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

Однако здесь есть одна проблема. Заметили? Мы используем оператор == для содержимого типа Maybe, но у нас нет уверенности, что то, что содержит тип Maybe, может быть использовано с методами класса Eq. Вот почему необходимо поменять декларацию экземпляра на следующую:

instance (Eq m) => Eq (Maybe m) where

   Just x == Just y = x == y

   Nothing == Nothing = True

   _ == _ = False

Нам пришлось добавить ограничение на класс. Таким объявлением экземпляра класса мы утверждаем: необходимо, чтобы все типы вида Maybe m имели экземпляр для класса Eq, но при этом тип m (тот, что хранится в Maybe) также должен иметь экземпляр класса Eq. Такой же экземпляр породил бы сам язык Haskell, если бы мы воспользовались директивой deriving.

В большинстве случаев ограничения на класс в декларации класса используются для того, чтобы сделать класс подклассом другого класса. Ограничения на класс в определении экземпляра используются для того, чтобы выразить требования к содержимому некоторого типа. Например, в данном случае мы требуем, чтобы содержимое типа Maybe также имело экземпляр для класса Eq.

При создании экземпляров, если вы видите, что тип использовался как конкретный при декларации (например, a –> a –> Bool), а вы реализуете экземпляр для конструктора типов, следует предоставить тип-параметр и добавить скобки, чтобы получить конкретный тип.

Примите во внимание, что тип, экземпляр для которого вы пытаетесь создать, заменит параметр в декларации класса. Параметр a из декларации class Eq a where будет заменён конкретным типом при создании экземпляра; попытайтесь в уме заменить тип также и в декларациях функций. Сигнатура (==) :: Maybe –> Maybe –> Bool не имеет никакого смысла, но сигнатура (==) :: (Eq m) => Maybe m –> Maybe m –> Bool имеет. Впрочем, это нужно только для упражнения, потому что оператор == всегда будет иметь тип (==) :: (Eq a) => a –> a –> Bool независимо от того, какие экземпляры мы порождаем.

О, и ещё одна классная фишка! Если хотите узнать, какие экземпляры существуют для класса типов, вызовите команду : info в GHCi. Например, выполнив команду :info Num, вы увидите, какие функции определены в этом классе типов, и выведете список принадлежащих классу типов. Команда :info также работает с типами и конструкторами типов. Если выполнить :info Maybe, мы увидим все классы типов, к которым относится тип Maybe. Вот пример:

ghci> :info Maybe

data Maybe a = Nothing | Just a -- Defined in Data.Maybe

instance Eq a => Eq (Maybe a) -- Defined in Data.Maybe

instance Monad Maybe -- Defined in Data.Maybe

instance Functor Maybe -- Defined in Data.Maybe

instance Ord a => Ord (Maybe a) -- Defined in Data.Maybe

instance Read a => Read (Maybe a) -- Defined in GHC.Read

instance Show a => Show (Maybe a) -- Defined in GHC.Show

Класс типов «да–нет»

В языке JavaScript и в некоторых других слабо типизированных языках вы можете поместить в оператор if практически любые выражения. Например, все следующие выражения правильные:

if (0) alert("ДА!") else alert("НЕТ!")

if ("") alert ("ДА!") else alert("НЕТ!")

if (false) alert("ДА!") else alert("НЕТ!)

и все они покажут НЕТ!".

Если вызвать

if ("ЧТО") alert ("ДА!") else alert("НЕТ!")

мы увидим "ДА!", так как язык JavaScript рассматривает непустые строки как вариант истинного значения.

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

class YesNo a where

   yesno :: a –> Bool

Довольно просто. Класс типов YesNo определяет один метод. Эта функция принимает одно значение некоторого типа, который может рассматриваться как хранитель некоей концепции истинности; функция говорит нам, истинно значение или нет. Обратите внимание: из того, как мы использовали параметр a в функции, следует, что он должен быть конкретным типом.

Теперь определим несколько экземпляров. Для чисел, так же как и в языке JavaScript, предположим, что любое ненулевое значение истинно, а нулевое – ложно.

instance YesNo Int where

   yesno 0 = False

   yesno _ = True

Пустые списки (и, соответственно, строки) считаются имеющими ложное значение; не пустые списки истинны.

instance YesNo [a] where

   yesno [] = False

   yesno _ = True

Обратите внимание, как мы записали тип-параметр для того, чтобы сделать список конкретным типом, но не делали никаких предположений о типе, хранимом в списке. Что ещё? Гм-м… Я знаю, что тип Bool также содержит информацию об истинности или ложности, и сообщает об этом довольно недвусмысленно:

instance YesNo Bool where

   yesno = id

Что? Какое id?.. Это стандартная библиотечная функция, которая принимает параметр и его же и возвращает. Мы всё равно записали бы то же самое. Сделаем экземпляр для типа Maybe:

instance YesNo (Maybe a) where

   yesno (Just _) = True

   yesno Nothing = False

Нам не нужно ограничение на класс параметра, потому что мы не делаем никаких предположений о содержимом типа Maybe. Мы говорим, что он истинен для всех значений Just и ложен для значения Nothing. Нам приходится писать (Maybe a) вместо просто Maybe, потому что, если подумать, не может существовать функции Maybe –> Bool, так как Maybe – не конкретный тип; зато может существовать функция Maybe a –> Bool. Круто – любой тип вида Maybe <нечто> является частью YesNo независимо от того, что представляет собой это «нечто»!

Ранее мы определили тип Tree для представления бинарного поискового дерева. Мы можем сказать, что пустое дерево должно быть аналогом ложного значения, а не пустое – истинного.

instance YesNo (Tree a) where

   yesno EmptyTree = False

   yesno _ = True

Есть ли аналоги истинности и ложности у цветов светофора? Конечно. Если цвет красный, вы останавливаетесь. Если зелёный – идёте. Ну а если жёлтый? Ну, я обычно бегу на жёлтый: жить не могу без адреналина!

instance YesNo TrafficLight where

   yesno Red = False

   yesno _ = True

Ну что ж, мы определили несколько экземпляров, а теперь давайте поиграем с ними:

ghci> yesno $ length []

False

ghci> yesno "ха-ха"

True

ghci> yesno ""

False

ghci> yesno $ Just 0

True

ghci> yesno True

True

ghci> yesno EmptyTree

False

ghci> yesno []

False

ghci> yesno [0,0,0]

True

ghci> :t yesno

yesno :: (YesNo a) => a –> Bool

Та-ак, работает. Теперь сделаем функцию, которая работает, как оператор if, но со значениями типов, для которых есть экземпляр класса YesNo:

yesnoIf :: (YesNo y) => y –> a –> a –> a

yesnoIf yesnoVal yesResult noResult =

     if yesno yesnoVal

         then yesResult

         else noResult

Всё довольно очевидно. Функция принимает значение для определения истинности и два других параметра. Если значение истинно, возвращается первый параметр; если нет – второй.

ghci> yesnoIf [] "ДА!" "НЕТ!"

"НЕТ!"

ghci> yesnoIf [2,3,4] "ДА!" "НЕТ!"

"ДА!"

ghci> yesnoIf True "ДА!" "НЕТ!"

"ДА!"

ghci> yesnoIf (Just 500) "ДА!" "НЕТ!"

"ДА!"

ghci> yesnoIf Nothing "ДА!" НЕТ!"

НЕТ!"

Класс типов Functor

Мы уже встречали множество классов типов из стандартной библиотеки. Ознакомились с классом Ord, предусмотренным для сущностей, которые можно упорядочить. Вдоволь набаловались с классом Eq, предназначенным для сравнения на равенство. Изучили класс Show, предоставляющий интерфейс для типов, которые можно представить в виде строк. Наш добрый друг класс Read помогает, когда нам надо преобразовать строку в значение некоторого типа. Ну а теперь приступим к рассмотрению класса типов Functor, предназначенного для типов, которые могут быть отображены друг в друга.

Возможно, в этот момент вы подумали о списках: ведь отображение списков – это очень распространённая идиома в языке Haskell. И вы правы: списковый тип имеет экземпляр для класса Functor.

Нет лучшего способа изучить класс типов Functor, чем посмотреть, как он реализован. Вот и посмотрим:

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

Итак, что у нас имеется? Класс определяет одну функцию fmap и не предоставляет для неё реализации по умолчанию. Тип функции fmap весьма интересен. Во всех вышеприведённых определениях классов типов тип-параметр, игравший роль типа в классе, был некоторого конкретного типа, как переменная a в сигнатуре (==) :: (Eq a) => a –> a –> Bool. Но теперь тип-параметр f не имеет конкретного типа (нет конкретного типа, который может принимать переменная, например Int, Bool или Maybe String); в этом случае переменная – конструктор типов, принимающий один параметр. (Напомню: выражение Maybe Int является конкретным типом, а идентификатор Maybe – конструктор типов с одним параметром.) Мы видим, что функция fmap принимает функцию из одного типа в другой и функтор, применённый к одному типу, и возвращает функтор, применённый к другому типу.