Re[76]: Ультракороткий язык программирования RS - Компьютерные священные войны

Здравствуйте, Lloyd, Вы писали:

L>Здравствуйте, PC_2, Вы писали:

M>>>

M>>>[1..2].foldLeft(любая_функция)
M>>>

PC_>>да не. Слишком много букв

M>>>горазддо понятнее, чем

M>>>

M>>>1..2\*
M>>>

M>>>особенно если кода больше, чем одна строчка

PC_>>Обратный слеш напоминает блок который развернут в другую сторону и пытается "схлопнуть" то что слева.
PC_>>Так что ультрапонятно и ультракоротко. Кстате раньше этот оператор назывался по другому, но теперь все пучком

L>А как будет выглядеть правый fold?

ну ясен перец

*/1..2

потому что напоминает слеш, который пытается схлопнуть то, что справа

а потом произойдет коллапс вселенной:

*/1..2\*

Здравствуйте, samius, Вы писали:

S>Здравствуйте, PC_2, Вы писали:

M>>>Память будет тратиться только на собственно результат

Миллион я не высичлял, но 100 000 вполне спокойно обрабатывает.

M>>>Думаю, на PC_2 фиг сделаешь.

PC_>>Чо-чо, на РС не сделаешь ?

PC_>>А так

PC_>>

PC_>>Sum:=1
PC_>>Sum*=(I<1048576?I)
PC_>>

S>Operators: S1
S>Object reference not set to an instance of an object.
S>================
S>Sum:=1

S>Sum:=1
S>...um:=1
S>......1
S>S1

S>S:=1
S>S*=(I<1048576?I)
S>

S>Operators: 1Expression
S>Object reference not set to an instance of an object.
S>================
S>S:=1

S>S:=1
S>...S:=1
S>......1
S>S*=(I<1048576?I)
S>I=0;
S>S*=Expression
S>...1*=
S>......1
S>1Expression

Там если я пишу код
S:=1
S*=(I<1048576?I)

То подразумеваю код
E S:=1
E S*=(I<1048576?I)

E от слова Expression, начало выражения

Поэтому код может быть отформатирован еще вот так

E S:=1
E S*=(
       I<1048576
       ?I
     )

Но на самом деле там действительно есть баг, можно сделать еще круче и проще

E S:=1
E !N:=1..1048576
E S*=N

Правда не уверен что на версии полторамесячной давности это отработает, но всеже. Код полность корректен, может и есть баги, но они как вы понимаете фиксятся, это мелочевка

Здравствуйте, Mamut, Вы писали:

M>Здравствуйте, Lloyd, Вы писали:

L>>Здравствуйте, PC_2, Вы писали:

M>>>>

M>>>>[1..2].foldLeft(любая_функция)
M>>>>

PC_>>>да не. Слишком много букв

M>>>>горазддо понятнее, чем

M>>>>

M>>>>1..2\*
M>>>>

M>>>>особенно если кода больше, чем одна строчка

PC_>>>Обратный слеш напоминает блок который развернут в другую сторону и пытается "схлопнуть" то что слева.
PC_>>>Так что ультрапонятно и ультракоротко. Кстате раньше этот оператор назывался по другому, но теперь все пучком

L>>А как будет выглядеть правый fold?

M>ну ясен перец

M>*/1..2
M>

M>потому что напоминает слеш, который пытается схлопнуть то, что справа

M>а потом произойдет коллапс вселенной:
M>

M>*/1..2\*
M>

Молодец, даже отметил улыбкой. Ты уже начинаешь думать в моем стиле.
Одним словом, свой язык — делай шо хошь

Кстате рациональные идеи приветствуются

M>>>>>

M>>>>>[1..2].foldLeft(любая_функция)
M>>>>>

PC_>>>>да не. Слишком много букв

M>>>>>горазддо понятнее, чем

M>>>>>

M>>>>>1..2\*
M>>>>>

M>>>>>особенно если кода больше, чем одна строчка

PC_>>>>Обратный слеш напоминает блок который развернут в другую сторону и пытается "схлопнуть" то что слева.
PC_>>>>Так что ультрапонятно и ультракоротко. Кстате раньше этот оператор назывался по другому, но теперь все пучком

L>>>А как будет выглядеть правый fold?

PC_>Молодец, даже отметил улыбкой. Ты уже начинаешь думать в моем стиле.
PC_>Одним словом, свой язык — делай шо хошь

Ты не ответил на выделенный выше вопрос

PC_>Кстате рациональные идеи приветствуются

Перестать гнаться за "понятностью" наследников apl

PC_>Там если я пишу код
PC_>S:=1
PC_>S*=(I<1048576?I)

PC_>То подразумеваю код
PC_>E S:=1
PC_>E S*=(I<1048576?I)

PC_>E от слова Expression, начало выражения

Нахрена?

PC_>Поэтому код может быть отформатирован еще вот так

PC_>

PC_>E S:=1
PC_>E S*=(
PC_>       I<1048576
PC_>       ?I
PC_>     )
PC_>

PC_>Но на самом деле там действительно есть баг, можно сделать еще круче и проще

PC_>

PC_>E S:=1
PC_>E !N:=1..1048576
PC_>E S*=N
PC_>

Почему это — умножение на все элементы массива, а не умножение каждого элемента массива на S? Также жду ответа тут: http://rsdn.ru/forum/philosophy/4088555.1.aspx

Здравствуйте, Mamut, Вы писали:

M>>>>>>

M>>>>>>[1..2].foldLeft(любая_функция)
M>>>>>>

PC_>>>>>да не. Слишком много букв

M>>>>>>горазддо понятнее, чем

M>>>>>>

M>>>>>>1..2\*
M>>>>>>

M>>>>>>особенно если кода больше, чем одна строчка

PC_>>>>>Обратный слеш напоминает блок который развернут в другую сторону и пытается "схлопнуть" то что слева.
PC_>>>>>Так что ультрапонятно и ультракоротко. Кстате раньше этот оператор назывался по другому, но теперь все пучком

L>>>>А как будет выглядеть правый fold?

PC_>>Молодец, даже отметил улыбкой. Ты уже начинаешь думать в моем стиле.
PC_>>Одним словом, свой язык — делай шо хошь

M>Ты не ответил на выделенный выше вопрос

Правого фолда нет, как и значения аккумулятора.
Это базовая упрощенная операция.

Здравствуйте, PC_2, Вы писали:

PC_>Здравствуйте, samius, Вы писали:

PC_>Там если я пишу код
PC_>S:=1
PC_>S*=(I<1048576?I)

PC_>То подразумеваю код
PC_>E S:=1
PC_>E S*=(I<1048576?I)

Да, и подразумеваешь что он работает. Это я уже понял.

E S:=1
E S*=(I<5?I)

Operators: 1Expression
Object reference not set to an instance of an object.
=================
S:=1

S:=1
...S:=1
......1
S*=(I<5?I)
I=0;
S*=Expression
...1*=
......1
1Expression

PC_>E от слова Expression, начало выражения

PC_>Поэтому код может быть отформатирован еще вот так

PC_>

PC_>E S:=1
PC_>E S*=(
PC_>       I<1048576
PC_>       ?I
PC_>     )
PC_>

E S:=1
E S*=(
       I<2
       ?I
     )

Index was out of range. Must be non-negative and less than the size of the collection.
Parameter name: index
S:=1

S:=1
...S:=1
......1
S*=(

S*=
...1*=
......1
I<2
I=0;
0<2
...0<2
......True
I=1;
1<2
...1<2
......True
I=2;
2<2
...2<2
......False
I=3;
3<2
...3<2
......False
I=4;
4<2
...4<2
......False
I=5;
5<2
...5<2
......False
I=6;
6<2
...6<2
......False
I=7;
7<2
...7<2
......False
I=8;
8<2
...8<2
......False
I=9;
9<2
...9<2
......False
?I

PC_>Но на самом деле там действительно есть баг, можно сделать еще круче и проще

PC_>

PC_>E S:=1
PC_>E !N:=1..1048576
PC_>E S*=N
PC_>

Unable to cast object of type 'RS.DOM.Types.MutableName' to type 'RS.DOM.Types.Mutable'.
S:=1

S:=1
...S:=1
......1
N:=1..1048576

PC_>Правда не уверен что на версии полторамесячной давности это отработает, но всеже. Код полность корректен, может и есть баги, но они как вы понимаете фиксятся, это мелочевка

Оперирую чем есь, конечно мелочевка.

PC_>>>>>>Обратный слеш напоминает блок который развернут в другую сторону и пытается "схлопнуть" то что слева.
PC_>>>>>>Так что ультрапонятно и ультракоротко. Кстате раньше этот оператор назывался по другому, но теперь все пучком

L>>>>>А как будет выглядеть правый fold?

PC_>>>Молодец, даже отметил улыбкой. Ты уже начинаешь думать в моем стиле.
PC_>>>Одним словом, свой язык — делай шо хошь

M>>Ты не ответил на выделенный выше вопрос

PC_>Правого фолда нет, как и значения аккумулятора.

Почему?

PC_>Это базовая упрощенная операция.

Теперь по-русски. И с примером, если можно.

Здравствуйте, Mamut, Вы писали:

PC_>>Там если я пишу код
PC_>>S:=1
PC_>>S*=(I<1048576?I)

PC_>>То подразумеваю код
PC_>>E S:=1
PC_>>E S*=(I<1048576?I)

PC_>>E от слова Expression, начало выражения

M>Нахрена?

За темже хреном что каждое сишное выражение заканчивается точкой с запятой. Я сделал круче, у меня начинается каждое выражение с E.
Начинаться может еще с G ( группа ) или с D ( декларация )
Таким образом при первом беглом взгляде на строчку сразу видно что это обьявлено. Группа, Выражение или Декларация, достаточно взглянуть на первый символ

PC_>>Поэтому код может быть отформатирован еще вот так

PC_>>

PC_>>E S:=1
PC_>>E S*=(
PC_>>       I<1048576
PC_>>       ?I
PC_>>     )
PC_>>

PC_>>Но на самом деле там действительно есть баг, можно сделать еще круче и проще

PC_>>

PC_>>E S:=1
PC_>>E !N:=1..1048576
PC_>>E S*=N
PC_>>

M>Почему это — умножение на все элементы массива, а не умножение каждого элемента массива на S? Также жду ответа тут: http://rsdn.ru/forum/philosophy/4088555.1.aspx

!N:=1..1048576

Это инициализация мутабл переменной, а не массива. Тоесть по сути это не массив.
I и J это встроенные мутабл переменные, можно обьявлять еще свои, указывая диапазоны их изменения.

Здравствуйте, samius, Вы писали:

S>Здравствуйте, PC_2, Вы писали:

PC_>>Здравствуйте, samius, Вы писали:

PC_>>Там если я пишу код
PC_>>S:=1
PC_>>S*=(I<1048576?I)

PC_>>То подразумеваю код
PC_>>E S:=1
PC_>>E S*=(I<1048576?I)

S>Да, и подразумеваешь что он работает. Это я уже понял.
S>

S>E S:=1
S>E S*=(I<5?I)
S>

S>Operators: 1Expression
S>Object reference not set to an instance of an object.
S>=================
S>S:=1

S>S:=1
S>...S:=1
S>......1
S>S*=(I<5?I)
S>I=0;
S>S*=Expression
S>...1*=
S>......1
S>1Expression

PC_>>E от слова Expression, начало выражения

PC_>>Поэтому код может быть отформатирован еще вот так

PC_>>

PC_>>E S:=1
PC_>>E S*=(
PC_>>       I<1048576
PC_>>       ?I
PC_>>     )
PC_>>

S>E S:=1
S>E S*=(
S>       I<2
S>       ?I
S>     )
S>

S>Index was out of range. Must be non-negative and less than the size of the collection.
S>Parameter name: index
S>S:=1

S>S:=1
S>...S:=1
S>......1
S>S*=(

S>S*=
S>...1*=
S>......1
S>I<2
S>I=0;
S>0<2
S>...0<2
S>......True
S>I=1;
S>1<2
S>...1<2
S>......True
S>I=2;
S>2<2
S>...2<2
S>......False
S>I=3;
S>3<2
S>...3<2
S>......False
S>I=4;
S>4<2
S>...4<2
S>......False
S>I=5;
S>5<2
S>...5<2
S>......False
S>I=6;
S>6<2
S>...6<2
S>......False
S>I=7;
S>7<2
S>...7<2
S>......False
S>I=8;
S>8<2
S>...8<2
S>......False
S>I=9;
S>9<2
S>...9<2
S>......False
S>?I

PC_>>Но на самом деле там действительно есть баг, можно сделать еще круче и проще

PC_>>

PC_>>E S:=1
PC_>>E !N:=1..1048576
PC_>>E S*=N
PC_>>

S>Unable to cast object of type 'RS.DOM.Types.MutableName' to type 'RS.DOM.Types.Mutable'.
S>S:=1

S>S:=1
S>...S:=1
S>......1
S>N:=1..1048576

PC_>>Правда не уверен что на версии полторамесячной давности это отработает, но всеже. Код полность корректен, может и есть баги, но они как вы понимаете фиксятся, это мелочевка

S>Оперирую чем есь, конечно мелочевка.

Ладно, тут работы подкинули срочной. Седне пофиксю. Там на 10 мин. дела

PC_>>>E от слова Expression, начало выражения

M>>Нахрена?

PC_>За темже хреном что каждое сишное выражение заканчивается точкой с запятой. Я сделал круче, у меня начинается каждое выражение с E.
PC_>Начинаться может еще с G ( группа ) или с D ( декларация )
PC_>Таким образом при первом беглом взгляде на строчку сразу видно что это обьявлено. Группа, Выражение или Декларация, достаточно взглянуть на первый символ

Так подавляющее большинство действий в программировании — это expression, е не нужен

PC_>>>

PC_>>>E S:=1
PC_>>>E !N:=1..1048576
PC_>>>E S*=N
PC_>>>

M>>Почему это — умножение на все элементы массива, а не умножение каждого элемента массива на S? Также жду ответа тут: http://rsdn.ru/forum/philosophy/4088555.1.aspx

PC_>!N:=1..1048576

PC_>Это инициализация мутабл переменной, а не массива. Тоесть по сути это не массив.

О да.

Generate, //.. генерация чего? -> Массивов ясен перец, 1..5 не забыл ?

Язык настолько ультрапонятен и просот, что одинаковая операция в нем то массив объявляет, то мутабельную переменную

Итак, согласно твоим же словам !N:=1..1048576 генерирует массив значений. Возвращаемся к вопросу. почему S*=N — это умножение на все элементы массива, а не умножение каждого элемента массива на S?

Также жду ответа тут: http://rsdn.ru/forum/philosophy/4088555.1.aspx

Здравствуйте, Lloyd, Вы писали:

L>Приведенный код ничем не лучше в плане потребления памяти (хвостовой рекурсии-то нету). Пожалуй даже хуже, т.к. стек по размеру мягко говоря обычно меньше размера доступной оперативки.

От же-шь занудные вы...

def factorial(n, i = 1){ | (0,_) | (1,_) => i | _ => factorial(n - 1, i * n)}

... << RSDN@Home 1.2.0 alpha 4 rev. 1472>>

Здравствуйте, PC_2, Вы писали:

M>>Ответь на неглупый. Вернее перепиши его так, чтобы он стал эквивалентен приведенному коду — без дикого жора памяти

PC_>Мамут не стоит настаивать на ерунде.
PC_>Я то напишу, не вопрос и смогу работать с числами которые имеют, например, миллиард разрядов.
PC_>Как это сделал с рациональными числами, архитектура у меня позволяет еще не такое делать,

Мой вопрос был не о максимальной разрядности чисел. Спрошу четче: для итерирования последовательности из n элементов в приведенных примерах создаются массивы для хранения их индексов. Это — единственный способ организации итераций? Если нет, то можно увидеть, как будет выглядеть альтернативный способ?

PC_>но зачем, вот например Немерла не обуздает эту проблему никакими макросами, потому что пасется на типах Шарпа, ксате говоря довольно скудных

Немерл не "пасется на типах Шарпа", они вместе с шарпом "пасутся" на системе типов .NET, в 4-ой версии которой есть такой тип как BigInteger, разрядность которого ограничена лишь объемом доступной памяти.

"пасется на типах Шарпа, ксате говоря довольно скудных" — довольно красноречиво говорит об уровне вашего знакомства с платформой. Как при этом можно столь уверенно подвергать критике языки, не имея о них даже поверхностного представления — за гранью моего понимания

... << RSDN@Home 1.2.0 alpha 4 rev. 1472>>

Здравствуйте, PC_2, Вы писали:

PC_>Здравствуйте, samius, Вы писали:

PC_>>>Правда не уверен что на версии полторамесячной давности это отработает, но всеже. Код полность корректен, может и есть баги, но они как вы понимаете фиксятся, это мелочевка

S>>Оперирую чем есь, конечно мелочевка.

PC_>Ладно, тут работы подкинули срочной. Седне пофиксю. Там на 10 мин. дела

Не спеши. Даже если пофиксишь, то оверхеду на вот такое действие
E S*=(I<2?I)
будет столько, что функциональный квиксорт покажется пределом оптимизации.

Здравствуйте, Mamut, Вы писали:

PC_>>>>E от слова Expression, начало выражения

M>>>Нахрена?

PC_>>За темже хреном что каждое сишное выражение заканчивается точкой с запятой. Я сделал круче, у меня начинается каждое выражение с E.
PC_>>Начинаться может еще с G ( группа ) или с D ( декларация )
PC_>>Таким образом при первом беглом взгляде на строчку сразу видно что это обьявлено. Группа, Выражение или Декларация, достаточно взглянуть на первый символ

M>Так подавляющее большинство действий в программировании — это expression, е не нужен

Мамут не совсем языкостроитель, но скилы растут

Экспрешин нужно чтобы форматировать код нормально.

Например Си

a = 1<2 &&
    A<b &&
    A>C &&
    F<K;

Точка с запятой нужна, это же не бейсик, и транслятор не знает где заканчивается выражение, он может это принять за
несколько выражений

a = 1<2 &&;
A<b &&;
A>C &&;
F<K;

у меня

E a = 1<2 &
    A<b &
    A>C &
    F<K

	От:	Sinix
	Дата:	22.12.10 09:52
	Оценка:	+1

От:	Mamut	http://dmitriid.com
Дата:	22.12.10 09:54
Оценка:

От:	PC_2	http://code.google.com/p/rsinterpretator/
Дата:	22.12.10 09:55
Оценка:

От:	PC_2	http://code.google.com/p/rsinterpretator/
Дата:	22.12.10 09:58
Оценка:

От:	Mamut	http://dmitriid.com
Дата:	22.12.10 09:59
Оценка:

От:	samius	http://sams-tricks.blogspot.com
Дата:	22.12.10 10:02
Оценка:	51 (1)

От:	kochetkov.vladimir	https://kochetkov.github.io
Дата:	22.12.10 10:12
Оценка: