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

Мы определили тела функций для функций в классе Eq, притом определили их взаимно рекурсивно . Мы записали, что два экземпляра класса Eqравны, если они не отличаются, и что они отличаются, если не равны. Необязательно было поступать так, и всё же скоро мы увидим, чем это может быть полезно.

Если записать декларацию class Eq a where, описать в ней функцию таким образом: (==) :: a -> a -> Bool, а затем посмотреть объявление этой функции, мы увидим следующий тип: (Eq a) => a –> a –> Bool.

Итак, что мы можем сделать с классом после того, как объявили его? Весьма немногое. Но как только мы начнём создавать экземпляры этого класса, то станем получать интересные результаты. Посмотрим на этот тип:

data TrafficLight = Red | Yellow | Green

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

instance Eq TrafficLight where

Red == Red = True

Green == Green = True

Yellow == Yellow = True

_ == _ = False

Экземпляр создан с помощью ключевого слова instance. Таким образом, ключевое слово classслужит для определения новых классов типов, а ключевое слово instance– для того, чтобы сделать для нашего типа экземпляр некоторого класса. Когда мы определяли класс Eq, то записали декларацию class Eq a whereи сказали, что идентификатор aиграет роль типа, который мы позднее будем делать экземпляром класса. Теперь мы это ясно видим, потому что когда мы создаём экземпляр, то пишем: instance Eq TrafficLight where. Мы заменили идентификатор на название нашего типа.

Так как операция ==была определена в объявлении класса через вызов операции /=и наоборот, следует переопределить только одну функцию в объявлении экземпляра класса. Это называется минимальным полным определением класса типов – имеется в виду минимум функций, которые надо реализовать, чтобы наш тип мог вести себя так, как предписано классом. Для того чтобы создать минимально полное определение для класса Eq, нам нужно реализовать или оператор ==, или оператор /=. Если бы класс Eqбыл определён таким образом:

class Eq a where

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

(/=) :: a –> a –> Bool

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

Мы реализовали оператор ==с помощью сопоставления с образцом. Так как комбинаций двух неравных цветов значительно больше, чем комбинаций равных, мы перечислили все равные цвета и затем использовали маску подстановки, которая говорит, что если ни один из предыдущих образцов не подошёл, то два цвета не равны.

Давайте сделаем для нашего типа экземпляр класса Show. Чтобы удовлетворить минимально полному определению для класса Show, мы должны реализовать функцию show, которая принимает значение и возвращает строку:

instance Show TrafficLight where

show Red = "Красный свет"

show Yellow = "Жёлтый свет"

show Green = "Зелёный свет"

Мы снова использовали сопоставление с образцом, чтобы достичь нашей цели. Давайте посмотрим, как это всё работает:

ghci> Red == Red

True

ghci> Red == Yellow

False

ghci> Red `elem` [Red, Yellow, Green]

True

ghci> [Red, Yellow, Green]

[Красный свет,Жёлтый свет,Зелёный свет]

Можно было бы просто автоматически сгенерировать экземпляр для класса Eqс абсолютно тем же результатом (мы этого не сделали в образовательных целях). Кроме того, автоматическая генерация для класса Showпросто напрямую переводила бы конструкторы значений в строки. Если нам требуется печатать что-то дополнительно, то придётся создавать экземпляр класса Showвручную.

Также можно создавать классы типов, которые являются подклассами других классов типов. Декларация класса Numдовольно длинна, но вот её начало:

class (Eq a) => Num a where

...

Как уже говорилось ранее, есть множество мест, куда мы можем втиснуть ограничения на класс. Наша запись равнозначна записи class Num a where, но мы требуем, чтобы тип aимел экземпляр класса Eq. Это означает, что мы должны определить для нашего типа экземпляр класса Eqдо того, как сможем сделать для него экземпляр класса Num. Прежде чем некоторый тип сможет рассматриваться как число, мы должны иметь возможность проверять значения этого типа на равенство.

Ну вот и всё, что надо знать про наследование, – это просто ограничения на класс типа-параметра при объявлении класса. При написании тел функций в декларации класса или при их определении в экземпляре класса мы можем полагать, что тип aимеет экземпляр для класса Eqи, следовательно, допускается использование операторов ==и /=со значениями этого типа.

Но как тип Maybeи списковый тип сделаны экземплярами классов? Тип Maybeотличается, скажем, от типа TrafficLightтем, что Maybeсам по себе не является конкретным типом – это конструктор типов, который принимает один тип-параметр (например, Char), чтобы создать конкретный тип (как Maybe Char). Давайте посмотрим на класс Eqещё раз:

class Eq a where

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

(/=) :: a –> a –> Bool

x == y = not (x /= y)

x /= y = not (x == y)

Из декларации типа мы видим, что aиспользуется как конкретный тип, потому что все типы в функциях должны быть конкретными (помните, мы обсуждали, что не можем иметь функцию типа a –> Maybe, но можем – функцию типа: a –> Maybe aили Maybe Int –> Maybe String). Вот почему недопустимо делать что-нибудь в таком роде:

instance Eq Maybe where

...

Ведь, как мы видели, идентификатор aдолжен принимать значение в виде конкретного типа, а тип Maybeне является таковым. Это конструктор типа, который принимает один параметр и производит конкретный тип.

Было бы скучно прописывать instance Eq (Maybe Int) where, instance Eq (Maybe Char) whereи т. д. для всех существующих типов. Вот почему мы можем записать это так: