Миран Липовача - Изучай Haskell во имя добра!

Сделать для типа Frankэкземпляр класса Tofuдовольно просто. Мы видим, что функция tofuпринимает значение типа a j(примером для типа такой формы может быть Maybe Int) и возвращает значение типа t a j. Если мы заменим тип Frankна t, результирующий тип будет Frank Int Maybe.

instance Tofu Frank where

tofu x = Frank x

Проверяем типы:

ghci> tofu (Just 'a') :: Frank Char Maybe

Frank {frankField = Just 'a'}

ghci> tofu ["ПРИВЕТ"] :: Frank [Char] []

Frank {frankField = ["ПРИВЕТ"]}

Пусть и без особой практической пользы, но мы потренировали наше понимание типов. Давайте сделаем ещё несколько упражнений из тип-фу. У нас есть такой тип данных:

data Barry t k p = Barry { yabba :: p, dabba :: t k }

Ну а теперь определим для него экземпляр класса Functor. Класс Functorпринимает типы сорта * –> *, но непохоже, что у типа Barryтакой сорт. Каков же сорт у типа Barry? Мы видим, что он принимает три типа-параметра, так что его сорт будет похож на ( нечто –> нечто –> нечто –> *). Наверняка тип p– конкретный; он имеет сорт *. Для типа kмы предполагаем сорт *; следовательно, тип tимеет сорт * –> *. Теперь соединим всё в одну цепочку и получим, что тип Barryимеет сорт (* –> *) –> * –> * –> *. Давайте проверим это в интерпретаторе GHCi:

ghci> :k Barry

Barry :: (* –> *) –> * –> * –> *

Ага, мы были правы. Как приятно! Чтобы сделать для типа Barryэкземпляр класса Functor, мы должны частично применить первые два параметра, после чего у нас останется сорт * –> *. Следовательно, начало декларации экземпляра будет таким:

instance Functor (Barry a b) where

Если бы функция fmapбыла написана специально для типа Barry, она бы имела тип

fmap :: (a –> b) –> Barry c d a –> Barry c d b

Здесь тип-параметр fпросто заменён частично применённым типом Barry c d. Третий параметр типа Barryдолжен измениться, и мы видим, что это удобно сделать таким образом:

instance Functor (Barry a b) where

fmap f (Barry {yabba = x, dabba = y}) = Barry {yabba = f x, dabba = y}

Готово! Мы просто отобразили тип fпо первому полю.

В данной главе мы хорошенько изучили, как работают параметры типов, и как они формализуются с помощью сортов по аналогии с тем, как формализуются параметры функций с помощью декларации типов. Мы провели любопытные параллели между функциями и конструкторами типов, хотя на первый взгляд они и не имеют ничего общего. При реальной работе с языком Haskell обычно не приходится возиться с сортами и делать вывод сортов вручную, как мы делали в этой главе. Обычно вы просто частично применяете свой тип к сорту * –> *или *при создании экземпляра от одного из стандартных классов типов, но полезно знать, как это работает на самом деле. Также интересно, что у типов есть свои собственные маленькие типы.

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

В этой главе вы узнаете, как вводить данные с клавиатуры и печатать их на экран. Начнём мы с основ ввода-вывода:

• Что такое действия?

• Как действия позволяют выполнять ввод-вывод?

• Когда фактически исполняются действия?

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

Мы уже упоминали, что Haskell – чисто функциональный язык. В то время как в императивных языках вы указываете компьютеру серию шагов для достижения некой цели, в функциональном программировании мы описываем, чем является то или иное понятие. В языке Haskell функция не может изменить некоторое состояние, например поменять значение переменной (если функция изменяет состояние, мы говорим, что она имеет побочные эффекты). Единственное, что могут сделать функции в языке Haskell, – это вернуть нам некоторый результат, основываясь на переданных им параметрах. Если вызвать функцию дважды с одинаковыми параметрами, она всегда вернёт одинаковый результат. Если вы знакомы с императивными языками, может показаться, что это ограничивает свободу наших действий, но мы видели, что на самом деле это даёт весьма мощные возможности. В императивном языке у вас нет гарантии, что простая функция, которая всего-то навсего должна обсчитать пару чисел, не сожжёт ваш дом, не похитит собаку и не поцарапает машину во время вычислений! Например, когда мы создавали бинарное поисковое дерево, то вставляли элемент в дерево не путём модификации дерева в точке вставки. Наша функция добавления нового элемента в дерево возвращала новое дерево, так как не могла изменить старое.