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

KV>>"выглядит примерно вот так, хоть пока и не работает" (с)

PC_>У меня в первом списке список программ. И они прекрасно работают.
PC_>Решения в студию от Немерла для всех их пожалуйста.

Да не вопрос:

PC_>//1. факториал
PC_>E 1..5\*

Вы уж определитесь что мы сравниваем: краткость записи стандартных математических операций или же алгоритмов их реализации. Ибо в первом случае, ваш язык сольет немерлу по полной, т.к. позволяет расширять свой синтаксис почти без ограничений:

public macro @!(e1)
syntax (e1, "!")
{
    <[
        $[1..$e1].FoldLeft(1,_*_)
    ]>
}

// После чего мы можем использовать вот такую запись

WriteLine(5!);

// В результате будет выведено "120"

Если же имеет место второй случай, то из записи "E 1..5\*" ну никак не следует, что это является именно факториалом, если не поломать голову и, исходя от обратного, не предположить, что "\" означает "применить операцию", а "*" то, какую операцию нужно применить. Я сначала это вообще за оставленный по ошибке комментарий принял. В немерловском варианте, этот алгоритм можно найти в макре между <[ и ]> :

$[1..5].FoldLeft(1,_*_)

причем это, в отличии от вашего варианта, именно алгоритм, а не "так захотелось автору языка" и читается как "взять диапазон от 1 до 5 и применить к нему операцию левой свертки, умножая текущий элемент с аккумулятором, имеющим по умолчанию значение 1".

И правильно ли я понимаю, что выражение "1..5" означает "создать массив из пяти элементов, в котором X[i] = i"? Но ведь тогда, для того, чтобы посчитать факториал 1048576, ваша программа отожрет 1 мегабайт памяти только для формирования индексов, в то время, как в том же немерле можно обойтись по старинке:

def factorial(n){ | 0 | 1 = > 1 | _ => factorial(n — 1)}

и никаких мегабайтов отожрано не будет (к вопросу о вашем замечании по поводу быстрой сортировки).

И вообще, как там у вас в языке с ленивыми вычислениями? Можно ли задать последовательность из 10 тысяч элементов, которая будет формироваться по мере необходимости (а-ля функции-генераторы в питоне).

PC_>//2. фибоначчи
PC_>E X:=1..10
PC_>E X.(I+2):=X.I+X.(I+1)
PC_>E X

def f(n) { | 0 | 1 => 1 | _ => f(n-2) + f(n-1) }
def X = $[1..10].Map(f);
WriteLine(X);

PC_>//3. сортировка пузырьком
PC_>E X:=1..10
PC_>E X.I>X.J?X.I:=:X.J
PC_>E X

Здесь среднюю строчку можно было бы и выкинуть, ибо зачем сортировать уже упорядоченную последовательность? Но, ок:

mutable X = $[1..5].ToArray();
_= X.IterI((i, _) => X.IterI((j, _) => when (X[i] < X[j]) X[i] <-> X[j]));
WriteLine(X.ToList())

Кстати, а как у вас обстоят дела с типами? Как будет в этом случае выглядеть сортировка, скажем, строк? Или произвольных объектов? Или функций (если конечно они у вас есть и являются первоклассными)?

PC_>//4. палиндром
PC_>E X:=1,2,3,2,1
PC_>E B:=True
PC_>E B:=B&(X.(5/2-I)=X.(5/2+I))
PC_>E B

mutable X = array[1, 2, 3, 2, 1];
mutable B = true;
_ = $[0..2].IterI((i, _) => {B = B && (X[i] == X[5-i])});
WriteLine(B);

PC_>//5. revers
PC_>E X:=1..5
PC_>E X.(5/2-I):=:X.(5/2+I))
PC_>E X

def reverse(lst, acc = [])
{
| (head :: tail, _) => reverse(tail, head :: acc)
| ([], _) => acc
}
// А теперь, заодно, проверим список на палиндромность еще раз
def X = [1, 2, 3, 2, 1];
WriteLine(reverse(X) == X);

PC_>//6. проверка на простое число
PC_>E X:=6
PC_>E X%2..(X-1)\<

def X = 6;
def B = $[2..X - 1].Fold(true, (x, a) => a && (X % x != 0));
WriteLine(B);

KV>>Я предлагаю сначала поиграть в другую игру: уберите комментарии, объясняющие предназначение каждого сниппета и опросите местный народ на предмет понимания ими того, что делает каждый из кусков кода. Кстати, а зачем эти комментарии вообще понадобились в черезвычайно легком в понимании языке?

PC_>Немерла хоть комментируй хоть не комментируй, разобраться сложно.

Вы в дискусии на что-то более конструктивное, чем "сам дурак", способны? Или сворачиваем беседу? Я пока еще жду внятного ответа на свой вопрос.

KV>>Все дело в том, что он не только от архитектуры оторван

PC_>А от чего еще ?

От реальности. Наиболее хардкорными потребителями сокращенных синтаксисов являются математики. Но у них уже есть масса функциональных языков, поддерживающих фактически их DSL, так сказать, и матлаб впридачу. Для промышленного программирования краткость синтаксиса вообще не является определяющим фактором по сравнению с читаемостью и легкостью поддержки. То, что увидел я из приведенных вами примеров, лично у меня оставило впечатление брейнфака для математиков, в котором количество языковых конструкций на порядки меньше нежели количество неоднозначностей и "неинтуитивностей".

PC_>А пока Немерла, пускай для меня, пасет задних. Пускай и на том наборе простых типовых программ.

Будете капризничать — вообще Влада позову

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

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

S>>Мне что-то кажется, что ты не знаешь, как выглядит пузырек. Там есть одна тонкость, второй цикл там от i+1, что в твоем пузырьке никак не отражено.

F>Ты еще не вкурил идею, что диапазоны применения счетчиков могут быть любые — интерпретатор определят их из намеряний программиста, которые тот должен четко протелепатировать?

F>Автор же сам пишет:
F>

F>Это счетчик, интерпретатор сам решает каким быть этому счетчику.

F>Это же очень удобно! Например, надо перевернуть массив "задом наперед":

F>X := 1..10
F>X.I := :X.I

F>А если надо перевернуть только первую половину массива, а вторую оставить без изменений, то это будет:

F>X := 1..10
F>X.I := :X.I

F>Как видишь, программирование с помощью паттернов выходит на качественно новый уровень!

Чесно, я не понял о чем ты пишешь.
Если тебе нужно заполнить массив до половины ( до 5го элемента ), то можешь сделать примерно так:

Х.(I<5?I) := I

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

PD>Здравствуйте, kochetkov.vladimir, Вы писали:

KV>>Что даст еще большее упрощение записи алгоритма, по сравнению с его математическим представлением ?

PD>Рекурсивная формула для вычисления чисел Фиббоначчи очень проста, но да поможет бог тому, кто вздумает вычислять их рекурсивно при достаточно больших N.
PD>Иная простота хуже воровства.

У меня итеративная реализация

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

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

PC_>>>Это уже оптимизация пузырька, как и досрочный выход из пузырька если за обход небыло не одной перестановки.
S>>Это не оптимизация, а необходимое условие для того что бы не переставлять уже переставленные элементы. Если условия нет, то в результате бардак.

PC_>Тоесть ты хочешь сказать что без твоего супер условия i+1 сортировка не выполнится ?

PC_>Спасибо, ты развеял мои сомнения относительно своей квалификации
Да, в действительности бардака не будет. Однако работа алгоритма ничего общего не имеет с пузырьком. Минимальный элмент сначала уходит в самое начало, после чего продвигается до самого конца.

Твой пузырек по отношению к оригинальному еще хуже чем функциональный квиксорт по отношению к инплейс квиксорту.

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


Спасибо, посчитал что средняя программа на Немерле на простых примерах примерно в три раза — четыре раза длинее.
Ну и малопонятней, учитывая количество шифтовых символов и т.д. Но последнее, как понимаете субьективно. Ну да ладно.


KV>От реальности. Наиболее хардкорными потребителями сокращенных синтаксисов являются математики. Но у них уже есть масса функциональных языков, поддерживающих фактически их DSL, так сказать, и матлаб впридачу. Для промышленного программирования краткость синтаксиса вообще не является определяющим фактором по сравнению с читаемостью и легкостью поддержки. То, что увидел я из приведенных вами примеров, лично у меня оставило впечатление брейнфака для математиков, в котором количество языковых конструкций на порядки меньше нежели количество неоднозначностей и "неинтуитивностей".

PC_>>А пока Немерла, пускай для меня, пасет задних. Пускай и на том наборе простых типовых программ.

KV>Будете капризничать — вообще Влада позову

Причем тут математики.
Короткий и мощный синтаксис это же очень классно.
Вот когда у меня рождается в голове микро программа, я просто сажусь и набираю ее за минуту-две.
Ну где еще такое возможно ? Программы настолько лаконичны, что я их держу в памяти, и их набирать могу на клавиатуре мобильного.

Вместе с тем на стандартном языке Шарп, Немерла, Джава, написание таких программок превращается в маленький геморой.

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

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

PC_>Раз ты не скачал транслятор и являешся распространителем своих догадок, то зачем мне отвечать на твои вопросы и тратить на тебя свое время ?
PC_>Мне это неинтересно.
А мне интересно как ты выкручиваешься. Вот-вот начну баллы ставить.

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

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

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

PC_>>>>Это уже оптимизация пузырька, как и досрочный выход из пузырька если за обход небыло не одной перестановки.
S>>>Это не оптимизация, а необходимое условие для того что бы не переставлять уже переставленные элементы. Если условия нет, то в результате бардак.

PC_>>Тоесть ты хочешь сказать что без твоего супер условия i+1 сортировка не выполнится ?

PC_>>Спасибо, ты развеял мои сомнения относительно своей квалификации
S>Да, в действительности бардака не будет. Однако работа алгоритма ничего общего не имеет с пузырьком. Минимальный элмент сначала уходит в самое начало, после чего продвигается до самого конца.

Еще раз подумай еще раз над тем что ты пишешь, прежде чем прислать.
Помойму ты лажанулся второй раз вподряд.

S>Твой пузырек по отношению к оригинальному еще хуже чем функциональный квиксорт по отношению к инплейс квиксорту.

Неужто ?

Ну давай выполним твою супер оптимизацю, благо на РС чтобы накодить пузырек мне нужно не больше времени чем написать половину последнего предложения:

X.I>X.(J>I?J)?X.I:=:X.J

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

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

PC_>>>Тоесть ты хочешь сказать что без твоего супер условия i+1 сортировка не выполнится ?

PC_>>>Спасибо, ты развеял мои сомнения относительно своей квалификации
S>>Да, в действительности бардака не будет. Однако работа алгоритма ничего общего не имеет с пузырьком. Минимальный элмент сначала уходит в самое начало, после чего продвигается до самого конца.

PC_>Еще раз подумай еще раз над тем что ты пишешь, прежде чем прислать.
Я даже посмотрел на этот процесс в отладчике

PC_>Помойму ты лажанулся второй раз вподряд.
Помойму лажа у тебя. Ты говоришь что квиксорт не квиксорт а сам пишешь пузырек — не пузырек.

S>>Твой пузырек по отношению к оригинальному еще хуже чем функциональный квиксорт по отношению к инплейс квиксорту.

PC_>Неужто ?
В пузырьке элементы только "всплывают" а у тебя и "всплывают" и "тонут".

PC_>Ну давай выполним твою супер оптимизацю, благо на РС чтобы накодить пузырек мне нужно не больше времени чем написать половину последнего предложения:

X.I>>X.(J>I?J)?X.I:=:X.J
Допустим что оно работает.
Но притом что ты радеешь за суперлаконичность и сверхпонятность своего языка, на поверку оказывается что код делает не совсем то, за что ты его выдаешь. Как минимум с первого раза.

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

PC_>Ну давай выполним твою супер оптимизацю, благо на РС чтобы накодить пузырек мне нужно не больше времени чем написать половину последнего предложения:

X.I>>X.(J>I?J)?X.I:=:X.J

А по-моему ты здесь сравнил элементы массива, а не значения индексов.

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

PC_>Наверное, этот код делает тоже что делает

Наверное? Т.е. ты даже сам не понимаешь, как работает твой язык?

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

S>В пузырьке элементы только "всплывают" а у тебя и "всплывают" и "тонут".

Чтото ты не доглядел.
За одну итерацию в оригинальном алгоритме мы подымаем 1 элемент. Ничего там не тонет.
Просто к элементу который однажды "всплыл", уже понятно что он максимальный, и возвращаться к нему не стоит. А я возвращаюсь в первой реализации алгоритма и не возвращаюсь уже во второй реализации.

PC_>>Ну давай выполним твою супер оптимизацю, благо на РС чтобы накодить пузырек мне нужно не больше времени чем написать половину последнего предложения:

X.I>>>X.(J>I?J)?X.I:=:X.J
S>Допустим что оно работает.
S>Но притом что ты радеешь за суперлаконичность и сверхпонятность своего языка, на поверку оказывается что код делает не совсем то, за что ты его выдаешь. Как минимум с первого раза.

Он делает то что я декларирую.
Если ты говоришь что там нет такихто оптимизаций, то я говорю, что их там нет и показываю как добавить.
Что еще нужно ?

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

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

PC_>>Наверное, этот код делает тоже что делает

24>Наверное? Т.е. ты даже сам не понимаешь, как работает твой язык?

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

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

PC_>Тут рейс эксепшина скорей всего будет...

Рейс эксепшина перекатывался и падал вниз стремительным домкратом!

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

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

PC_>>Тут рейс эксепшина скорей всего будет...

A>Рейс эксепшина перекатывался и падал вниз стремительным домкратом!

Да не, там будет нормальный рантайм эррор.
Типо такаято операция не определена для таких то типов.

А так программы на языке черезвычайно живучи.
Я даже позаимствовал из баз данных понятие NULL.

Если при любой операции получилось это значение то в итоге тоже будет NULL.
Фактически программист исбавлен от бесконечной проверки граничных условий.

Ну какими макросами Немерла такое реализуешь ?

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

Знакомься:
* АПЛ
* J
* K

Не знаю насколько быстро на них писать, но читать их кода нельзя.

Ну, и от краткости записи сами алгоритмы проще не становятся. Если бы это было так, то лучшим способом упростить программу было бы сжатие ее исходного кода zip-ом.

Сегодня в языках ценится выразительность и средства декомпозиции (классы, функции высшего порядка, сопоставление с образцом, макросы).

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

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

PC_>А вот ты не понимаешь как читать тему от начала до конца

Тему я как раз прочёл всю, и слежу за обновлениями, давно таких весёлых тем не было

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

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

VD>Знакомься:
VD>* АПЛ
VD>* J
VD>* K

VD>Не знаю насколько быстро на них писать, но читать их кода нельзя.

Ну упоминал я уже Влад эти языки, языки эти короткие но не понятные.
Используют юникод и тд тп. Я к проектированию синтаксиса подошел основательно. Птичести языка обьявлен бой.
Цель получить и короткий и понятный язык.

VD>Ну, и от краткости записи сами алгоритмы проще не становятся. Если бы это было так, то лучшим способом упростить программу было бы сжатие ее исходного кода zip-ом.
VD>Сегодня в языках ценится выразительность и средства декомпозиции (классы, функции высшего порядка, сопоставление с образцом, макросы).
VD>В прочем, возможно это изначально была шутка. Тогда она удалась.

Никаких шуток, есть рабочий транслятор и рабочий набор примеров и еще не вспаханое поле аспектного программирования.
Я хочу это неклюжее ООП заменить исключительно гибкой структурой построеной на распозновании классов.

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

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

S>>В пузырьке элементы только "всплывают" а у тебя и "всплывают" и "тонут".

PC_>Чтото ты не доглядел.
PC_>За одну итерацию в оригинальном алгоритме мы подымаем 1 элемент. Ничего там не тонет.
PC_>Просто к элементу который однажды "всплыл", уже понятно что он максимальный, и возвращаться к нему не стоит. А я возвращаюсь в первой реализации алгоритма и не возвращаюсь уже во второй реализации.
Просто напиши эквивалентный код на С# и погляди на то что происходит в отладчике, если у тебя нет отладчика твоего чуда.

X.I>X.(J>I?J)?X.I:=:X.J
S>>Допустим что оно работает.
S>>Но притом что ты радеешь за суперлаконичность и сверхпонятность своего языка, на поверку оказывается что код делает не совсем то, за что ты его выдаешь. Как минимум с первого раза.

PC_>Он делает то что я декларирую.
Любой код делает то что продекларировал автор, безотносительно того, что автор имел в виду.
PC_>Если ты говоришь что там нет такихто оптимизаций, то я говорю, что их там нет и показываю как добавить.
PC_>Что еще нужно ?
Ты чего хотел достичь когда писал сюда? Вот что тебе нужно? Продемонтрировать лаконичность и понятность? Пока ты продемонстрировал то, что ты выдаешь некий код за решение неких задач, притом что этот код решает задачи либо какие-то другие, либо не так как заявлено. Что в общем-то ставит под сомнение лаконичность и понятность.

По реверсу комментарии будут?
Напомню

//5. revers
E X:=1..5
E X.(5/2-I):=:X.(5/2+I))
E X
Напиши эквивалентный код на шарпе, а то мне кажется что половина итераций пройдет по уже переписанному массиву, если твой код работает inplace.

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

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

Смотри, все харьки, задают глупые вопросы и не понимают твоего кода.
А между прочим ты обещал, что "Кодить на нем будет действительно просто и быстро". Какой же кодить, если люди даже понять его не могут?

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

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

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

S>>>В пузырьке элементы только "всплывают" а у тебя и "всплывают" и "тонут".

PC_>>Чтото ты не доглядел.
PC_>>За одну итерацию в оригинальном алгоритме мы подымаем 1 элемент. Ничего там не тонет.
PC_>>Просто к элементу который однажды "всплыл", уже понятно что он максимальный, и возвращаться к нему не стоит. А я возвращаюсь в первой реализации алгоритма и не возвращаюсь уже во второй реализации.
S>Просто напиши эквивалентный код на С# и погляди на то что происходит в отладчике, если у тебя нет отладчика твоего чуда.

зачем мне писать я и так знаю что он делает.
А ты сиди с отладчиком и дебажь пузырек

X.I>>X.(J>I?J)?X.I:=:X.J
S>>>Допустим что оно работает.
S>>>Но притом что ты радеешь за суперлаконичность и сверхпонятность своего языка, на поверку оказывается что код делает не совсем то, за что ты его выдаешь. Как минимум с первого раза.

PC_>>Он делает то что я декларирую.
S>Любой код делает то что продекларировал автор, безотносительно того, что автор имел в виду.
PC_>>Если ты говоришь что там нет такихто оптимизаций, то я говорю, что их там нет и показываю как добавить.
PC_>>Что еще нужно ?
S>Ты чего хотел достичь когда писал сюда? Вот что тебе нужно? Продемонтрировать лаконичность и понятность? Пока ты продемонстрировал то, что ты выдаешь некий код за решение неких задач, притом что этот код решает задачи либо какие-то другие, либо не так как заявлено. Что в общем-то ставит под сомнение лаконичность и понятность.

Что значит я выдаю некий код за решение неких задач. Я четко определил это множество задач уже работает на пре пре пре альфе, а эти еще в процессе.
В чем вопрос ? Что ты хочешь мне доказать ? Что у меня чтото не работает ? Так это смешно, я не теоретик, я практик, и компьютер прекрасно понимает все мои идеи воплощенные инженерной мыслью в трансляторе РС.
А ты иди с пузырьком в отладчике разбирайся, может в следующем семестре такая лаба тебе пригодится.

S>По реверсу комментарии будут?
S>Напомню

S>//5. revers
S>E X:=1..5
S>E X.(5/2-I):=:X.(5/2+I))
S>E X
S>Напиши эквивалентный код на шарпе, а то мне кажется что половина итераций пройдет по уже переписанному массиву, если твой код работает inplace.

Я не буду писать код на шарпе. Потому что реверс на шарпе написать это гемор на минут пять рабочего времени.
Что еще не понятно ?
Мне проще трижды на РС его написать, менее геморно.