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

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

завидую молодым и самоуверенным
где мои школьные годы?

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

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

VD>>>Зачем запрещать? Достаточно не допускать их смеси в одном фале.
M_>>не всякий редактор покажет, что стоит имеено здесь — пробел или таб

VD>Не пользуйся "всякими" редакторами. Пользуйся полноценными. Кроме того, табы и пробелы должны контролироваться компилятором.
ага, плавали — знаем.
знаешь, иногда приходится и в чужих системах клавиши давить и файлы править. А что там окажется — только от хозяина зависит.

Классический случай, когда фанат вима или емакса попадает в систему, где стоит что-то другое.....

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

ВВ>>>>>А там можно получить неправильную программу просто вставив лишний пробел

FR>>>>Пробел фигня, вот неправильный таб вообще может до смертоубийства довести

T>>>В чём разница?
M_>>разница в том, что разные редакторы ставят разное количество пробелов вместо таба. То есть, глазами смотришь — строки на одном уровне, запускаешь — код ведет себя черти как. Залез в коды — вот оно: таб и пробелы. Уж сколько раз такое было......

T>Ну так настройте редактор.
еще один.
ты пробовал когда-нить поработать за чужой машиной? Когда там все другое И НАСТРОЕНО ПОД ХОЗЯИНА. ?
попробуй, потом расскажешь, как тебе хозяин системы спасибо говорил за "настроенный редактор"

ВВ>>>>>>А там можно получить неправильную программу просто вставив лишний пробел
FR>>>>>Пробел фигня, вот неправильный таб вообще может до смертоубийства довести
T>>>>В чём разница?
M_>>>разница в том, что разные редакторы ставят разное количество пробелов вместо таба. То есть, глазами смотришь — строки на одном уровне, запускаешь — код ведет себя черти как. Залез в коды — вот оно: таб и пробелы. Уж сколько раз такое было......

T>>Ну так настройте редактор.
M_>еще один.
M_>ты пробовал когда-нить поработать за чужой машиной? Когда там все другое И НАСТРОЕНО ПОД ХОЗЯИНА. ?
M_>попробуй, потом расскажешь, как тебе хозяин системы спасибо говорил за "настроенный редактор"

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

Вы путаете "настроено под хозяина" и "настроено". Если человек пишет на языке, где пробелы/табы важны и они у него не подсвечены — значит редактор не настроен.

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

ВВ>>И что это? unit в Хаскеле это пустой кортеж. Его литерал — это ()
T>Ах вон ты о чём. Теперь понял.

Ну вот это тот же самый void, что и у меня. Не больше и не меньше.
Не забудь, кстати, записать его наличие в список недостатков Хаскеля

ВВ>>А если еще вспомнить, что даже в C# есть ленивость:
T>А ленивость, ещё раз, к последовательности отношения не имеет. Можно выполнить последовательно и потом. Можно выполнить в разнобой и сейчас.

А что же тогда имеет отношение к последовательности?
В чем проблема ленивого языка на пару с сайд-эффектами? Выражение вида var x = y + 2 может иметь один результат там, где оно фактически записано, и совсем другой, если мы выполняем его не сразу, а лишь "по требованию", т.к. "y" мог просто-напросто поменяться.
Очевидно, что вся эта неявная ленивость при сайд эффектах идет лесом.
В С# есть ленивость, но там ты, можно сказать, реализуешь ее на свой страх и риск — и да, злоупотребление тут вполне может привести к не самым приглядным эффектам.

ВВ>>Монада это — сначала функция А, потом функция Б. Описание функции Б выглядит как "сначала функция А1, потом функция Б2".
ВВ>>По-моему — четкая последовательность.
T>Хакей, мы по-разному понимаем этот термин. Думаю, что тебе стоит обратиться к какому-нибудь штангисту и уточнить своё определение.

Объясни тогда свое понимание. Которое при этом не имеет отношения к ленивости.

T>>>>>Я хочу увидеть (и показать) как (в худшем случае) N-1 выражений в каждом блоке не используются.
ВВ>>>>Синтаксический мусор т.е.? Ну я и так знаю, что он есть.
T>>>Не синтаксический. как бы это.. семантический мусор что-ли
T>>>Грамматически в коде куча значений и не используются. Некрасиво. Вот стейтменты честно говорят, что значений они не возвращают.
ВВ>>Альтернатива приведет к тому, что ты будешь постоянно писать что-то типа:
ВВ>>Я через это уже проходил, некрасивости куда больше.

T>Согласен, некрасиво. Потому что это не альтернатива. Это просто зачем-то явный null в конце. А неиспользованное выражение for осталось.

ВВ>>Да и что такого некрасивого в void? Это просто значение, которого нет.

T>Именно это и некрасиво. Значение, которое ничего не значит. Охренеть содержательно. Если б оно называлось side-effect, было бы честнее и понятнее, чес-слово.

"Пустой кортеж". Вполне нормальное понятие.
А что у нас в качестве альтернативы-то? Разделение на statement и expression — это не так хорошо, как тебе почему-то кажется.
Вот есть функция, она всегда возвращает какое-то значение. Что может быть телом функции? Очевидно, только expression. Т.е. я в принципе не могу писать императивный код внутри функции? А несколько выражений могу записать? Блок выражений сам по себе является выражением?
Если да — получаем ту же петрушку. Последним в блоке идет statement. Не компилируем? Заставляем возвращать значение? Вводим, помимо функций, некие субрутины, которые от функций отличаются только тем, что значение не возвращают? Созданные специально для императивного кода.

Опять же, по каким-то причинам большинство ФЯ таки тоже не могут уйти от этого void-а.

ВВ>>Возвращаемое значение тоже не используется, но функция вполне может делать что-нибудь полезное. С сайд-эффектами
ВВ>>Не вызывать ее?
T>Я повторюсь, что лично по-моему, стейтмент это и есть "выражение, значение которого неважно, но вычислить его нужно".

А вот вызов функции — это может быть и стейтмент и не стейтмент.

ВВ>>Это в чистых ленивых языках. Тут "функциональность" сама по себе не причем, если ты конечно ее с ленивостью не делаешь тождественной.
T>Я даже чётко написал, что это не в языках программирования вообще.

Ты четко написал, что подобное поведение для тебя является чуть ли не определением "функциональности" языка. Хотя многие ФЯ вполне энергичны и "все есть функция", очевидно, не про них.

T>Где побочных эффектов нет, там и можно, почему же. А наличие побочных эффектов во многих случаях можно статически найти. Тут рядом это обсуждалось в контексте немерле.

В контексте Немерле обсуждалась техника реализации модификатора pure для функции.
А так — ну нашел ты статически побочный эффект? Что делать? Не компилировать? Вычислять по месту? Во втором случае семантика программы станет вообще дико нетривиальной. Хаскель отдыхает.

T>Почему return этого не делает ты не сказал. Или может return в Ela этого не делает — то, конечно, всё может быть, я не знаю внутренностей. Опять, я рассуждаю с позиции какой-то теории не в конкретном языке, а в целом.
T>Хакей, не сошлись терминами. У меня немного другая мысль была.

Выскажи тогда свою мысль, я ее не понял. Наверное, можно представить себе язык, в котором return осуществляет binding. Но мне непонятно зачем да и вообще, надо сказать, я себе это с трудом представлю. К чему он биндит-то? Функция, одна и та же, может быть вызвана при инициализации, при изменении переменной или записи в консоль (побочные эффекты), наконец ее значение может быть попросту похерено.
Да и вообще это не задача функции что-то там связывать. Может быть у меня связывание происходит через паттерн матчинг вообще. Какой смысл нагружать return такой ответственностью?

ВВ>>>А если еще вспомнить, что даже в C# есть ленивость:
T>>А ленивость, ещё раз, к последовательности отношения не имеет. Можно выполнить последовательно и потом. Можно выполнить в разнобой и сейчас.

ВВ>А что же тогда имеет отношение к последовательности?

Порядок вычисления. Например, стейтментов в блоке или элементов в литерале списка.

ВВ>В чем проблема ленивого языка на пару с сайд-эффектами? Выражение вида var x = y + 2 может иметь один результат там, где оно фактически записано, и совсем другой, если мы выполняем его не сразу, а лишь "по требованию", т.к. "y" мог просто-напросто поменяться.
ВВ>Очевидно, что вся эта неявная ленивость при сайд эффектах идет лесом.

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

ВВ>>>Монада это — сначала функция А, потом функция Б. Описание функции Б выглядит как "сначала функция А1, потом функция Б2".
ВВ>>>По-моему — четкая последовательность.
T>>Хакей, мы по-разному понимаем этот термин. Думаю, что тебе стоит обратиться к какому-нибудь штангисту и уточнить своё определение.

ВВ>Объясни тогда свое понимание. Которое при этом не имеет отношения к ленивости.

Я уже сказал. Это интерфейс о двух методах: pure :: a -> m a и bind :: m a -> (a -> m b) -> m b. Ну, конечно, весь смысл во втором, первый так, чтоб было с чего начать.

T>>Согласен, некрасиво. Потому что это не альтернатива. Это просто зачем-то явный null в конце. А неиспользованное выражение for осталось.
ВВ>>>Да и что такого некрасивого в void? Это просто значение, которого нет.

T>>Именно это и некрасиво. Значение, которое ничего не значит. Охренеть содержательно. Если б оно называлось side-effect, было бы честнее и понятнее, чес-слово.

ВВ>"Пустой кортеж". Вполне нормальное понятие.

По-моему — так себе нормальное оно. Спорно. Больше похоже на костыль. Или я не видел действительно осмысленных применений ему.

ВВ>А что у нас в качестве альтернативы-то? Разделение на statement и expression — это не так хорошо, как тебе почему-то кажется.
ВВ>Вот есть функция, она всегда возвращает какое-то значение. Что может быть телом функции? Очевидно, только expression. Т.е. я в принципе не могу писать императивный код внутри функции? А несколько выражений могу записать? Блок выражений сам по себе является выражением?
ВВ>Если да — получаем ту же петрушку. Последним в блоке идет statement. Не компилируем? Заставляем возвращать значение? Вводим, помимо функций, некие субрутины, которые от функций отличаются только тем, что значение не возвращают? Созданные специально для императивного кода.

Последнее, про субрутины специально для императивного кода мне даже нравится. Эдакая подпись, как global: "да, я беру на себя ответственность и щас буду писать грязный императивный код."

ВВ>Опять же, по каким-то причинам большинство ФЯ таки тоже не могут уйти от этого void-а.

Да, именно. По каким-то. Я, например, честно скажу, что не знаю по каким. Даже не буду гадать.

ВВ>>>Возвращаемое значение тоже не используется, но функция вполне может делать что-нибудь полезное. С сайд-эффектами
ВВ>>>Не вызывать ее?
T>>Я повторюсь, что лично по-моему, стейтмент это и есть "выражение, значение которого неважно, но вычислить его нужно".

ВВ>А вот вызов функции — это может быть и стейтмент и не стейтмент.

Да... я всё больше верю в свой 'do'

ВВ>>>Это в чистых ленивых языках. Тут "функциональность" сама по себе не причем, если ты конечно ее с ленивостью не делаешь тождественной.
T>>Я даже чётко написал, что это не в языках программирования вообще.

ВВ>Ты четко написал, что подобное поведение для тебя является чуть ли не определением "функциональности" языка. Хотя многие ФЯ вполне энергичны и "все есть функция", очевидно, не про них.

Да, некоторые называют языки функциональными уже за то, что не Java (имеют first class function). Это такая скользкая терминологическая херня. я не буду об этом спорить

T>>Где побочных эффектов нет, там и можно, почему же. А наличие побочных эффектов во многих случаях можно статически найти. Тут рядом это обсуждалось в контексте немерле.

ВВ>В контексте Немерле обсуждалась техника реализации модификатора pure для функции.
ВВ>А так — ну нашел ты статически побочный эффект? Что делать? Не компилировать? Вычислять по месту? Во втором случае семантика программы станет вообще дико нетривиальной. Хаскель отдыхает.

Нашёл — не применяй там ленивость, мемоизацию и всё.

T>>Почему return этого не делает ты не сказал. Или может return в Ela этого не делает — то, конечно, всё может быть, я не знаю внутренностей. Опять, я рассуждаю с позиции какой-то теории не в конкретном языке, а в целом.
T>>Хакей, не сошлись терминами. У меня немного другая мысль была.

ВВ>Выскажи тогда свою мысль, я ее не понял. Наверное, можно представить себе язык, в котором return осуществляет binding. Но мне непонятно зачем да и вообще, надо сказать, я себе это с трудом представлю. К чему он биндит-то? Функция, одна и та же, может быть вызвана при инициализации, при изменении переменной или записи в консоль (побочные эффекты), наконец ее значение может быть попросту похерено.
ВВ>Да и вообще это не задача функции что-то там связывать. Может быть у меня связывание происходит через паттерн матчинг вообще. Какой смысл нагружать return такой ответственностью?

Идея такая, что в императивных языках return уже сейчас делает две вещи: бинд и goto. Прими это как факт, как базу для рассуждения.

function f() {
return 10;
}

line1: f();
line2: ...

такой код биндит 10 к специальному неиспользуемому имени и делает goto на line2.

line3: x = f();
line4: print x

такой код биндит 10 к имени 'x' и делает goto на line4.

x = expr это тоже патерн-матчинг, никакого противоречия тут нет.

Интересное начинается, если из семантики return убрать goto.

function f() {
return 10;
if (cond) {
return 20;
}
}

Тогда, в зависимости от условия, функция вернёт 10 или 20.

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

ВВ>>А что же тогда имеет отношение к последовательности?
T>Порядок вычисления. Например, стейтментов в блоке или элементов в литерале списка.

А почему это не связано с ленивостью?
Скажи вот здесь вот:

var seq = from p in list select p;

foreach (var e in seq) 
{

}

порядок вычисления сохраняется?

А здесь:

let l = lazy { 2 + 2}

let r = Lazy.force l + 2

ВВ>>В чем проблема ленивого языка на пару с сайд-эффектами? Выражение вида var x = y + 2 может иметь один результат там, где оно фактически записано, и совсем другой, если мы выполняем его не сразу, а лишь "по требованию", т.к. "y" мог просто-напросто поменяться.
ВВ>>Очевидно, что вся эта неявная ленивость при сайд эффектах идет лесом.

T>Да, конечно; я это тоже говорил а ещё говорил, что можно во многих случаях отделить чистые выражения от потенциально содержащих сайдэффекты. И применить ленивость только к чистым, где она безопасна.

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

ВВ>>Объясни тогда свое понимание. Которое при этом не имеет отношения к ленивости.
T>Я уже сказал. Это интерфейс о двух методах: pure :: a -> m a и bind :: m a -> (a -> m b) -> m b. Ну, конечно, весь смысл во втором, первый так, чтоб было с чего начать.

А зачем нужен вообще этот метод? Это "интерфейс" задает последовательность выполнения, что весьма важно в том случае, если у нас есть побочные эффект. Метод 2 выполнится только после метода 1, ибо ему может зависеть от сайд-эффектов метода 1.
Если это не последовательность — то что?

Код вида (псевдо-C#):

WriteLine("1");
WriteLine("2");
WriteLine("3");

я могу расписать так:

var exec = f1 => {
   WriteLine("1");
   f1(f2 => {
                WriteLine("2");
                f2(f3 => {
                            WriteLine("3");    
                            ...
                         });
             }); 
};

exec |> f => f();

Вот тебе и монада.

ВВ>>"Пустой кортеж". Вполне нормальное понятие.
T>По-моему — так себе нормальное оно. Спорно. Больше похоже на костыль. Или я не видел действительно осмысленных применений ему.

Альтернатива?

ВВ>>Опять же, по каким-то причинам большинство ФЯ таки тоже не могут уйти от этого void-а.
T>Да, именно. По каким-то. Я, например, честно скажу, что не знаю по каким. Даже не буду гадать.

А я подозреваю, что это цена за смешение императивности и функциональности. В общем вопрос тот же. Альтернатива?

T>Да... я всё больше верю в свой 'do'

Только, чем он от монад отличается

T>Да, некоторые называют языки функциональными уже за то, что не Java (имеют first class function). Это такая скользкая терминологическая херня. я не буду об этом спорить

Да можешь считать функциональными только чистые и ленивые языки, мне не жалко.
Договоримся, что, говоря "функциональный язык", я имею в виду язык типа OCaml, F#, Scala, Nemerle.

T>Идея такая, что в императивных языках return уже сейчас делает две вещи: бинд и goto. Прими это как факт, как базу для рассуждения.

Мне все равно эта база непонятна. Да чем она поможет? Почему бы не считать, что бинд делает не return, а "=". Кто в данном случае делает бинд:

let (x > 10, y < 20) as tuple = func()

T>function f() {
T> return 10;
T> if (cond) {
T> return 20;
T> }
T>}
T>Тогда, в зависимости от условия, функция вернёт 10 или 20.

И получает код, в который я вообще не въезжаю. По идее бы он должен был выглядеть так:

function f() {
   if (cond)
      20
   else
      10
}

Я готов принять любые допущения, но хочется понять — зачем. Что ты пытаешь показать этим return без goto?

ВВ>>>А что же тогда имеет отношение к последовательности?
T>>Порядок вычисления. Например, стейтментов в блоке или элементов в литерале списка.

ВВ>А почему это не связано с ленивостью?
ВВ>Скажи вот здесь вот:

ВВ>

ВВ>var seq = from p in list select p;

ВВ>foreach (var e in seq) 
ВВ>{

ВВ>}
ВВ>

ВВ>порядок вычисления сохраняется?

Там очень много вычислений. Ты о чём именно?

ВВ>А здесь:

ВВ>

ВВ>let l = lazy { 2 + 2}

ВВ>let r = Lazy.force l + 2
ВВ>

И здесь тоже уточни.

ВВ>>>В чем проблема ленивого языка на пару с сайд-эффектами? Выражение вида var x = y + 2 может иметь один результат там, где оно фактически записано, и совсем другой, если мы выполняем его не сразу, а лишь "по требованию", т.к. "y" мог просто-напросто поменяться.
ВВ>>>Очевидно, что вся эта неявная ленивость при сайд эффектах идет лесом.

T>>Да, конечно; я это тоже говорил а ещё говорил, что можно во многих случаях отделить чистые выражения от потенциально содержащих сайдэффекты. И применить ленивость только к чистым, где она безопасна.

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

Смотря чего ожидает программист.

ВВ>>>Объясни тогда свое понимание. Которое при этом не имеет отношения к ленивости.
T>>Я уже сказал. Это интерфейс о двух методах: pure :: a -> m a и bind :: m a -> (a -> m b) -> m b. Ну, конечно, весь смысл во втором, первый так, чтоб было с чего начать.
ВВ>А зачем нужен вообще этот метод? Это "интерфейс" задает последовательность выполнения, что весьма важно в том случае, если у нас есть побочные эффект. Метод 2 выполнится только после метода 1, ибо ему может зависеть от сайд-эффектов метода 1.
ВВ>Если это не последовательность — то что?

Какой ты всё-таки... спрашиваешь моё определение, я его говорю без слова последовательность (наверное не просто так), ты опять навязываешь эту последовательность.

x = pure 10
f a = pure 20
result = bind x f # bind x ( a => pure 20 )
Возвращает pure 20. x вообще не надо вычислять. Нет последовательности.

А то по-твоему получается, что скобки в "a + (b + c)" тоже монада, потому что заставляет вычислить b+c до сложения с 'a'. То, что ты описал называется просто зависимость данных. Понятно, блин, что некоторые выражения зависят от значения других. Как видишь, на примере скобок, для этого не нужны интерфейсы и специальные термины.

ВВ>>>"Пустой кортеж". Вполне нормальное понятие.
T>>По-моему — так себе нормальное оно. Спорно. Больше похоже на костыль. Или я не видел действительно осмысленных применений ему.

ВВ>Альтернатива?

Ну, в Clean в качестве альтернативы — *World (звезда означает, что это значение можно использовать один раз). Не скажу, что это очень здорово, но в этом хотя бы есть смысл, в отличие от пустого кортежа/void: вот было состояние мира, вот мы его поменяли. Всё честно.

Чтобы действительно решить проблему "возврата ничего", один из подходов: FRP. Попытка очистить сайдэффекты. Но это довольно сложно.

А специальная языковая конструкция (стейтмент) это просто. Хотя и 100% "для бедных".

ВВ>А я подозреваю, что это цена за смешение императивности и функциональности. В общем вопрос тот же. Альтернатива?

(вряд ли есть смысл в одном посте задавать один вопрос дважды )

T>>Да... я всё больше верю в свой 'do'
ВВ>Только, чем он от монад отличается

От IO — тем что форсирует вычисление каждого выражения внутри. От остальных монад — всем.

T>>Идея такая, что в императивных языках return уже сейчас делает две вещи: бинд и goto. Прими это как факт, как базу для рассуждения.

ВВ>Мне все равно эта база непонятна. Да чем она поможет? Почему бы не считать, что бинд делает не return, а "=". Кто в данном случае делает бинд:

Потому что вызов функции не всегда стоит справа от '='. Например, в "f() + 1" нет '='.

ВВ>

ВВ>let (x > 10, y < 20) as tuple = func()
ВВ>

В данном случае return в func делает бинд промежуточному скрытому имени, которое потом раскладывается на x и y (если я правильно понял этот код). То есть два бинда.

T>>function f() {
T>> return 10;
T>> if (cond) {
T>> return 20;
T>> }
T>>}
T>>Тогда, в зависимости от условия, функция вернёт 10 или 20.

ВВ>И получает код, в который я вообще не въезжаю. По идее бы он должен был выглядеть так:

ВВ>

ВВ>function f() {
ВВ>   if (cond)
ВВ>      20
ВВ>   else
ВВ>      10
ВВ>}
ВВ>

Это код, который решает ту же самую задачу, но совсем по-другому.

Вот ещё пример зачем нужен return без goto:

function index-of (L, item) {
  return null;
  for x, index in L, [1..] {
    if x == item:
      return index;
      break; // то есть, здесь уже с goto
  }
}

В делфи неявно создаётся переменная Result. Полный аналог такого return.

function ...
begin
Result := 0;
...
Result := что-то ещё
...
Result := f();
end;

ВВ>Я готов принять любые допущения, но хочется понять — зачем. Что ты пытаешь показать этим return без goto?

Ну ты говорил, что return специально не делаешь, вот я хочу показать, что без goto он не так уж и страшен.

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

M_>завидую молодым и самоуверенным
M_>где мои школьные годы?

http://www.rsdn.ru/forum/life/3792757.1.aspx

Автор: March_rabbit
Дата: 30.04.10

Ваши школьные годы однозначно очень, очень далеко.

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

ВВ>>>Ты, видимо, else пропустил. Вообще я все же не понимаю вопрос. Или ты намекаешь на то, что else — это не мусор? А на else никто и не наезжал.
NB>>нет, там ";" после первого выражения пропущено.

ВВ>Если запись expr expr не создает конфликтов, то все понятно. Ты записал в строку if без else и еще одно выражение.

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

var x = lambda(x) -> (x*x) (10)

здесь x -- это функция или 100?
ответ поясни.

ВВ>>>Но вот скобочки вокруг cond вполне могут быть и мусором.

NB>>

NB>>class Test {
NB>>   operator bool ();
NB>>   operator () (int)
NB>>} test;

NB>>if test (1) ;
NB>>

NB>>здесь ошибка или нет?

ВВ>Я вообще не вижу тут проблемы. Ну т.е. у всех конструкций есть вполне очевидное завершение. Ну и ; сам по себе является валидным выражением. Так что все в порядке.

то есть вызовется оператор bool, и если результат true, то вернется 1?
почему именно так?

ВВ>>>Ну а что это меняет? А в глобальном блоке как быть?
NB>>так же как в не глобальном.

ВВ>А вот тут точно нужны все точки с запятой:

ВВ>x => { expr1; expr2; };

на мой взгляд да

ВВ>>> А как быть с конструкциями, которые вообще могут быть без блоков?
NB>>пример?

ВВ>Объявление переменной

Точка с запятой в в конце объявления :
int x;

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

ВВ>Известно, что в Си-подобном синтаксисе круглые скобочки несколько перегружены смыслом. Это и средство для группировки выражений, и часть грамматики некоторых стандартных выражений вроде for, if и вызов функции, и приведение типов...
ВВ>На мой взгляд это несколько снижает читабельность.

ВВ>А как бы вы отнеслись к сокращению "скобочности" синтаксиса? Хотя бы в выражениях. Например, вместо


ВВ>

ВВ>for (x in y) 
ВВ>  expr
ВВ>

ВВ>было бы


ВВ>

ВВ>for x in y do
ВВ>  expr
ВВ>

Здесь, совершенно очевидно, вы правы. Круглые скобки лишние. По ключевому слову In тип оператора For однозначно определяется. Хотя есть вариант обойтись и без этого ключевого слова определив такой тип циклов как отдельный класс операторов ForEach.
ВВ>Или вместо


ВВ>

ВВ>if (x > y)
ВВ>  expr
ВВ>else
ВВ>  expr
ВВ>

ВВ>было бы


ВВ>

ВВ>if x > y then
ВВ>  expr
ВВ>else
ВВ>  expr
ВВ>

И здесь круглые скобки лишние. Транслятору вполне по силам выделить логическое выражение. Можно даже обойтись без ключевого слова Then. У меня здесь другое замечание. Условные операторы If с Else и без Else должны быть разными. И проблема не столько с "кочующим Else", сколько в объектном подходе. Если считать каждый оператор независимым объектом, то конструкцию без Else можно считать таковой. А объект с Else подразумевает выполнение оператора if, и еще какой-то анализ, и возможно действия. Т.е. это другое функциональное содержание. Т.е. другой класс операторов, который в себе содержит оператор If, результат действия которого нуждается в дополнительном анализе.
ВВ>Само собой при сохранении остальной си-подобности.
Как я заметил, здесь обсуждался не поставленый Вами вопрос, а вопрос необходимости фигурных скобок если в теле оператора один оператор. В общем случае лишние скобки только мешают чтению. Проблема только определить какие скобки можно назвать лишними. Т.е. все операторы можно разделить на два множества те, которые требуют чего-то обязательного после (тогда для одного оператора скобки не нужны), и множества операторов для которых наличие чего-то не обязательно. Тогда без скобок не обойтись. Именно они указывают на наличего вот этого чего-то. Отсюда вывод: Приводить к единому виду необходимо сами операторы. Тогда применение скобок будет иметь единые правила. Кстати, что я и предлагаю в своем языке. . Раздел 2 именно о скобках и группировании.

Хотел бы поставить проблему шире. Вообще применение скобок в языках.

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

G>>Можно избавиться и от фигурных скобок, введя двумерный синтаксис. Было бы желание.

ВВ>Что такое двумерный синтаксис? Можно поподробнее?

Когда scope задается величиной отступа.

Т.е. вместо

if x { a(); b(); } else { c(); d(); }
do_something();

Мы пишем

if x 
   a()
   b()
else
   c()
   d()
do_something()

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

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

G>Один и только один оператор на строке, отступ задает вложенность. Много современных языков это используют.

Много — это кто кроме Питона и Немерля?

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

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

G>>Один и только один оператор на строке, отступ задает вложенность. Много современных языков это используют.

AVK>Много — это кто кроме Питона и Немерля?

Эммм, неужто ты про хаскель не в курсе?

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

AVK>Много — это кто кроме Питона и Немерля?

F#