Пользователь
0,0
рейтинг
26 ноября 2013 в 15:45

Разработка → Прелюдия или как полюбить Haskell из песочницы

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

Почему нельзя просто взять и пересесть на Haskell?

«Вы все испорчены императивным стилем!» — так сказал нам наш первый преподаватель функциональных языков, замечательный человек, ученый и организатор Сергей Михайлович Абрамов. И он был прав. Как же трудно было забыть про переменные, присваивания, алгоритмы и начать думать функциями. Вы можете сесть и написать программу на Haskell, без проблем. Вы можете построить вложенный цикл, использовать переменные и присваивания, да легко! Но, потом, вы посмотрите на свой код и скажете: «Кому нужна эта функциональщина? Да, я на си напишу и быстрее, и лучше».

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

Читайте прелюдию

Ответ прост. Всего два слова. Читайте прелюдию! Если вы хотите постичь и полюбить Haskell, если хотите научиться чистому функциональному стилю, читайте прелюдию.

Прелюдия (Prelude) — стандартная библиотека самых необходимых функций, определяется стандартом Haskell 98. Каждая строчка, каждая точка выверены и вылизаны, ничего лишнего и императивного там не находится. Читая прелюдию, ты испытываешь эмоции сравнимые с эмоциями при прочтении интересной фантастической книги.

Одно из моих любимых мест в прелюдии это раздел где описывается работа со списками.
Возьмем, например, функцию map.
map :: (a -> b) -> [a] -> [b]
map f []     = []
map f (x:xs) = f x : map f xs

Вы помните — мы мыслим функциями.
Что есть функция map? На входе мы имеем некоторую функцию из множества A в множество B, и список элементов из множества A. На выходе должны получить список из множества B, путем применения функции к каждому элементу списка.

Эта функция является отличным примером одного из основных приемов работы в Haskell — паттерны. Map имеющая на входе параметры вида а f [] (функция и пустой список) возвратит пустой список. В остальных случаях f применится к первому элементу списка, получившийся элемент добавится (двоеточие) к списку, образованному путем применения функции map к хвосту списка.
Одно из главных достоинств Haskell — если вы сформулировали функцию на математическом языке, запрограммировать ее, как правило, дело нескольких минут.

Еще немножко примеров

А, вот, еще одно чудо: функции head и tail, ну, просто загляденье!
head             :: [a] -> a
head (x:_)       =  x
head []          =  error "Prelude.head: empty list"

tail             :: [a] -> [a]
tail (_:xs)      =  xs
tail []          =  error "Prelude.tail: empty list"

Думаю, тут даже объяснять нечего. Нижнее подчеркивание в паттернах Haskell расшифровывается как «все что угодно».
null             :: [a] -> Bool
null []          =  True
null (_:_)       =  False

Неужели, существуют люди, которым это не нравится?

А вот функция length.
length           :: [a] -> Int
length []        =  0
length (_:l)     =  1 + length l


А как в прелюдии определен класс Eq? Вы будете смеяться!
class  Eq a  where
    (==), (/=) :: a -> a -> Bool

        -- Minimal complete definition:
        --      (==) or (/=)
    x /= y     =  not (x == y)
    x == y     =  not (x /= y)

Правда головокружительная красота?

О чем я?

Можно было бы привети много примеров кода, но зачем портить вам удовольствие?
Всем новичкам, всем кто хочет полюбить Haskell один совет — читайте прелюдию. Я читаю и стараюсь писать как в прелюдии. Хотя бы стремлюсь. Читая прелюдию я понял философию Haskell и полюбил этот язык, чего всем вам желаю!
Простите, за сумбур, наверное я не писатель, я очень плохо изложил все то, что было нужно, но мне очень хотелось поделиться с вами частичкой любви к Haskell и этим маленьким, но очень полезым советом. Читайте прелюдию!
Сергий Смирнов @serr
карма
18,7
рейтинг 0,0
Реклама помогает поддерживать и развивать наши сервисы

Подробнее
Спецпроект

Самое читаемое Разработка

Комментарии (107)

  • +17
    Функциональщина — это всегда плюс.

    Действительно, один из самых эффективных способов разобраться с языком — перелопатить какую-нибудь библиотеку или фреймворк, написанные на нем. Библиотека встроенных функций — хороший тому пример.

    Люблю ФЯ за их красоту и лаконичность. Не за производительность и «другой подход» к решению задач. Нет, именно за синтаксис. А данная библиотека — неисчерпаемый источник этого счастья. Большинство функций простые, короткие и понятные.

    Спасибо, что еще раз напомнили.
    Очистим же разум от императивной скверны! (Чую минусов отхвачу, но не могу удержаться)
    • +11
      Вы правы. Синтаксис — одно из основных преимуществ ФЯ.
      С.М.Абрамов, о котором я писал в статье (еще раз большое ему спасибо!), рассказывал о своем первом знакомстве с Haskell. Он увидел, как, в какой-то статье про алгоритмы, функции записывались в очень интересном виде. Вроде бы без специальных типографских символов для формул, но все понятно. И он переписал некоторые свои статьи согласно этому синтаксису. И в каком же он был шоке, когда, некоторое время спустя, ему сказали, что он запрограммировал свои статьи на Haskell. А потом, он запустил это все в интерпретаторе и оно заработало.
      • 0
        Вот уравнение

        image

        solve (fvm::ddt(U) + fvm::div(phi, U) + fvm::laplacian(nu, U) == -fvc::grad(p) + f);
        

        А вот это код на С++, решающий это уравнение в частных производных (естественно, не без библиотек). Так что какой-то особый синтаксис языка необязателен, чтобы вычисления на нём можно было писать интуитивно, особенно если язык — такой монстрик, как С++.
    • +1
      Если бы окружающий мир был свободен от императивной скверны, все было бы гораздо проще.
      • +2
        Не хотелось бы разводить холивар ФЯ vs ИЯ. Думаю, каждый язык имеет свои преимущества, недостатки и область применения.
      • +8
        Тоже люблю ФП, но вот не надо экстремизма. :)
        • +2
          Я больше про несовместимость pure & lazy с реальным миром.
          • +3
            Ааа, понял. Я то думал что наезд на ООП.

            Вообще, ООП берет за основу «идеологии» реальный мир. Pure ФП использует математическую модель вселенной. А компьютеры, как мне кажется, работают в своей третьей вселенной, абсолютно отличной от первых двух. Но мы, примитивные существа, не в состоянии осознать её правила, так как приучены мыслить в рамках объектов и процессов. Вот и напридумывали «переводчиков» разной степени кривости…

            Это так, минутка философии в комментариях на хабре… :)
            • –3
              Только загвоздка в том, что программы пишутся не для вселенских, а для людских задач — задач «примитивных существ». Соответственно, математические задачи решаются на одних языках, манипуляция объектами осуществляется с помощью других языков, парсеры-лексеры описываются ещё своими языками.

              И разные модели вселенной тут вообще ни при чём. Ну совершенно.
              • 0
                Во-первых, процитирую (не совсем дословно), одного из ведущих радио-т: где вы видели чтобы в реальном мире объект выезжал из абстрактной фабрики?

                Во-вторых, программы не пишутся для людских задач. Программы пишутся для замены одних байтов на другие. Веб-сайт — это не страница (как в книге). HTTP — это не кабель. gif — это не рисунок. Единственные задачи которые пишутся для реальных «людских» задач — это моделирование физических (и не только) процессов. И там, как ни странно, ООП редко используется.
                • –1
                  Вы немного отстали от жизни. Люди больше не читают книг — люди большей частью сидят на веб-сайтах. Прокладывают кабеля люди тоже достаточно редко. И картины с рисунками уступили своё место всяким джипегам. Нравится вам это, не нравится вам это, но Интернет и компьютеры (а также внутренние «несуществующие» объекты наподобие файлов) являются частью реального мира. Ещё раз — файлы являются объектами реального мира. Деление на Виртуальность и Реальность с недавних пор стало бредом.

                  Никакому человеку не нужно заменять одни байты на другие. Людям нужно смотреть картинки, читать посты, писать сообщения, слушать музыку и смотреть видео. Это всё — людские задачи. То, что вы их называете «заменой одних байтов на другие», имеет смысла ничуть не больше, чем описание ваших повседневных задач как «перемещение атомов с одного места на другое».

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

                  А вот провести пальцем по гладкой пластинке, что повлёчёт за собой передачу определённых сигналов, которые заставят измениться две переменные типа integer, что приведёт к тому, что определённым образом изменится поляризация жидкокристаллических ячеек — и последующее изменение давления пальца на пластинку, что вызовет подачу сигналов в два устройства, которые начнут вибрировать — это людская задача. «Включить песню» называется.
                  • 0
                    «изменить две переменные типа integer» — это и есть «заменить одни байты на другие». Почему первое — людская задача, а второе — нет, непонятно. Подача сигнала на устройство также выполняется как замена байтов на порте устройства.
                    • 0
                      Именно это я и хотел сказать. Задачи «зайти на сайт», «послать сигналы» и «изменить байты» эквивалентны — и, следовательно, все являются людскими.
                      • 0
                        Но сказали-то что замена байтов не имеет смысла.
                        • +1
                          Но задача «зайти на сайт» очевидно является людской.

                          Любую задачу можно разложить на мелкие подзадачи вроде передвижения атомов, замены байтов или выезжание объекта из абстрактной фабрики, а потом сказать «ага, вот эти все задачи по отдельности не людские, значит и вся целая задача тоже не людская!»
                  • 0
                    А Вы уверены что Вы реальны?
                    • +1
                      Вот только спора об определениях нам не хватало. Я уверен, что я реален не меньше, чем окружающие меня предметы и явления.

                      Если вы намекаете на то, что всё на самом деле «нереально», то хотелось бы заметить, что в контексте этой дискуссии понятие реальности не связано с соответствующим понятием в философии. Я уже давно замечаю, что понятия «виртуального» и «реального» мира в компьютерных дискуссиях (простое желание гиков самоидентифицироваться и отделить себя от «некомпьютерных» обывателей) начинают путать с понятием виртуальной реальности, известной задо-олго до возникновения Интернета.
                      • 0
                        > Я уверен, что я реален

                        Так, просто к слову: А кем уверен? Кто Вас в этом уверил? :)
                        Мне просто нравятся игры слов…
                • +1
                  Вы не совсем правы, практически всё современное ПО для моделирования физики как раз ООП (может конечно в разных областях по-разному). Во всяком случае, то с чем я знаком.
              • +2
                Ок, спустимся от философии к практике. ФП-язык и ООП-язык — не говоря уже о DSL парсеров — строятся на различных наборах понятий. И ничего из этих понятий не существует для процессора. Для процессоров не существует типов, объектов, функций, даже циклов. Даже присваивания как такового не существует, потому что нечему присваивать. Процессоры абсолютно императивен, если вспоминать про декларативные языки.
                Вот вам и разные вселенные. И для преодоления разрыва между этим вселенными используются бесконечные костыли разных уровней — vtbl, thunk-и, кодогенерация, виртуальные машины, монады и прочие многообразные ужасы. И что самое печальное — для того, чтобы что-то написать для своих людских задач, используя приятную тебе семантику, нужно преодолеть этот разрыв и не забыть про abstraction penalty этого преодоления.

                Я, кстати, не понимаю, как вообще можно программировать, не помня об этом.
                • +1
                  И для преодоления разрыва между этим вселенными используются бесконечные костыли разных уровней — vtbl, thunk-и, кодогенерация, виртуальные машины, монады и прочие многообразные ужасы.

                  Всё намешали в одну кучу.

                  Виртуальные машины вроде LLVM используются не для преодоления какого-то мифического разрыва между вселенными, а для упрощения кодогенерации на разных (но схожих) платформах. Вы бы ещё сказали, что язык Си используется для преодоления разрыва. Процессор, ассемблер, Си, промежуточный язык GHC, сам Хаскелл — это что, всё разные вселенные? Раздули из мухи (ну ладно, мышки или хомячка) слона.

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

                  Вообще, у вас какой-то очень странный взгляд на абстракции — вы их все назвали «бесконечными костылями». Ну да, костыли — если считать проблемой то, что у нас не один утверждённый Богом язык, компилятор, процессор, алгоритм, структура данных и т.д., а много. По-моему, это как раз не проблема.

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

                  Вспомните — несколько десятков лет назад были специализированные Лисп-машины. А сейчас их нет. И что? Если современного Лиспера пересадить на Лисп-машину вместо компьютера с «абсолютно императивным» процессором, для него ничего не изменится. Ну разве что работать быстрее станет. Наверное.

                  Я, кстати, не понимаю, как вообще можно программировать, не помня об этом.

                  А я понимаю. Не так страшен abstraction penalty, как его малюют.
            • –1
              Компьютеры как раз работают в реальной вселенной (и являются ее частью), так же как и человеческий мозг. Отсюда и проблема — чтобы решить проблему расово правильно, надо сделать две межвселенских перехода: мозг-математика и математика-компьютер, в то время как рядом соблазнительный прямой туннель мозг-компьютер — но который с точки зрения математики оказывается кривым. Такая вот печалька.
              • 0
                А причём тут математика?
                • +2
                  математика — она везде «причем». А там, где не причем — значит, эта область знаний/практик недоразвита.
                  • 0
                    Я захожу на сайт и как будто бы не использую никакой математики. Я читаю книгу с экрана и тоже математики не применяю, потому что книга про поросёнка Петю и к математике не относится. Вот он, прямой туннель мозг—компьютер. Где я должен был совершить два межвселенских перехода, с какой целью, и что не так сейчас?
                    • 0
                      Вы — не должны, это программист должен, чтобы вас качественно обслужить.
                      • 0
                        Ага. А программисты бывают разных уровней. На самом нижнем уровне (структура процессора) нужны физика и математика. Из этого не следует, что математика также нужна и на всех высших уровнях. Или вы все абстрации заносите в раздел «математика»?
                        • 0
                          Нет, не все. Но математики всегда чувствуют, является ли та или иная абстракция математической, и отторгают нематематические. Иногда перебарщивают и отвергают то, что впоследствии признают (например, операционное исчисление).
                          • +1
                            Я бы очень поостерёгся делить абстракции на математические и нематематические. Файл — математическая абстракция или нет?
                            • –1
                              Конечно, остерегайтесь, чтобы не попасть впросак в глазах математиков.

                              Думаю, что математики не признАют файл математической абстракцией. Впрочем, я не математик.
                              • +1
                                Нет, я остерегаюсь по той причине, что делить мир на чёрное и белое в большинстве случаев неверно.

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

                                Ко многим повседневным задачам файлы подходят хорошо.
    • +5
      И, снова, о важности прелюдии в процессе любви! (на этот раз к хаскелю)
    • 0
      Особенно по сранению с такими прекрасными и удивительными языками как J ;)
  • +3
    Прелюдия (Prelude) — стандартная библиотека самых необходимых функций, определяется стандартом Haskell 98.

    Хоть это, безусловно, и правда, но хочу заметить, что Haskell 98 уже устарел. Текущая версия стандарта — Haskell 2010.
  • +3
    Изучение стандартных библиотек и различных исходников — основа основ. Честно, ожидал увидеть некое сравнение с империческими ЯП, показывающее, как лаконично можно решать большие и объемные задачи.
    А в итоге выдержки из прелюдии и фраза, которая повторяется чуть ли не через каждое слово — «читайте прелюдию».
    Это всё равно, что выкладывать куски кода из msdn и говорить: «Ой, как красиво написали!»
    Никого не хотел обидеть. Просто впечатление от прочтения.
    • +2
      Если бы автор начал сравнивать хаскель с императивными языками — начался бы срач (так всегда бывает).
      На хабре статья есть «через тернии к haskell» там есть сравнения. Прсмотрите.
      • –5
        О, спасибо, начало статьи интригующее: добавил в закладки для вечернего чтения )
        К сожалению, карма не даёт плюсануть.
    • +2
      Да, никто не обижается. Сам вижу, что получилось не то, что хотел. Понимаете, эмоции переполняют, а, вот, излагать материал плохо получается. Надеюсь, только, что кого-нибудь этот текст подтолкнет к изучению Haskell.
      • 0
        Я когда впервые увидел определение Eq тоже был счастлив. =)
  • +12
    Если бы вы ещё описали, что именно и как эти функции делают, было бы совсем замечательно.
    Вы ведь рекламируете Хаскель тем, кто с ним никогда не работал? Но человеку, который с Хаскелем незнаком, ваши восторги непонятны.
    PS
    ++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++ .>+.+++++++..+++.>++.<<+++++++++++++++.>.+++. ------.--------.>+.>.
    Правда, головокружительная красота?
    • +2
      Помогу немного автору:

      head — вернуть первый элемент list'a.
      tail — вернуть list без первого элемена.
      x:xs — добавить элемент x в начало list'a xs и вернуть этот list
      [] — пустой list (как и у всех языках, в принципе)

      Надеюсь стало немного понятнее.
      • +3
        Вы как раз описали наиболее понятные конструкции.
        Вот эти гораздо интереснее:
        :: ->
        И, наконец, что это:
        (_:_)
        • +3
          tail :: [a] -> [a]
          Функция tail принимает на вход список элементов множества а и возвращает список элементов множества а.
          xxx :: [Integer] -> Bool -> [Bool]
          Функция xxx принимает на вход список элементов Integer и значение Boolean, а возвращает список Boolean.
          (_:_) — непустой список.

        • +2
          А, ок, виноват:

          После :: идет описание типа функции/данных.

          -> используется в описании типов для обозначения обработки данных (transformation). Если по сути, слева от этого знака — тип аргумента функции, а справа — тип возвращаемого значения. Например Int -> Boot — тип функции которая принимает целое число и возвращает булевское значение.
          Пример посложнее: Int -> Float -> Bool это функция, которая принимает аргумент Int и возвращает функцию Float -> Bool. Благодаря синтаксическому сахару первой функции можно передать 2 значения (Int и Float) и рассматривать ее как функцию с двумя аргументами, которая возвращает просто Bool.

          (_:_) — здесь все просто: скобки для компилятора — можно игнорировать. Подчеркивание _ значит «любое значение». Соответственно _:_ значит «head list'a — любой елемент, tail list'a — любой список». Под это определение подойдет любой список за исключением пустого, так как он не удовлетворяет первую часть условия (head list'a — любой элемент), так как «head []» — это не валидная конструкция (в рантайме вызывает эксепшн).
        • 0
          В коротком комментарии, пожалуй, не объяснишь, что такое декларация типа (::), стрелка (->), образец вообще и список вида голова+хвост ((_:_)) в частности, но, чтобы поддержать Ваш интерес к Хаскелю, скажу, что даже такая конструкция имеет смысл, значение и тип:
          (.)(.)

          • 0
            Сломал себе мозг думая где это может быть использовано и к чему оно приведет в последствии. :)
            • +1
              Prelude> :t ((.)(.))
              ((.)(.)) :: (a -> b -> c) -> a -> (a1 -> b) -> a1 -> c

              Prelude> let f = ((.)(.)) (:) (+ 1) (const [])
              Prelude> :i f
              f :: a -> [Integer -> Integer] — Defined at :45:5
              Prelude>

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

              • 0
                Поигрался в ghci — понял. Мне кажется если добавить еще одну сись композицию — можно понять вселенную где-то до девятого измерения.
          • +5
            ((_:_))
            
            ((.)(.))
            


            Это серьезно? А вот такое есть?

            ((_._))
            


            • 0
              Нет, к сожалению. Сделать-то можно, но это будет моветон.
              • –1
                del
            • +5
              Есть вот такое:

              (_|_)

              Bottom называется.
              • +14
                Так я вижу что bottom.
        • 0
          я думаю, это можно добавить в статью )
    • +1
      Синтаксис приведенных функций аналагичен обычной математической записи. Но, Вы, правы. Буду тренироваться. Если написал никому не нужный текст — простите, готов удалить.
      • 0
        Не стоит
  • +7
    Кстати, я вот тут собирался написать статью (или даже несколько) с подробным описанием типизации данных в Haskell. Очень уж это широкая и элегантная концепция. Как думаете, есть смысл писать о типах данных (и их обработке на этапе компиляции), в отрыве (насколько это возможно) от выполнения кода (рантайма)?
    • +1
      Думаю, стоит.
      Тема несколько необычная и у меня лично вызвала самые большие затруднения при изучении хаскеля. После императивных яп трудно воспринимается. Если в статье подход к обяснениям будет не такой, как в большинмстве учебников — обязательно прочитаю. Взглянуть с другой стороны, так сказать.
      С нетерпением буду ждать :-)
      • +1
        Попытаюсь что-то «скомпилировать», тем более что уже есть некоторые наработки. Спасибо.
  • +1
    К сожалению не могу того же сказать про Scala. Открываешь исходники — а там всякие оптимизации, иногда с вкраплениями императивщины. Так что, еще один аргумент в пользу чисто функциональных языков — чистота библиотек.
  • +21
    Простите за цинизм, но это очередная статья о непонятном языке программирования, где его адепт восхваляет абсолютно непонятные куски кода без единого объяснения.
    Если вы так хотите переманить всех «императивщиков» на свою сторону, то уж пишите интересные статьи с интересными и обязательно пояснёнными примерами, а не кидайтесь кусками китайско-подобного когда с воплями восхищения.
  • +6
    Спасибо. Было трудно, но я подрочил.
  • НЛО прилетело и опубликовало эту надпись здесь
    • +2
      А о чем это вы? Не дадите ссылку?
      • +1
      • НЛО прилетело и опубликовало эту надпись здесь
        • +4
          Какой то он подозрительно сиподобный (насколько это возможно в функциональных языках)… Нет, все же Хаскел красивее.

          Но туториал прочту.
          • НЛО прилетело и опубликовало эту надпись здесь
            • НЛО прилетело и опубликовало эту надпись здесь
  • +1
    Понял всё, кроме того, что такое класс Eq и что он делает.
    • +1
      Это тип данных, которые можно сравнивать (перегружают операции сравнения).
      • 0
        В общем, если я правильно понял, это абстрактный класс, операции == и /= сами ничего не делают, и одну из них надо в производном классе перегрузить.
  • 0
    Правильно-ли я понимаю, что length — это рекурсия? Как и map.
    • 0
      Да, но length оптимизируется в цикл.
    • –1
      А map в цикл не оптимизируется, но ему и не надо. Если интересно, могу объяснить, почему.
      • 0
        можете объяснить, почему не оптимизируется, или почему ему и не надо?
        • 0
          параллелить можно
        • 0
          потому что Хаскель справляется с бесконечными списками
        • +1
          Потому что ленивость. Представьте, что вместо списка у вас Питоновский генератор — применение функции к каждому элементу не должно никак влиять на производительность до тех пор, пока вы эти элементы не начнёте вычислять. А вот для массивов да векторов map отлично оптимизируется в цикл.
  • +10
    Делал несколько подходов к Haskell. Спору нет, после него все остальное выглядит блекло. Думаю человек, которому удалось сделать на нем что нибудь полезное, что нибудь нужное в быту, никогда уже не сможет вернуться к другим языкам. Мне не удалось. А сколько разочарований: неизбежность компиляции по месту потребления, громоздкость monad transformers, вечная борьба с cabal, ощущение ненужности на freenode.net #haskell — нет я могу понять о чем они говорят, не постигаю зачем. И в конце болезненное возвращение к серости земного. Для себя решил, пусть любовь к Haskell остается возвышенной и нереализованной.
    • +6
      Может изучение Haskell и делает программиста лучше, но по моему несчастней.
  • –1
    Неужели, существуют люди, которым это не нравится?


    Существуют. (_:_) — это невозможно понять — это нужно просто запомнить :) Почему-то большинство функциональных языков очень любят использовать спецсимволы для основных, я бы сказал фундаментальных, конструкций. Ладно скобочки но сложно вместо -> написать function например. Мне нравятся принципы ФП изучать, но чисто теоретически — читать ФЯП их не могу, тем более на них писать. Разве что в PHP использовать принципы :)
    • +5
      (_:_) — это невозможно понять — это нужно просто запомнить :

      Ну прямо таки!

      Две абстракции:
      "_" — означает — тут стоит параметр, но нам не нужно её значение, нам пофиг на него, и оно вычислено не будет (по крайней мере для ленивых значений)

      ":" — это соединитель хвоста и головы в список.
      В терминах самого Хаскеля, список определён так:
      data [a] = [] | a : [a]
      

      По-русски — список — гомогенный — он пустой([]) или ( там стоит ИЛИ | ) состоит из головы и списка. Это рекурсивное определение.

      Исходя из этого, (_:_) — это непустой список, где нам неважны его значения.
      • 0
        ЕМНИП, оно может вообще быть никогда не вычислено, даже если там не _, а что-то другое. Т. е. в данном случае мы просто пишем это, потому что не интересуемся значением и чтобы не вводить новую переменную в локальной области видимости. Если бы мы написали (eval:l), то eval, в отличие от l, не вычислилось бы, потому что нигде не используется в локальной области видимости.
      • +1
        "_" — означает — тут стоит параметр, но нам не нужно её значение, нам пофиг на него, и оно вычислено не будет


        Оно не будет вычислено, даже буде там x написан. Список будет приведён к WHNF, т.е. вычислит, что он не пустой, а с головой и хвостом, но не вычислит ни саму голову, ни хвост:

        test = case (undefined:undefined) of
          [] -> False
          (x:y) -> True
        


        Результат: True
    • 0
      В Haskell все функции ровно одного аргумента, для реализции функции многих аргументов применяется концепция карирования, то есть применения аргументов к функции по очереди. Результат применения первого аргумента суть функция остальных. В такой семантике «вместо -> написать function» не получится.
    • 0
      "->" — это еще ничего. В Racket, который тесно связан со своей IDE — есть даже греческая буква λ для лямбда-выражений. Хорошо хоть ключевое слово lambda оставить додумались.
    • +2
      Без обид, но если вы считаете что (_:_) это не логично, а function то же самое что и -> вам все же нужно подучить базовые принципы ФП…
      • 0
        Я понятия не имею что значит -> в Хаскеле и поєтому написал «например». Ещё раз — я изучаю теорию, не вдаваясь синтаксис какого-то конкретного ФЯП. Примеры в книгах и статьях обычно есть на каком-то конкретном, но я в них читаю только то, что они иллюстрируют, не обращая внимания на синтаксис, не пытаюсь, например, расшифровать
        null             :: [a] -> Bool
        
        , а смотрю на
        null []          =  True
        null (_:_)       =  False
        
        , не пытаясь расшифровать и (_:_)
        • +2
          (_:_) — это невозможно понять — это нужно просто запомнить

          Если вы утверждаете, что что-то невозможно понять, это обычно предполагает, что вы хотя бы попытались это понять.
          • 0
            :) — означает шутку, а не символы какого-то ЯП. Да и сама фраза, как говорится, «мем» из анекдота…
            • 0
              Кроме шутки, у смайлика есть ещё дюжина значений. С учётом того, что в этом же сообщении было
              но сложно вместо -> написать function например.

              я не воспринял это как шутку.

              Вот сейчас хотел привести пример какого-нибудь языка, в котором :) являлось бы самодостаточным осмысленным выражением, но ничего не вспомнил. Никто не подскажет?..
              • 0
                Скобки, как правило, заняты для другого.
        • 0
          (_:_) — это невозможно понять — это нужно просто запомнить

          не пытаясь расшифровать и (_:_)


          Нда…
        • 0
          В текстах по математике не пишут function, в них пишут, например, f: R->R. Об этом и хаскель.
    • 0
      Ну вы же не пишете plus вместо + и equal вместо ==. Главное один раз привыкнуть.
      • 0
        Это общепринятые обозначения и, да, иногда пишу (PHP не поддерживает перегрузку операторов).
        • 0
          Общепринятость — это очень и очень хорошо. Главное, чтобы это не переходило в консерватизм, который уже так себе.
  • 0
    дубль
  • –1
    Не стоило, на мой взгляд, так сходу говорить о классе Eq, предварительно не объяснив что такое классы типов. Новичок совсем ничего не поймёт, а остальные уже успели оценить эстетическую составляющую. В целом, конечно, идея статьи правильная, но напрашивается более развернутое описание.
    Если вы знакомы с С. М. Абрамовым, то в своих будущих статьях обязательно вставляйте его цитаты, этот человек — кладезь коротких но емких и умных фраз.
  • 0
    А я учил по эволюции программиста на Haskell. Там код читать тоже было своеобразное удовольствие :-).
  • +1
    С недавних пор изучаю реализации транзакционной памяти. Очень понравилась реализация Haskell. Предельно простая и понятная, благодаря системе типов языка. Гугление привело на довольно интересные курсы School of Haskell, где многие особенности языка тоже очень доходчиво описаны. До этого лишь немного читал Learn You a Haskell for Great Good, но смог разобраться в необходимой фиче. Рекомендую!
  • +2
    >А как в прелюдии определен класс Eq? Вы будете смеяться!

    Подскажите, я еще только начинаю изучать haskell и в этом месте для меня полнейший ступор

    Это всё красиво конечно, но только как оно работает? как реально сравнение происходит? когда 2 функции (== и \=) по сути ссылаются друг на дружку?

    Haskell мне интересен — но из за вот таких вот головоломок читать код становится очень тяжело. (хотя наверное это просто из за плохого понимания языка)
    • 0
      Как минимум одну из функций (==) или (\=) переопределяют в instance-ах. И снимают зацикленность.
      Как правило, переопределяют (==)

Только зарегистрированные пользователи могут оставлять комментарии. Войдите, пожалуйста.