Haskell vs Lisp

>> И больше ничего? Значит теоретизируешь. Попробуй на хаскеле сделать парсер какого-нибудь текстового файла, а еще лучше XML'а с помощью HXT. Сразу возникнет ощущение, что чего-то важное в жизни ты пропустил.

Хм... Мне как-то схемой сподручнее такие вещи делать, да и макросы - это великая весчь...

>Мне как-то схемой сподручнее

Схема меня всем устраивала, кроме отсутствия нормальной типизации...

>> Схема меня всем устраивала, кроме отсутствия нормальной типизации...

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

>> Схема меня всем устраивала, кроме отсутствия нормальной типизации...

> Обычная сильная динамическая типизация

Это калька с какого термина? o_O

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

В Хаскеле этим занимается компилятор, а в Схеме? Юнит-тесты?

Strong Dynamic Typing.

Sincerely yours,
C. O.

> Хаскельный вывод типов выражений вещь конечно интересная, но практического применения я для него так и не нашел, ну может кроме отлавливания своих же логических ошибок,

Логические ошибки при статической типизации отлавливаются и без автоматического вывода типов. Это свойство статической типизации как таковой. У автоматического вывода типов существуют на мой взгляд существует два основных полезных свойства: 1) он красиво разруливает полиморфизм - случаи когда один и тотже код может применяться к данным разных типов, а в хаскеле благодоря его системе классов это вообще крайне полезно. 2) он снимает с программиста рутинную необходимость постоянно деклалировать что символ 'a' имеет тип Int, а 'b' - 'String'.

>> 2) он снимает с программиста рутинную необходимость постоянно деклалировать что символ 'a' имеет тип Int, а 'b' - 'String'.

Автоматический вывод к этому не имеет никакого отношения, речь идет о типах выражений вроде такого func :: a -> b -> [a]. То о чем пишешь ты - это динамическая типизация и она таки в Хаскеле имеет место быть. Дальше поверх нее накручиваются классы, которые практически идентичны жабовским инерфейсам.

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

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

> То о чем пишешь ты - это динамическая типизация и она таки в Хаскеле имеет место быть.

Гм... Ты серьёзно???

>То о чем пишешь ты - это динамическая типизация и она таки в Хаскеле имеет место быть.

Динамическая типизация в Хаскелле - это Data.Dynamic, а не то что он имеет ввиду...

Это я уже понял. Про Data.Dynamic я, конечно, знаю, но мужик явно не в теме.

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

let f x y z = 
   let _ = y + (doSomething x) in 
     print_string x

можно сделать вывод, что 
1) 'x' имеет тип string, поскольку 
используется в функции print_string которая на вход должна получать 
строку 
2) 'y' должен иметь тип int поскольку используется в качестве 
одного из аргументов в операторе +, который имеет тип int->int->int 
3)Функция 'doSomething' должна иметь тип string -> int 
4) Функция f должна иметь тип string->int->b->unit, где b - пофигу какой тип. 

Все это вычисляется на этапе трансляции. Поэтому с одной стороны программист в явном виде типы почти не описывает (за некоторыми исключениями), но транслятор знает какой тип может иметь каждая сущность. 

Во-первых вот

http://ru.wikipedia.org/wiki/%D0%9C%D0%BE%D0%B4%D0%B5%D0%BB%D1%8C_%D1%82%D0%B...

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

Динамическая - это когда тип известен только в рантайме, статическая стало быть наоборот. Т.е. в Хаскелле статическая, кроме Data.Dynamic.

Во-1, что такое Хиндли-Милнер я знаю явно получше тебя.

Во-2, основным признаком динамической типизации является определение типа во время исполнения, а не во время компиляции. Тип выражений Хаскеля определяется во время компиляции (если не пользоваться костылями^W экстеншенами типа Data.Dynamic). Посему Хаскель - язык статически типизированный.

Да похер на самом деле :))

Надоело уже троллить на эту тему :)))

> С какого легче начать обучение - Haskell или Lisp.

С Ерланга.

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

Много выпили на 8-ое марта??

Хинт: C# тоже научился определять некоторые типы из контекста.

И VB.Net :)

Хороший флейм.

А есть какой-нить диалект лиспа, чтоб на нем можно было не из коробки, но и не особо напрягаясь, слобать систему типов Хаскеля c ее type inference?

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

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

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

Вообще-то большинство Лиспов позволяют использовать статическую типизацию (что ускоряет исполнение в разы). Если известно, что аргумент функции int, а не хрень неизвестная, то и арифметика над ним будет инлайниться, все дела. Так что type inference уместен и даёт реальную пользу. И, да, реализаций таких - полно.

> Так что type inference уместен и даёт реальную пользу. И, да, реализаций таких - полно.

Кинь ссылку на лучшие 3, только не гугль.