История изменений

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

Тривиально протаскивается error в IO, который не выполняется, перепутанные аргументы в функциях с типом String -> String -> String -> ..., return в монадах

Огромное количество ошибок при передаче в Gtk некорректных данных (Gtk-CRITICAL) при работе Leksah и то, что они годами не исправляются, также как бы намекает.

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

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

Приведу аналогию: в обычных программах бывает что два бага друг друга нейтрализуют и программа ведёт себя (почти) всегда верно.

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

Типы - это некая проверка которую ты пишешь в соотвествии с задуманной тобой логикой. Не то что даже проверка, а верятно, «дорога». Т.е. да, ты можешь свернуть на другую дорогу и вообще поехать не по дороге или сама дорога ведёт не туда.. но таки по дорогам обычно все ездят почему то... Потом ты реализуешь логику, которая должна соотвествовать типам. Да, ты можешь ошибиться в типах. И можешь ошибиться в логике так, что проверка типов пройдёт. Но это всё таки вещи уровня «два бага один другой перекрыл». Ну да, бывает. Но это не основная черта системы на мой взгляд. Основная - то что ты пишешь тип, потом пишешь соотвествующий код и у тебя согласованная система. Следующее важное свойство - меняешь в одном месте и типы тебе говорят где что сломалось (облегчают рефакторинг). А так же при этом уходят целые классы ошибок.

Но да, через год-другой расскажу как оно тут... пока - так.

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

Тривиально протаскивается error в IO, который не выполняется, перепутанные аргументы в функциях с типом String -> String -> String -> ..., return в монадах

Огромное количество ошибок при передаче в Gtk некорректных данных (Gtk-CRITICAL) при работе Leksah и то, что они годами не исправляются, также как бы намекает.

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

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

Приведу аналогию: в обычных программах бывает что два бага друг друга нейтрализуют и программа ведёт себя (почти) всегда верно.

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

Типы - это некая проверка которую ты пишешь в соотвествии с задуманной тобой логикой. Не то что даже проверка, а верятно, «дорога». Т.е. да, ты можешь свернуть на другую дорогу и вообще поехать не по дороге или сама дорога ведёт не туда.. но таки по дорогам обычно все ездят почему то... Потом ты реализуешь логику, которая должна соотвествовать типам. Да, ты можешь ошибиться в типах. И можешь ошибиться в логике так, что проверка типов пройдёт. Но это всё таки вещи уровня «два бага один другой перекрыл». Ну да, бывает. Но это не основная черта системы на мой взгляд. Основная - то что ты пишешь тип, потом пишешь соотвествующий код и у тебя согласованная система. Следующее важное свойство - меняешь в одном месте и типы тебе говорят где что сломалось (облегчают рефакторинг). А так же при этом уходят целые классы ошибок.

Но да, через год-другой расскажу как оно тут... пока - так.

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

Тривиально протаскивается error в IO, который не выполняется, перепутанные аргументы в функциях с типом String -> String -> String -> ..., return в монадах

Огромное количество ошибок при передаче в Gtk некорректных данных (Gtk-CRITICAL) при работе Leksah и то, что они годами не исправляются, также как бы намекает.

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

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

Приведу аналогию: в обычных программах бывает что два бага друг друга нейтрализуют и программа ведёт себя (почти) всегда верно.

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

Типы - это некая проверка которую ты пишешь в соотвествии с задуманной тобой логикой. Не то что даже проверка, а верятно, «дорога». Т.е. да, ты можешь свернуть на другую дорогу и вообще поехать не по дороге или сама дорога ведёт не туда.. но таки по дорогам обычно все ездят почему то... Потом ты реализуешь логику, которая должна соотвествовать типам. Да, ты можешь ошибиться в типах. И можешь ошибиться в логике так, что проверка типов пройдёт. Но это всё таки вещи уровня «два бага один другой перекрыл». Ну да, бывает. Но это не основная черта системы на мой взгляд. Основная - то что ты пишешь тип, потом пишешь соотвествующий код и у тебя согласованная система (типы облегчают написание, ты как бы размечаешь и освещаешь сам себе дорогу за весьма дёшево). Потом меняешь в одном месте и типы тебе говорят где тчо сломалось (типы облегчают рефакторинг). А так же при этом уходят целые классы ошибок.

Но да, через год-другой расскажу как оно тут... пока - так.

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

Тривиально протаскивается error в IO, который не выполняется, перепутанные аргументы в функциях с типом String -> String -> String -> ..., return в монадах

Огромное количество ошибок при передаче в Gtk некорректных данных (Gtk-CRITICAL) при работе Leksah и то, что они годами не исправляются, также как бы намекает.

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

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

Приведу аналогию: в обычных программах бывает что два бага друг друга нейтрализуют и программа ведёт себя (почти) всегда верно.

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

Типы - это некая проверка которую ты пишешь в соотвествии с задуманной тобой логикой. Потом ты реализуешь логику, которая должна соотвествовать типам. Да, ты можешь ошибиться в типах. И можешь ошибиться в логике так, что проверка типов пройдёт. Но это всё таки вещи уровня «два бага один другой перекрыл». Ну да, бывает. Но это не основная черта системы на мой взгляд. Основная - то что ты пишешь тип, потом пишешь соотвествующий код и у тебя согласованная система (типы облегчают написание, ты как бы размечаешь и освещаешь сам себе дорогу за весьма дёшево). Потом меняешь в одном месте и типы тебе говорят где тчо сломалось (типы облегчают рефакторинг). А так же при этом уходят целые классы ошибок.

Но да, через год-другой расскажу как оно тут... пока - так.

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

Тривиально протаскивается error в IO, который не выполняется, перепутанные аргументы в функциях с типом String -> String -> String -> ..., return в монадах

Огромное количество ошибок при передаче в Gtk некорректных данных (Gtk-CRITICAL) при работе Leksah и то, что они годами не исправляются, также как бы намекает.

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

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

Приведу аналогию: в обычных программах бывает что два бага друг друга нейтрализуют и программа ведёт себя (почти) всегда верно.

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

Типы - это некая проверка которую ты пишешь в соотвествии с задуманной тобой логикой. Потом ты реализуешь логику, которая должна соотвествовать типам. Да, ты можешь ошибиться в типах. И можешь ошибиться в логике так, что проверка типов пройдёт. Но это всё таки вещи уровня «два бага один другой перекрыл». Ну да, бывает. Но это не основная черта системы на мой взгляд. Основная - то что ты пишешь тип, потом пишешь соотвествующий код и у тебя согласованная система (типы облегчают написание). Потом меняешь в одном месте и типы тебе говорят где тчо сломалось (типы облегчают рефакторинг). А так же при этом уходят целые классы ошибок.

Но да, через год-другой расскажу как оно тут... пока - так.

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

Тривиально протаскивается error в IO, который не выполняется, перепутанные аргументы в функциях с типом String -> String -> String -> ..., return в монадах

Огромное количество ошибок при передаче в Gtk некорректных данных (Gtk-CRITICAL) при работе Leksah и то, что они годами не исправляются, также как бы намекает.

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

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

Приведу аналогию: в обычных программах бывает что два бага друг друга нейтрализуют и программа ведёт себя (почти) всегда верно.

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

Типы - это некая проверка которую ты пишешь в соотвествии с задуманной тобой логикой. Потом ты реализуешь логику, которая должна соотвествовать типам. Да, ты можешь ошибиться в типах. И можешь ошибиться в логике так, что проверка типов пройдёт. Но это всё таки вещи уровня «два бага один другой перекрыл». Ну да, бывает. Но это не основная черта системы на мой взгляд. Основная - то что ты пишешь тип, потом пишешь соотвествующий код и у тебя согласованная система (типы облегчают написание). Потом меняешь в одном месте и типы тебе говорят где тчо сломалось (типы облегчают рефакторинг). А так же при этом уходят целые классы ошибок.

Но да, через год-другой расскажу как оно тут... пока - так.