итак, боремся с грустными смайликами

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

SQL. В принципе, неплохой язык. Как он работает? Пункты разделяются ключевыми словами, точнее, начинаются с ключевых слов select from, inner join, having. Но это не ЯП общего назначения.

Как и препроцессор Си

Мне кажется, язык без оператора присваивания вызовет много протестов на начальном этапе, хотя по большому счёту в этом нет ничего особо страшного.

Ну, можно не так экстремально (set <var> = <expr>), а просто строго разделять присваивание и сравнение, т.е., например, как в Си (= и == чтобы не сильно отпугивать), но выражение <var> = <expr> не должно возвращать ничего, т.е. не быть expr. Возможно, тогда можно будет парсить как SQL без точек-с-запятой.

Есть ещё Lua, где нет точек с запятой, но перенос строк не важен. Для этого надо соответствующую грамматику иметь.

Ты так не считаешь?

Мне не нравится голанг, но не из-за синтаксиса.

Golang'овский перенос как конец оператора - удобно.

Длинные строки, требующие переноса, возникают тогда, когда у функции много аргументов. Других вариантов я не могу придумать.

Ещё бывает long_name1(longName2(longName2(...(longNameN(x))))...);

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

Делай как в Tcl: несбалансированная любая скобка или кавычка.

Возможно, тогда можно будет парсить как SQL без точек-с-запятой.

Слабо верю в реальность такого счастья. lvalue/place может быть довольно кудрявым.

Есть ещё Lua, где нет точек с запятой, но перенос строк не важен.

Как это нет? http://www.lua.ru/doc/8.html

Конечно, тут уже и sql привели для примера, но я вспомнил, что в языке хранимых процедур MS SQL вызов процедуры тоже требует ключевого слова:

exec процедура параметр1, ..., параметрN

процедура1
процедура2

процедура1();
процедура2();

процедура1(процедура2);

2 den73: сколько разработчиков участвует в создании твоего языка? Тебе не кажется что развивать язык нужно учитывая просьбы пользователей языка? Кто знает, может те кто будут его пробовать и писать средние программы найдут его непригодным и молча перейдут на другой язык.

несбалансированная любая скобка или кавычка.

Что мне не нравилось в tcl? А вот что:

$btext configure -wrap [dict get $opts -wrap] \
    -xscrollcommand [list $w.sx set] \
    -yscrollcommand [list $w.sy set] \
    -foreground $COLOR(stdin) \
    -background $COLOR(bg) \
    -insertbackground grey \
    -font $::tkcon::OPT(font) -borderwidth 1 -highlightthickness 0 \
    -blockcursor 1  \
    -undo 1

Как это нет? http://www.lua.ru/doc/8.html

Ты же видишь: они опциональны от слова совсем. Вот это — работающий (хотя и плохо читаемый) код:

local i = 1 m = i + 3 for k = 1, m do print(k) end

Перенос на новую строку осуществляется с помощью

а зачем вообще нужен ручной перенос на новую строку, если есть word-wrap?

а чё там иметь? в том же С/С++ типичная строка выглядит как один из из следующих вариантов:

а) объявление

б) присваивание (=, +=, етк)

в) вызов ф-ции.

г) управляющие конструкции типа if,while

но объявление можно сделать так: аuto x(1), y(" "), z(MyClass(1, 1.0, ""). т.е. с использованием вывода типа можно в случае объявления полагаться на ключевое слово.

с присваиванием тоже ясно: если парсер находит нечто вида x = 2 + y, то, очевидно, переменная слева от знака присваивания является началом новой строки

про ф-ции выше написали.

с управляющими конструкциями аналогично как с ф-циями

* z(MyClass(1, 1.0, ""))

кстати можно и так:

z = MyClass(1, 1.0, "")

а можно x = int(), если непосредственную инициализацию хочется отложить.

для указателей можно что-то вроде: f = int*(nullptr)

Например, как я в коде отличу переменную от метода без параметров? например, в С вызов метода без параметров записывается так: greet() но не так: greet

Вывод типов предаёт дополнительную степень неявности.

вывод типов — отличная штука. потому, что писать всё время MyClass x = new MyClass() — идиотизм.

но дело не только в этом.

допустим у нас есть

class SuperMegaPuperClassNameWith100500SymbolsInName
{

};

и есть SuperMegaPuperClassNameWith100500SymbolsInName func();

auto x = func();

во-первых, замучаешься вводить SuperMegaPuperClassNameWith100500SymbolsInName вместо auto, во-вторых, если программист захочет поменять имя класса SuperMegaPuperClassNameWith100500SymbolsInName на SuperGigaPuperClassNameWith100500SymbolsInName, всё привет, привет ручная работа, ну или авторефракторинг с помощью внешних утилит, корректность результатов исполнения которых всё-равно, вероятно, придётся проверять вручную.

Выглядит опасным с точки зрения возникновения всяких неоднозначностей.

например?

Программист может в результате опечатки что-то пропустить или написать лишнее.

например?

в итоге получится «Не-Хмурый С» без смайликов, но мало кому понятный :-)

Это ты — тот анонимус со смайликами в соседних тредах?

Подобное я считаю большой ошибкой и никогда в свой язык такое не включу.

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

А ещё местами запятая используется чтобы разделить кортеж с одним элементом (а,) от просто переменной в скобках (а).

Практически я имел дело с двумя языками, где нет точек с запятой...

В OpenEuphoria тоже нет.

Вот это — работающий (хотя и плохо читаемый) код

Да, и легко написать осмысленный код, имеющий не тот смысл, который ты подразумеваешь. Вот цитата из какого-то введения:

ОЧЕНЬ ЧАСТО ОШИБКИ ВОЗНИКАЮТ ИЗ-ЗА ТОГО, ЧТО ПРОГРАММИСТ ЗАБЫЛ НАПИСАТЬ КЛЮЧЕВОЕ СЛОВО LOCAL ПЕРЕД ПЕРВЫМ ПРИСВАИВАНИЕМ ЛОКАЛЬНОЙ ПЕРЕМЕННОЙ И ЗАТЕР ТАКИМ ОБРАЗОМ ГЛОБАЛЬНУЮ. СЛЕДИ ЗА ОБЛАСТЬЮ ВИДИМОСТИ ТВОИХ ПЕРЕМЕННЫХ

Это говорит о том, что интерфейс языка плохо продуман.

А ещё местами запятая используется чтобы разделить кортеж с одним элементом (а,) от просто переменной в скобках (а)

Вот это уже осмысленное применение.

В смысле, в чём проблему видишь?

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

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

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

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

если парсер находит нечто вида x = 2 + y, то, очевидно

Неверно.

*
x = 2 + y

Большой перерыв. Сегодня точно не вернусь.

ОЧЕНЬ ЧАСТО ОШИБКИ ВОЗНИКАЮТ ИЗ-ЗА ТОГО, ЧТО ПРОГРАММИСТ ЗАБЫЛ НАПИСАТЬ КЛЮЧЕВОЕ СЛОВО LOCAL

Это известная проблема, да. Лучше было бы сделать как в Питоне.

Это говорит о том, что интерфейс языка плохо продуман.

Ты по одному этому факту так рассудил? Ты уверен, что твой Яр продуман значительно лучше?

Потом, ты просил язык без точек с запятой. Я тебе показал. Ты почему-то стал говорить, что без точек с запятыми жить плохо.

Но из Явы уже ничего не растёт. ;)

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

Scala не взлетела

Куча язычков мечтают о таком «не взлетела».

Не сочти за переход на личности, но какой популярности своего языка ожидаешь? И если окажешься единственным его пользователем, то значит ли это, что всё в языке плохо?

В лиспе это делается без синтаксического мусора.

Да, без «синтаксического мусора» в виде запятых, но ты их почему-то захотел. И теперь наворачиваешь один мусор поверх другого, чтобы подпереть костылями возникшие проблемы.

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

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

в С/С++, в выражениии *x «*» — спецсимвол, явным образом относящийся к «x»

а выражения вида «функ1(X) присваивание функ2(Ч)» не нужны

Что мне не нравилось в tcl?

в том что вам ненравится переносы строк \ легко убираются

$btext configure -wrap [dict get $opts -wrap] {*}{
    -xscrollcommand [list $w.sx set] 
    -yscrollcommand [list $w.sy set] 
    -foreground $COLOR(stdin) 
    -background $COLOR(bg) 
    -insertbackground grey 
    -font $::tkcon::OPT(font) -borderwidth 1 -highlightthickness 0 
    -blockcursor 1  
    -undo 1
}

По поводу go — это просто продолжение линейки: PL/I — B — C — Alef — Limbo — Go.

Нет. Вернее, таких «линеек» можно много расписать с одним корнем. Go не является продолжением C.

C (Thompson, Ritchie)

Ритчи был основным разработчиком Си. В последующих языках он участие не принимал.

Вот нашёл страничку:

https://wiki.theory.org/YourLanguageSucks

Хотя довольно дурацкая, но лучше чем ничего.

Она не просто дурацкая, она некорректная. Отстой полный.

смайлики

серьёзный аргумент

Да ладно?

Это ты — тот анонимус со смайликами в соседних тредах?

это не я. Не являюсь анонимусом довольно много лет

Сбацал на коленке маленькую програмку, котора бегает по википедии и смотрит в infobox какой язык на какой повлиял или возник под влиянием другого языка. (Influenced/Influenced by)

Получилось довольно таки интересно: https://www.dim13.org/images/langtree.svg

Получилось довольно таки интересно

сделайте это развидить :-)

Отож! :D

Лучше бы ты напечатал матрицу смежности.

Спасибо, буду знать. А как с компилятором байт-кода оно, нормально взаимодействует? Но этот синтаксис в любом случае слишком эзотерический, чтобы я его в свой язык вставил.

Ты по одному этому факту так рассудил? Ты уверен, что твой Яр продуман значительно лучше?

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

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

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

в С/С++, в выражениии *x «*» — спецсимвол, явным образом относящийся к «x»

a * x = b;

Что такое в этом выражении звёздочка? Имя типа, указателем на который мы объявляем x? или левый аргумент оператора *, результат которого имеет переопредёленную операцию = ?

Нет,, пример не приведу (это ж думать надо), но в целом некрасиво как-то выглядит, .

Да, без «синтаксического мусора» в виде запятых, но ты их почему-то захотел

Да не то, что я их захотел. Просто это нужно полностью вынести себе мозг, чтобы ещё и запятые выкинуть. Я без запятых в лиспе себя прекрасно чувствую, да и в tcl ничего. Зато в лиспе скобки достали. А если скобки выкинуть, то нужно что-то вместо них. Например, запятые.

tcl был бы идеалом, если сделать:

- жадное выполнение как в лиспе - выкинуть эзотерические строки и сделать вместо них нормальные макросы - сделать синтаксис доступа к полям «объект.поле» - решить вопрос с переносом строк (впрочем, пример уже показали)

Но пугает меня в tcl ещё и expr. В общем-то сама по себе идея очень здравая. Арифметика нужна редко, а её парсер изрядно добавляет сложности и неразберихи. Но это нужно преодолеть определённый барьер вхождения. Некоторые начинают знакомство с язком с hello,world, а некоторые с 2+2. В лиспе это полный пипец, а в tcl тоже не сахар. То, что expr кое-где (в циклах и if-ах) неявно вставляется, только увеличивает недоумение.

Хотя вот тебе пример по мотивам предыдущего:

print_va_args(a,*b);
print_va_args(,a*b); // в языке, где можно пропускать аргументы

select f1,f2,f3 f4,f5,f6 from mytable;

Это всё не те примеры, которые ты просил. Но ты видишь, как всё хрупко даже без разрешения мусорных запятых. Я чувствую, что нельзя разрешать мусорную запятую, и всё.

а зачем вообще нужен ручной перенос на новую строку, если есть word-wrap?

Я тоже над этим уже давно думаю. Не могу ответить, честно говоря. Кроме того, что будет выглядеть некрасиво, если перенесётся как попало. И, скажем, вид кода поменяется при изменении размеров окна.

Т.е., нужен со стороны IDE какой-то адаптированный, интеллектуальный word wrap, который будет переносить согласно стилю.

Или давать подсказку ему. Скажем, два пробела - это сразу автоматический перевод на новую строку.

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

Вот жуткий пример из питона:

value = foo.bar()['first'][0]*baz.ham(1, 2)[5:9] \
  + verify(34, 20)*skip(500, 360)

value = foo.bar()['first'][0]*baz.ham(1, 2)[5:9] \
  -5+function_for_size_effect()

value = foo.bar()['first'][0]*baz.ham(1, 2)[5:9] - \
  5+function_for_size_effect()

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

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