Миран Липовача - Изучай Haskell во имя добра!
- Название:Изучай Haskell во имя добра!
- Автор:
- Жанр:
- Издательство:ДМК Пресс
- Год:2012
- Город:Москва
- ISBN:978-5-94074-749-9
- Рейтинг:
- Избранное:Добавить в избранное
-
Отзывы:
-
Ваша оценка:
Миран Липовача - Изучай Haskell во имя добра! краткое содержание
Язык Haskell имеет множество впечатляющих возможностей, но главное его свойство в том, что меняется не только способ написания кода, но и сам способ размышления о проблемах и возможных решениях. Этим Haskell действительно отличается от большинства языков программирования. С его помощью мир можно представить и описать нестандартным образом. И поскольку Haskell предлагает совершенно новые способы размышления о проблемах, изучение этого языка может изменить и стиль программирования на всех прочих.
Ещё одно необычное свойство Haskell состоит в том, что в этом языке придаётся особое значение рассуждениям о типах данных. Как следствие, вы помещаете больше внимания и меньше кода в ваши программы.
Вне зависимости от того, в каком направлении вы намерены двигаться, путешествуя в мире программирования, небольшой заход в страну Haskell себя оправдает. А если вы решите там остаться, то наверняка найдёте чем заняться и чему поучиться!
Эта книга поможет многим читателям найти свой путь к Haskell.
Отображения, монады, моноиды и другое! Всё сказано в названии: «Изучай Хаскель во имя добра!» – весёлый иллюстрированный самоучитель по этому сложному функциональному языку.
С помощью оригинальных рисунков автора, отсылке к поп-культуре, и, самое главное, благодаря полезным примерам кода, эта книга обучает основам функционального программирования так, как вы никогда не смогли бы себе представить.
Вы начнете изучение с простого материала: основы синтаксиса, рекурсия, типы и классы типов. Затем, когда вы преуспеете в основах, начнется настоящий мастер-класс от профессионала: вы изучите, как использовать аппликативные функторы, монады, застежки, и другие легендарные конструкции Хаскеля, о которых вы читали только в сказках.
Продираясь сквозь образные (и порой безумные) примеры автора, вы научитесь:
• Смеяться в лицо побочным эффектам, поскольку вы овладеете техниками чистого функционального программирования.
• Использовать волшебство «ленивости» Хаскеля для игры с бесконечными наборами данных.
• Организовывать свои программы, создавая собственные типы, классы типов и модули.
• Использовать элегантную систему ввода-вывода Хаскеля, чтобы делиться гениальностью ваших программ с окружающим миром.
Нет лучшего способа изучить этот мощный язык, чем чтение «Изучай Хаскель во имя добра!», кроме, разве что, поедания мозга его создателей. Миран Липовача (Miran Lipovača) изучает информатику в Любляне (Словения). Помимо его любви к Хаскелю, ему нравится заниматься боксом, играть на бас-гитаре и, конечно же, рисовать. У него есть увлечение танцующими скелетами и числом 71, а когда он проходит через автоматические двери, он притворяется, что на самом деле открывает их силой своей мысли.
Изучай Haskell во имя добра! - читать онлайн бесплатно ознакомительный отрывок
Интервал:
Закладка:
Мы можем использовать оператор <*>со списками вот так:
ghci> [(*0),(+100),( 2)] <*> [1,2,3]
[0,0,0,101,102,103,1,4,9]
Левый список содержит три функции, а правый – три значения, поэтому в результирующем списке будет девять элементов. Каждая функция из левого списка применяется к каждому элементу из правого. Если у нас имеется список функций, принимающих два параметра, то мы можем применить эти функции между двумя списками.
В следующем примере применяются две функции между двумя списками:
ghci> [(+),(*)] <*> [1,2] <*> [3,4]
[4,5,5,6,3,4,6,8]
Оператор <*>левоассоциативен, поэтому сначала выполняется [(+),(*)] <*> [1,2], результатом чего является такой же список, как [(1+),(2+),(1*),(2*)], потому что каждая функция слева применяется к каждому значению справа. Затем выполняется [(1+),(2+),(1*),(2*)] <*> [3,4], что возвращает окончательный результат.
Как здорово использовать аппликативный стиль со списками!
ghci> (++) <$> ["хa","хeх","хм"] <*> ["?","!","."]
["хa?","хa!","хa.","хeх?","хeх!","хeх.","хм?","хм!","хм."]
Ещё раз: мы использовали обычную функцию, принимающую две строки, между двумя списками строк, просто вставляя соответствующие аппликативные операторы.
Вы можете воспринимать списки как недетерминированные вычисления. Значение вроде 100или "что"можно рассматривать как детерминированное вычисление, которое имеет только один результат. В то же время список вроде [1,2,3]можно рассматривать как вычисление, которое не в состоянии определиться, какой результат оно желает иметь, поэтому возвращает нам все возможные результаты. Поэтому когда вы пишете что-то наподобие (+) <$> [1,2,3] <*> [4,5,6], то можете рассматривать это как объединение двух недетерминированных вычислений с помощью оператора +только для того, чтобы создать ещё одно недетерминированное вычисление, которое ещё меньше уверено в своём результате.
Использование аппликативного стиля со списками часто является хорошей заменой генераторам списков. В главе 1 мы хотели вывести все возможные комбинации произведений [2,5,10]и [8,10,11]и с этой целью предприняли следующее:
ghci> [x*y | x <���– [2,5,10], y <���– [8,10,11]]
[16,20,22,40,50,55,80,100,110]
Мы просто извлекаем значения из обоих списков и применяем функцию между каждой комбинацией элементов. То же самое можно сделать и в аппликативном стиле:
ghci> (*) <$> [2,5,10] <*> [8,10,11]
[16,20,22,40,50,55,80,100,110]
Для меня такой подход более понятен, поскольку проще понять, что мы просто вызываем оператор *между двумя недетерминированными вычислениями. Если бы мы захотели получить все возможные произведения элементов, больших 50, мы бы использовали следующее:
ghci> filter (>50) $ (*) <$> [2,5,10] <*> [8,10,11]
[55,80,100,110]
Легко увидеть, что вызов выражения pure f <*> xsпри использовании списков эквивалентен выражению fmap f xs. Результат вычисления pure f– это просто [f], а выражение [f] <*> xsприменит каждую функцию в левом списке к каждому значению в правом; но в левом списке только одна функция, и, следовательно, это похоже на отображение.
Тип IO – тоже аппликативный функтор
Другой экземпляр класса Applicative, с которым мы уже встречались, – экземпляр для типа IO. Вот как он реализован:
instance Applicative IO where
pure = return
a <*> b = do
f <���– a
x <���– b
return (f x)
Поскольку суть функции pureсостоит в помещении значения в минимальный контекст, который всё ещё содержит значение как результат, логично, что в случае с типом IOфункция pure– это просто вызов return. Функция returnсоздаёт действие ввода-вывода, которое ничего не делает. Оно просто возвращает некое значение в качестве своего результата, не производя никаких операций ввода-вывода вроде печати на терминал или чтения из файла.
Если бы оператор <*>ограничивался работой с типом IO, он бы имел тип (<*>) :: IO (a –> b) –> IO a –> IO b. В случае с типом IOон принимает действие ввода-вывода a, которое возвращает функцию, выполняет действие ввода-вывода и связывает эту функцию с идентификатором f. Затем он выполняет действие ввода-вывода bи связывает его результат с идентификатором x. Наконец, он применяет функцию fк значению xи возвращает результат этого применения в качестве результата. Чтобы это реализовать, мы использовали здесь синтаксис do. (Вспомните, что суть синтаксиса doзаключается в том, чтобы взять несколько действий ввода-вывода и «склеить» их в одно.)
При использовании типов Maybeи []мы могли бы воспринимать применение функции <*>просто как извлечение функции из её левого параметра, а затем применение её к правому параметру. В отношении типа IOизвлечение остаётся в силе, но теперь у нас появляется понятие помещения в последовательность, поскольку мы берём два действия ввода-вывода и «склеиваем» их в одно. Мы должны извлечь функцию из первого действия ввода-вывода, но для того, чтобы можно было извлечь результат из действия ввода-вывода, последнее должно быть выполнено. Рассмотрите вот это:
myAction :: IO String
myAction = do
a <���– getLine
b <���– getLine
return $ a ++ b
Это действие ввода-вывода, которое запросит у пользователя две строки и вернёт в качестве своего результата их конкатенацию. Мы достигли этого благодаря «склеиванию» двух действий ввода-вывода getLineи return, поскольку мы хотели, чтобы наше новое «склеенное» действие ввода-вывода содержало результат выполнения a ++ b. Ещё один способ записать это состоит в использовании аппликативного стиля:
myAction :: IO String
myAction = (++) <$> getLine <*> getLine
Это то же, что мы делали ранее, когда создавали действие ввода-вывода, которое применяло функцию между результатами двух других действий ввода-вывода. Вспомните, что функция getLine– это действие ввода-вывода, которое имеет тип getLine :: IO String. Когда мы применяем оператор <*>между двумя аппликативными значениями, результатом является аппликативное значение, так что всё это имеет смысл.
Если мы вернёмся к аналогии с коробками, то можем представить себе функцию getLineкак коробку, которая выйдет в реальный мир и принесёт нам строку. Выполнение выражения (++) <$> getLine <*> getLineсоздаёт другую, бо́льшую коробку, которая посылает эти две коробки наружу для получения строк с терминала, а потом возвращает конкатенацию этих двух строк в качестве своего результата.
Интервал:
Закладка:
