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

Хорошим примером будет класс типов, определяющий равенство. Значения многих типов можно сравнивать на равенство с помощью оператора ==. Посмотрим на его сигнатуру:

ghci> :t (==)

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

Заметьте: оператор равенства ==– это функция. Функциями также являются операторы +, *, –, /и почти все остальные операторы. Если имя функции содержит только специальные символы, по умолчанию подразумевается, что это инфиксная функция. Если мы захотим проверить её тип, передать её другой функции или вызвать как префиксную функцию, мы должны поместить её в круглые скобки.

Интересно… мы видим здесь что-то новое, а именно символ =>. Всё, что находится перед символом =>, называется ограничением класса . Мы можем прочитать предыдущее объявление типа следующим образом: «функция сравнения на равенство принимает два значения одинакового типа и возвращает значение типа Bool. Тип этих двух значений должен быть экземпляром класса Eq» (это и есть ограничение класса).

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

ПРИМЕЧАНИЕ.Важно отметить, что классы типов в языке Haskell не являются тем же самым, что и классы в объектно-ориентированных языках программирования.

У функции elemтип (Eq a) => a –> [a] –> Bool, потому что она применяет оператор ==к элементам списка, чтобы проверить, есть ли в этом списке значение, которое мы ищем.

Далее приводятся описания нескольких базовых классов типов.

Класс Eqиспользуется для типов, которые поддерживают проверку равенства. Типы, являющиеся его экземплярами, должны реализовывать функции ==и /=. Так что если у нас есть ограничение класса Eqдля переменной типа в функции, то она может использовать ==или /=внутри своего определения. Все типы, которые мы упоминали выше, за исключением функций, входят в класс Eq, и, следовательно, могут быть проверены на равенство.

ghci> 5 == 5

True

ghci> 5 /= 5

False

ghci> 'a' == 'a'

True

ghci> "Хо Хо" == "Хо Хо"

True

ghci> 3.432 == 3.432

True

Класс Ordпредназначен для типов, которые поддерживают отношение порядка.

ghci> :t (>)

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

Все типы, упоминавшиеся ранее, за исключением функций, имеют экземпляры класса Ord. Класс Ordсодержит все стандартные функции сравнения, такие как >, <, >=и <=. Функция compareпринимает два значения одного и того же типа, являющегося экземпляром класса Ord, и возвращает значение типа Ordering. Тип Orderingможет принимать значения GT, LTили EQ, означая, соответственно, «больше чем», «меньше чем» и «равно».

ghci> "Абракадабра" < "Зебра"

True

ghci> "Абракадабра" `compare` "Зебра"

LT

ghci> 5 >= 2

True

ghci> 5 `compare` 3

GT

Значения, типы которых являются экземплярами класса типов Show, могут быть представлены как строки. Все рассматривавшиеся до сих пор типы (кроме функций) являются экземплярами Show. Наиболее часто используемая функция в классе типов Show– это, собственно, функция show. Она берёт значение, для типа которого определён экземпляр класса Show, и представляет его в виде строки.

ghci> show 3

"3"

ghci> show 5.334

"5.334"

ghci> show True

"True"

Класс Read– это нечто противоположное классу типов Show. Функция readпринимает строку и возвращает значение, тип которого является экземпляром класса Read.

ghci> read "True" || False

True

ghci> read "8.2" + 3.8

12.0

ghci> read "5" – 2

3

ghci> read "[1,2,3,4]" ++ [3]

[1,2,3,4,3]

Отлично. Но что случится, если попробовать вызвать read "4"?

ghci> read "4"

:1:0:

Ambiguous type variable `a' in the constraint:

`Read a' arising from a use of `read' at :1:0–7

Probable fix: add a type signature that fixes these type variable(s)

Интерпретатор GHCi пытается нам сказать, что он не знает, что именно мы хотим получить в результате. Заметьте: во время предыдущих вызовов функции readмы что-то делали с результатом функции. Таким образом, интерпретатор GHCi мог вычислить, какой тип ответа из функции readмы хотим получить.

Когда мы использовали результат как булево выражение, GHCi «понимал», что надо вернуть значение типа Bool. А в данном случае он знает, что нам нужен некий тип, входящий в класс Read, но не знает, какой именно. Давайте посмотрим на сигнатуру функции read.

ghci> :t read

read :: (Read a) => String –> a

ПРИМЕЧАНИЕ.Идентификатор String– альтернативное наименование типа [Char]. Идентификаторы Stringи [Char]могут быть использованы взаимозаменяемо, но далее будет использоваться только String, поскольку это удобнее и писать, и читать.

Видите? Функция возвращает тип, имеющий экземпляр класса Read, но если мы не воспользуемся им позже, то у компилятора не будет способа определить, какой именно это тип. Вот почему используются явные аннотации типа. Аннотации типа – способ явно указать, какого типа должно быть выражение. Делается это с помощью добавления символов ::в конец выражения и указания типа. Смотрите:

ghci> read "5" :: Int

5

ghci> read "5" :: Float

5.0

ghci> (read "5" :: Float) * 4

20.0

ghci> read "[1,2,3,4]" :: [Int]

[1,2,3,4]

ghci> read "(3, 'a')" :: (Int, Char)

(3, 'a')

Для большинства выражений компилятор может вывести тип самостоятельно. Но иногда он не знает, вернуть ли значение типа Intили Floatдля выражения вроде read "5". Чтобы узнать, какой у него тип, язык Haskell должен был бы фактически вычислить read "5".

Но так как Haskell – статически типизированный язык, он должен знать все типы до того, как скомпилируется код (или, в случае GHCi, вычислится). Так что мы должны сказать языку: «Эй, это выражение должно иметь вот такой тип, если ты сам случайно не понял!»

Обычно компилятору достаточно минимума информации, чтобы определить, значение какого именно типа должна вернуть функция read. Скажем, если результат функции readпомещается в список, то Haskell использует тип списка, полученный благодаря наличию других элементов списка: