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

FDS>Компилятор и не обязан готовить мне кофе, а выводить правильные сообщения об ошибках — обязан, если это промышленный компилятор.

По-моему вы просто придираетесь к мелочам. Правильное понимание того, что if есть выражение, возвращающее результат, приходит достаточно быстро.

Есть еще такой момент. Не надо во всем потакать новичкам. Цель не будет все равно достигнута, и ничего хорошего из этого не выйдет. Пусть сами поднимают свой уровень.

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

P>Товарищи, предлагаю именно для ифа сделать дополнительный хинт, чтобы пояснять новичкам из С# причину ошибки

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

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

D>По-моему вы просто придираетесь к мелочам.

Эта мелочь очень утомляет.

D> Правильное понимание того, что if есть выражение, возвращающее результат, приходит достаточно быстро.

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

D>Есть еще такой момент. Не надо во всем потакать новичкам. Цель не будет все равно достигнута, и ничего хорошего из этого не выйдет. Пусть сами поднимают свой уровень.

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

Так что сами поднимайте свой уровень, а я хочу работать с сообщениями об ошибках эффективно.

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

FDS>Здравствуйте, Аноним, Вы писали:

FDS>>>Если это невозможно или трудно исправить, это не значит, что это не дефект.

А>>Довольно странное утверждение. По этой логике, если я заведу Issue #58 "компилятор не готовит мне кофе", то этот баг нельзя будет закрыть, пока Nemerle таки не научится варить мне кофе. Ведь если это невозможно или трудно исправить, это не значит, что это не дефект.

FDS>Компилятор и не обязан готовить мне кофе, а выводить правильные сообщения об ошибках — обязан, если это промышленный компилятор.

Любой функциональный язык даст похожее сообщение об ошибке. Вот например F#
> if true then 1 else "a";;

if true then 1 else "a";;
--------------------^^^

stdin(2,21): error FS0001: This expression was expected to have type
int
but here has type
string
>

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

А>>>Довольно странное утверждение. По этой логике, если я заведу Issue #58 "компилятор не готовит мне кофе", то этот баг нельзя будет закрыть, пока Nemerle таки не научится варить мне кофе. Ведь если это невозможно или трудно исправить, это не значит, что это не дефект.

FDS>>Компилятор и не обязан готовить мне кофе, а выводить правильные сообщения об ошибках — обязан, если это промышленный компилятор.

А>Любой функциональный язык даст похожее сообщение об ошибке. Вот например F#

Значит этот дефект есть и в F#. Что поделаешь, и Microsoft не идеален

Если где-то вы нашли неверную работу, это не значит, что и Nemerle должен неверно работать. Если в C#, и в других ОО-языках, не было до появления Nemerle вывода типов, то это не значит, что в Nemerle его не должно быть.

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

FDS>Здравствуйте, Аноним, Вы писали:

А>>>>Довольно странное утверждение. По этой логике, если я заведу Issue #58 "компилятор не готовит мне кофе", то этот баг нельзя будет закрыть, пока Nemerle таки не научится варить мне кофе. Ведь если это невозможно или трудно исправить, это не значит, что это не дефект.

FDS>>>Компилятор и не обязан готовить мне кофе, а выводить правильные сообщения об ошибках — обязан, если это промышленный компилятор.

А>>Любой функциональный язык даст похожее сообщение об ошибке. Вот например F#

FDS>Значит этот дефект есть и в F#. Что поделаешь, и Microsoft не идеален

FDS>Если где-то вы нашли неверную работу, это не значит, что и Nemerle должен неверно работать. Если в C#, и в других ОО-языках, не было до появления Nemerle вывода типов, то это не значит, что в Nemerle его не должно быть.

А вообще Вы правы, в F# ошибка в случае, когда функция объявляется как unit (аналог void) дается на первую ветку ифа,
а в случае, когда тип функции не ставится — на вторую, значит можно сделать.
Только там вывод типов используется Хиндли-Милнера и у него куча других ограничений.
Хотя не знаю, может здесь вывод типов и не при чем.

Подробности:

> let f () = (1,2,3);;

val f : unit -> int * int * int

> let y b : unit = if b then f() else ();;

let y b : unit = if b then f() else ();;
---------------------------^^^

stdin(8,28): error FS0001: This expression was expected to have type
unit
but here has type
int * int * int

> let y b = if b then f() else ();;

let y b = if b then f() else ();;
-----------------------------^^

stdin(9,30): error FS0001: This expression was expected to have type
int * int * int
but here has type
unit
>

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

VD>>Возможно тут можно ввести некую эвристику для конкретного случая (в общем случае тут все правильно) или просто изменить текст сообщения.

BM>Может сделать чтобы все классы наследовались от Void, точнее чтобы Object наследовался от Void, тогда подобная проблема с ифом отпадет сама собой, так как сработает автоматический downcast к типу Void

Это предложение я даже понять не могу. Не то что оценить. Для меня это звучит дико.

Куда могут деться проблемы я тоже не понимаю.

см.
http://rsdn.ru/forum/nemerle/4390829.1.aspx

Автор:
Дата: 23.08.11

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

VD>>Твоя логика такая: Я писал if который ничего не возвращает, но забыл, что функция compareFiles возвращает значение.

FDS>С чего это ты взял, что моя логика такая? Я писал if, который возвращает void, что явно указано в описании функции, но забыл, что функция compareFiles возвращает значение. И я был крайне удивлён, когда компилятор сказал мне, что if возвращает мне вовсе не void.

Что в лоб, что по лбу. Смысл от перестановки слов не меняется. Ты полностью повторил мои слова.

FDS>Сам подумай, если я пишу def a: string = if (условие) 1 else "2"
FDS>и мне компилятор на строке "2" говорит, что, мол, ожидается int, очевидно, меня это смущает, т.к. я явно указал, что a: string, и я ожидаю, что компилятор поймёт, что if как раз типа string.

Очевидно это исключительно для тебя. В прочем, я уже повторясь.

Проблема в том, что ты не осознаешь всей сложности алгоритмов вывода типа. Языки вроде C# вообще не учитывают возвращаемое значение при выводе типов. И на то есть свои причины.

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

Как я уже неоднократно говорил ИИ пока что не изобретен. По этому приходится использовать алгоритмы. В немерле используется описанный мной алгоритм. Отсюда и результат. Изменить его, конечно, можно, но не факт, что получится лучше. Есть ведь и другие случаи. Например, возвращемый тип функции может совпадать с случайно появившимся значением:

def f() : string
{
  if (cond)
    WriteLine("..."); // void
  else
    ReadLine(); // возвращает строку

  "a"
}

По твоей логике, компилятор радостно отрапортует, что WriteLine() возвращает не тот тип. Хотя ошибка скорее в том, что не тот тип возвращает ReadLine().

FDS>Вот как раз если бы он думал так, я бы не был бы против.

То у него был бы ИИ.

FDS>Вот на этот код
FDS>

FDS>def a: int = "2";
FDS>

FDS>компилятор соверешнно верно отвечает
FDS>error : expected int, got string in type-enforced expression: System.String is not a subtype of System.Int32 [simple require]

VD>>Твой же случай — это чистая ошибка. В шарпе она проскочила бы в рантайм. Тут же тебе ее поймали.

FDS>Да нет, в шарпе это не было бы ошибкой вообще (я не хотел ничего получать из функции, и она была пустой).

Бала бы. Ты вызвал чистую функцию не порождающую побочных эффектов и потерял ее значение. Это чистой воды ошибка. Только сообщения об этом ты не получишь. А значит и не узнаешь о ней. Будет просто неверное поведение.

VD>>Можно сделать так. Сообщение изменить так:
VD>>

VD>>Detected incompatible types (int * int * int)- and void in computation branchs

VD>>и сообщение будет указывать на заголовок if-а, а не на его кишки. Или на обе ветки.

FDS>Ну да, лучше если оно будет содержать весь регион выражения if.

VD>>Так пойдет?

FDS>Я бы предложил сначала вынести само сообщение, чтобы программист его видел: иногда этого достаточно.
FDS>Т.е. примерно так:
FDS>

FDS>Detected incompatible types in computation branchs: (int * int * int), void

Ну, можно и так. Это уже детали.

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

FDS>>Сам подумай, если я пишу def a: string = if (условие) 1 else "2"
FDS>>и мне компилятор на строке "2" говорит, что, мол, ожидается int, очевидно, меня это смущает, т.к. я явно указал, что a: string, и я ожидаю, что компилятор поймёт, что if как раз типа string.

VD>Очевидно это исключительно для тебя. В прочем, я уже повторясь.

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

VD>Проблема в том, что ты не осознаешь всей сложности алгоритмов вывода типа. Языки вроде C# вообще не учитывают возвращаемое значение при выводе типов. И на то есть свои причины.

Мне и не нужно ничего осознавать. Я лишь пишу дефект с просьбой что-нибудь исправить: или вывод типов, если возможно, или сообщение об ошибке.
В F# вот, как тут в теме показали, вывод типов вполне справился.

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

Здесь он был известен.

VD>

VD>def f() : string
VD>{
VD>  if (cond)
VD>    WriteLine("..."); // void
VD>  else
VD>    ReadLine(); // возвращает строку

VD>  "a"
VD>}
VD>

VD>По твоей логике, компилятор радостно отрапортует, что WriteLine() возвращает не тот тип. Хотя ошибка скорее в том, что не тот тип возвращает ReadLine().

Ты вообще читаешь, что я пишу? По-моему нет.

FDS>>Вот как раз если бы он думал так, я бы не был бы против.

VD>То у него был бы ИИ.

У F# есть ИИ? Почему он так думает?

VD>>>Твой же случай — это чистая ошибка. В шарпе она проскочила бы в рантайм. Тут же тебе ее поймали.

FDS>>Да нет, в шарпе это не было бы ошибкой вообще (я не хотел ничего получать из функции, и она была пустой).

VD>Бала бы. Ты вызвал чистую функцию не порождающую побочных эффектов и потерял ее значение. Это чистой воды ошибка.
Это не ошибка: мне так и нужно было на данном этапе работы с кодом.

FDS>>Я бы предложил сначала вынести само сообщение, чтобы программист его видел: иногда этого достаточно.
FDS>>Т.е. примерно так:
FDS>>

FDS>>Detected incompatible types in computation branchs: (int * int * int), void

VD>Ну, можно и так. Это уже детали.

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

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

FDS>у меня уже два закрытых дефекта при том, что в обоих случаях никто с моим мнением считаться даже не желает.

Может быть ты просто "докопался до столба?"

Подобные ошибки — это пробел в понимании языка, но не проблема в компиляторе. ИМХО.

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

H>Подобные ошибки — это пробел в понимании языка, но не проблема в компиляторе. ИМХО.


Скажи мне, чего я не понимаю

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

FDS>Скажи мне, чего я не понимаю

Того, что в Nemerle нету стейтментов.

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

H>Того, что в Nemerle нету стейтментов.

Кто тебе сказал, что я этого не понимаю?

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

DR>>На мой взгляд, текущее сообщение вполне адекватно, но в идеале хотелось бы что-то вроде: "Conditional expression branches have incompatible types: (int * int * int)- and void".

А>Не, я реально офигеваю. И это немерлисты считают идеальным сообщением об ошибке???
А>Лично меня в такой ситуации устраивает только "void function can not return a value", как в общем-то во всех нормальных языках.

Вот тебе аналог на "нормальном" языке:

class Program
{
  static void Main(string[] args)
  {
    return args.Length < 0 
      ? args 
      : 1; // error CS0173: Type of conditional expression cannot be determined because there is no implicit conversion between 'string[]' and 'int'
  }
}

Как видишь, ни слова про "void function can not return a value". Более того, сообщение по смыслу очень похоже на немерловое.

Немерловый if — это полный аналог тернарного оператора C#. Просто в Nemerle void считается обычным типом и выражения могут возвращать его. Отсюда вместо 1 в Nemerle можно вставить то, что в C# называется statment.

И что характено, даже указание ошибки на той же сроке!

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

А>>А с if-ами без тренарного оператора чем ругается?

DR>Код с if-ами не аналогичен. Как уже обьяснили, в Немерле if это выражение, также как и оператор ?: в С++. Код FDSC не пытается вернуть что либо из функции, просто потому что внутреннее выражение не имеет смысла.

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

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

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

FDS>>у меня уже два закрытых дефекта при том, что в обоих случаях никто с моим мнением считаться даже не желает.

H>Может быть ты просто "докопался до столба?"

H>Подобные ошибки — это пробел в понимании языка, но не проблема в компиляторе. ИМХО.

Скажу больше, тут вообще ошибок нет никаких. Ошибка у автора кода и она успешно выявлена компилятором.

Единственное, что имеет смысл — сделать сообщение более информативным и чтобы оно указывало на шапку if-а, а не на одну из подветок.

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

H>>Того, что в Nemerle нету стейтментов.

FDS>Кто тебе сказал, что я этого не понимаю?

Тогда должен понмать, что сравнивать if немерла нужно с ?: С, а не со стейтментом.

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

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

Если выявляет, пусть делает это качественно.

Средних размеров приложение, это сколько?

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

VD>Вот тебе аналог на "нормальном" языке:
VD>

VD>class Program
VD>{
VD>  static void Main(string[] args)
VD>  {
VD>    return args.Length < 0 
VD>      ? args 
VD>      : 1; // error CS0173: Type of conditional expression cannot be determined because there is no implicit conversion between 'string[]' and 'int'
VD>  }
VD>}
VD>

VD>Как видишь, ни слова про "void function can not return a value". Более того, сообщение по смыслу очень похоже на немерловое.

VD>Немерловый if — это полный аналог тернарного оператора C#. Просто в Nemerle void считается обычным типом и выражения могут возвращать его. Отсюда вместо 1 в Nemerle можно вставить то, что в C# называется statment.

VD>И что характено, даже указание ошибки на той же сроке!

Зато само сообщение гораздо приятнее.