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

ghci> "один" `mappend` "два"

"одиндва"

ghci> "два" `mappend` "один"

"дваодин"

И это нормально. Тот факт, что при умножении выражения 3 * 5и 5 * 3дают один и тот же результат, – это просто свойство умножения, но оно не выполняется для большинства моноидов.

Мы уже изучили один из способов рассматривать числа как моноиды: просто позволить бинарной функции быть оператором *, а единичному значению – быть 1. Ещё один способ для чисел быть моноидами состоит в том, чтобы в качестве бинарной функции выступал оператор +, а в качестве единичного значения – значение 0:

ghci> 0 + 4

4

ghci> 5 + 0

5

ghci> (1 + 3) + 5

9

ghci> 1 + (3 + 5)

9

Законы моноидов выполняются, потому что если вы прибавите 0 к любому числу, результатом будет то же самое число. Сложение также ассоциативно, поэтому здесь у нас нет никаких проблем.

Итак, в нашем распоряжении два одинаково правомерных способа для чисел быть моноидами. Какой же способ выбрать?.. Ладно, мы не обязаны выбирать! Вспомните, что когда имеется несколько способов определения для какого-то типа экземпляра одного и того же класса типов, мы можем обернуть этот тип в декларацию newtype, а затем сделать для нового типа экземпляр класса типов по-другому. Можно совместить несовместимое.

Модуль Data.Monoidэкспортирует для этого два типа: Productи Sum.

Productопределён вот так:

newtype Product a = Product { getProduct :: a }

deriving (Eq, Ord, Read, Show, Bounded)

Это всего лишь обёртка newtypeс одним параметром типа наряду с некоторыми порождёнными экземплярами. Его экземпляр для класса Monoidвыглядит примерно так:

instance Num a => Monoid (Product a) where

mempty = Product 1

Product x `mappend` Product y = Product (x * y)

Значение mempty– это просто 1, обёрнутая в конструктор Product. Функция mappendпроизводит сопоставление конструктора Productс образцом, перемножает два числа, а затем оборачивает результирующее число. Как вы можете видеть, имеется ограничение класса Num a. Это значит, что Product aявляется экземпляром Monoidдля всех значений типа a, для которых уже имеется экземпляр класса Num. Для того чтобы использовать тип Product aв качестве моноида, мы должны произвести некоторое оборачивание и разворачивание newtype:

ghci> getProduct $ Product 3 `mappend` Product 9

27

ghci> getProduct $ Product 3 `mappend` mempty

3

ghci> getProduct $ Product 3 `mappend` Product 4 `mappend` Product 2

24

ghci> getProduct . mconcat . map Product $ [3,4,2]

24

Тип Sumопределён в том же духе, что и тип Product, и экземпляр тоже похож. Мы используем его точно так же:

ghci> getSum $ Sum 2 `mappend` Sum 9

11

ghci> getSum $ mempty `mappend` Sum 3

3

ghci> getSum . mconcat . map Sum $ [1,2,3]

6

Ещё одним типом, который может действовать как моноид двумя разными, но одинаково допустимыми способами, является Bool. Первый способ состоит в том, чтобы заставить функцию ||, которая представляет собой логическое ИЛИ, действовать как бинарная функция, используя Falseв качестве единичного значения. Если при использовании логического ИЛИ какой-либо из параметров равен True, функция возвращает True; в противном случае она возвращает False. Поэтому если мы используем Falseв качестве единичного значения, операция ИЛИ вернёт Falseпри использовании с False– и Trueпри использовании с True. Конструктор newtype Anyаналогичным образом имеет экземпляр класса Monoid. Он определён вот так:

newtype Any = Any { getAny :: Bool }

deriving (Eq, Ord, Read, Show, Bounded)

А его экземпляр выглядит так:

instance Monoid Any where

mempty = Any False

Any x `mappend` Any y = Any (x || y)

Он называется Any, потому что x `mappend` yбудет равно True, если любое из этих двух значений равно True. Даже когда три или более значений Bool, обёрнутых в Any, объединяются с помощью функции mappend, результат будет содержать True, если любое из них равно True.

ghci> getAny $ Any True `mappend` Any False

True

ghci> getAny $ mempty `mappend` Any True

True

ghci> getAny . mconcat . map Any $ [False, False, False, True]

True

ghci> getAny $ mempty `mappend` mempty

False

Другой возможный вариант экземпляра класса Monoidдля типа Bool– всё как бы наоборот: заставить оператор &&быть бинарной функцией, а затем сделать значение Trueединичным значением. Логическое И вернёт True, только если оба его параметра равны True.

Это объявление newtype:

newtype All = All { getAll :: Bool }

deriving (Eq, Ord, Read, Show, Bounded)

А это экземпляр:

instance Monoid All where

mempty = All True

All x `mappend` All y = All (x && y)

Когда мы объединяем значения типа Allс помощью функции mappend, результатом будет Trueтолько в случае, если все значения, использованные в функции mappend, равны True:

ghci> getAll $ mempty `mappend` All True

True

ghci> getAll $ mempty `mappend` All False

False

ghci> getAll . mconcat . map All $ [True, True, True]

True

ghci> getAll . mconcat . map All $ [True, True, False]

False

Так же, как при использовании умножения и сложения, мы обычно явно указываем бинарные функции вместо оборачивания их в значения newtypeи последующего использования функций mappendи mempty. Функция mconcatкажется полезной для типов Anyи All, но обычно проще использовать функции orи and. Функция orпринимает списки значений типа Boolи возвращает True, если какое-либо из них равно True. Функция andпринимает те же значения и возвращает значение True, если все из них равны True.

Помните тип Ordering? Он используется в качестве результата при сравнении сущностей и может иметь три значения: LT, EQи GT, которые соответственно означают «меньше, чем», «равно» и «больше, чем».

ghci> 1 `compare` 2

LT

ghci> 2 `compare` 2

EQ

ghci> 3 `compare` 2

GT

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