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

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

True

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

LT

ghci> 5 >= 2

True

ghci> 5 `compare` 3

GT

Класс Show

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

ghci> show 3

"3"

ghci> show 5.334

"5.334"

ghci> show True

"True"

Класс Read

Класс 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"

<interactive>:1:0:

    Ambiguous type variable `a' in the constraint:

     `Read a' arising from a use of `read' at <interactive>: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 использует тип списка, полученный благодаря наличию других элементов списка:

ghci> [read "True" , False, True, False]

[True, False, True, False]

Так как read "True" используется как элемент списка булевых значений, Haskell самостоятельно определяет, что тип read "True" должен быть Bool.

Класс Enum

Экземплярами класса Enum являются последовательно упорядоченные типы; их значения можно перенумеровать. Основное преимущество класса типов Enum в том, что мы можем использовать его типы в интервалах списков. Кроме того, у них есть предыдущие и последующие элементы, которые можно получить с помощью функций succ и pred. Типы, входящие в этот класс: (), Bool, Char, Ordering, Int, Integer, Float и Double.

ghci> ['a'..'e']

"abcde"

ghci> [LT .. GT]

[LT,EQ,GT]

ghci> [3 .. 5]

[3,4,5]

ghci>succ 'B'

'C'

Класс Bounded

Экземпляры класса типов Bounded имеют верхнюю и нижнюю границу.

ghci> minBound :: Int

–2147483648

ghci> maxBound :: Char

'1114111'

ghci> maxBound :: Bool

True

ghci> minBound :: Bool

False

Функции minBound и maxBound интересны тем, что имеют тип (Bounded a) => a. В этом смысле они являются полиморфными константами.

Все кортежи также являются частью класса Bounded, если их компоненты принадлежат классу Bounded.

ghci> maxBound :: (Bool, Int, Char)

(True,2147483647,'1114111')

Класс Num

Класс Num – это класс типов для чисел. Его экземпляры могут вести себя как числа. Давайте проверим тип некоторого числа:

ghci> :t 20

20 :: (Num t) => t

Похоже, что все числа также являются полиморфными константами. Они могут вести себя как любой тип, являющийся экземпляром класса Num (Int, Integer, Float или Double).

ghci> 20 :: Int

20

ghci> 20 :: Integer

20

ghci> 20 :: Float

20.0

ghci> 20 :: Double

20.0

Если проверить тип оператора *, можно увидеть, что он принимает любые числа.

ghci> :t (*)

(*) :: (Num a) => a –> a –> a

Он принимает два числа одинакового типа и возвращает число этого же типа. Именно поэтому (5 :: Int) * (6 :: Integer) приведёт к ошибке, а 5 * (6 :: Integer) будет работать нормально и вернёт значение типа Integer потому, что 5 может вести себя и как Integer, и как Int.

Чтобы присоединиться к классу Num, тип должен «подружиться» с классами Show и Eq.

Класс Floating

Класс Floating включает в себя только числа с плавающей точкой, то есть типы Float и Double.

Функции, которые принимают и возвращают значения, являющиеся экземплярами класса Floating, требуют, чтобы эти значения могли быть представлены в виде числа с плавающей точкой для выполнения осмысленных вычислений. Некоторые примеры: функции sin, cos и sqrt.

Класс Integral

Класс Integral – тоже числовой класс типов. Если класс Num включает в себя все типы, в том числе действительные и целые числа, то в класс Integral входят только целые числа. Для типов Int и Integer определены экземпляры данного класса.

Очень полезной функцией для работы с числами является fromIntegral. Вот её объявление типа:

fromIntegral :: (Num b, Integral a) => a –> b

Из этой сигнатуры мы видим, что функция принимает целое число (Integral) и превращает его как более общее число (Num).

ПРИМЕЧАНИЕ. Необходимо отметить, что функция fromIntegral имеет несколько ограничений классов в своей сигнатуре. Такое вполне допустимо – несколько ограничений разделяются запятыми и заключаются в круглые скобки.

Это окажется полезно, когда потребуется, чтобы целые числа и числа с плавающей точкой могли «сработаться» вместе. Например, функция вычисления длины length имеет объявление length :: [a] –> Int, вместо того чтобы использовать более общий тип (Num b) => length :: [a] –> b. (Наверное, так сложилось исторически – хотя, по-моему, какова бы ни была причина, это довольно глупо.) В любом случае, если мы попробуем вычислить длину списка и добавить к ней 3.2, то получим ошибку, потому что мы попытались сложить значения типа Int и число с плавающей точкой. В этом случае можно использовать функцию fromIntegral:

ghci> fromIntegral (length [1,2,3,4]) + 3.2

7.2

Несколько заключительных слов о классах типов

Поскольку класс типа определяет абстрактный интерфейс, один и тот же тип данных может иметь экземпляры для различных классов, а для одного и того же класса могут быть определены экземпляры различных типов. Например, тип Char имеет экземпляры для многих классов, два из которых – Eq и Ord, поскольку мы можем сравнивать символы на равенство и располагать их в алфавитном порядке.