Итак, значения, такие как 3, "ДА" или takeWhile (функции тоже являются значениями, поскольку мы можем передать их как параметр и т. д.), имеют свой собственный тип. Типы – это нечто вроде маленьких меток, привязанных к значениям, чтобы мы могли строить предположения относительно них. Но и типы имеют свои собственные маленькие меточки, называемые
Что такое сорта и для чего они полезны? Давайте посмотрим сорт типа, используя команду :k в интерпретаторе GHCi.
ghci> :k Int
Int :: *
Звёздочка? Как затейливо! Что это значит? Звёздочка обозначает, что тип является конкретным. * вслух (до этого не приходилось), я бы сказал «звёздочка» или просто «тип».
О’кей, теперь посмотрим, каков сорт у типа Maybe:
ghci> :k Maybe
Maybe :: * –> *
Конструктор типов Maybe принимает один конкретный тип (например, Int) и возвращает конкретный тип (например, Maybe Int). Вот о чём говорит нам сорт. Точно так же тип Int –> Int означает, что функция принимает и возвращает значение типа Int; сорт * – > * означает, что конструктор типов принимает конкретный тип и возвращает конкретный тип. Давайте применим параметр к типу Maybe и посмотрим, какого он станет сорта.
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)
