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

ghci> :k Maybe Int

Maybe Int :: *

Так я и думал! Мы применили тип-параметр к типу Maybeи получили конкретный тип. Можно провести параллель (но не отождествление: типы – это не то же самое, что и сорта) с тем, как если бы мы сделали :t isUpperи :t isUpper 'A'. У функции isUpperтип Char –> Bool; выражение isUpper 'A'имеет тип Bool, потому что его значение – просто False. Сорт обоих типов, тем не менее, *.

Мы используем команду :kдля типов, чтобы получить их сорт, так же как используем команду :tдля значений, чтобы получить их тип. Выше уже было сказано, что типы – это метки значений, а сорта – это метки типов; и в этом они схожи.

Посмотрим на другие сорта.

ghci> :k Either

Either :: * –> * –> *

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

ghci> :k Either String

Either String :: * –> *

ghci> :k Either String Int

Either String Int :: *

Когда нам нужно было сделать для типа Eitherэкземпляр класса Functor, пришлось частично применить его, потому что класс Functorпринимает типы только с одним параметром, в то время как у типа Eitherих два. Другими словами, класс Functorпринимает типы сорта * –> *, и нам пришлось частично применить тип Eitherдля того, чтобы получить сорт * –> *из исходного сорта * –> * –> *. Если мы посмотрим на определение класса Functorещё раз:

class Functor f where

fmap :: (a –> b) –> f a –> f b

то увидим, что переменная типа fиспользуется как тип, принимающий один конкретный тип для того, чтобы создать другой. Мы знаем, что возвращается конкретный тип, поскольку он используется как тип значения в функции. Из этого можно заключить, что типы, которые могут «подружиться» с классом Functor, должны иметь сорт * –> *.

Ну а теперь займёмся тип-фу. Посмотрим на определение такого класса типов:

class Tofu t where

tofu :: j a –> t a j

Объявление выглядит странно. Как мы могли бы создать тип, который будет иметь экземпляр такого класса? Посмотрим, каким должен быть сорт типа. Так как тип j aиспользуется как тип значения, который функция tofuпринимает как параметр, у типа j aдолжен быть сорт *. Мы предполагаем сорт *для типа aи, таким образом, можем вывести, что тип jдолжен быть сорта * –> *. Мы видим, что тип tтакже должен производить конкретный тип, и что он принимает два типа. Принимая во внимание, что у типа aсорт *и у типа jсорт * –> *, мы выводим, что тип tдолжен быть сорта * –> (* –> *) –> *. Итак, он принимает конкретный тип (a)и конструктор типа, который принимает один конкретный тип (j),и производит конкретный тип. Вау!

Хорошо, давайте создадим тип такого сорта: * –> (* –> *) –> *. Вот один из вариантов:

data Frank a b = Frank {frankField :: b a} deriving (Show)

Откуда мы знаем, что этот тип имеет сорт * –> (* –> *) – > *? Именованные поля в алгебраических типах данных сделаны для того, чтобы хранить значения, так что они по определению должны иметь сорт *. Мы предполагаем сорт *для типа a; это означает, что тип bпринимает один тип как параметр. Таким образом, его сорт – * –> *. Теперь мы знаем сорта типов aи b; так как они являются параметрами для типа Frank, можно показать, что тип Frankимеет сорт * –> (* –> *) – > *. Первая *обозначает сорт типа a; (* –> *)обозначает сорт типа b. Давайте создадим несколько значений типа Frankи проверим их типы.

ghci> :t Frank {frankField = Just "ХА-ХА"}

Frank {frankField = Just "ХА-ХА"} :: Frank [Char] Maybe

ghci> :t Frank {frankField = Node 'a' EmptyTree EmptyTree}

Frank {frankField = Node 'a' EmptyTree EmptyTree} :: Frank Char Tree

ghci> :t Frank {frankField = "ДА"}

Frank {frankField = "ДА"} :: Frank Char []

Гм-м-м… Так как поле frankFieldимеет тип вида a b, его значения должны иметь типы похожего вида. Например, это может быть Just "ХА-ХА", тип в этом примере – Maybe [Char], или ['Д','А'](тип [Char]; если бы мы использовали наш собственный тип для списка, это был бы List Char). Мы видим, что значения типа Frankсоответствуют сорту типа Frank. Сорт [Char]– это *, тип Maybeимеет сорт * –> *. Так как мы можем создать значение только конкретного типа и тип значения должен быть полностью определён, каждое значение типа Frankимеет сорт *.

Сделать для типа 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должен измениться, и мы видим, что это удобно сделать таким образом: