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

class Monoid m where

mempty :: m

mappend :: m –> m –> m mconcat :: [m] –> m

mconcat = foldr mappend mempty

Класс типов Monoidопределён в модуле Data.Monoid. Давайте потратим некоторое время, чтобы как следует с ним познакомиться.

Прежде всего, нам видно, что экземпляры класса Monoidмогут быть определены только для конкретных типов, потому что идентификатор mв определении класса типов не принимает никаких параметров типа. В этом состоит отличие от классов Functorи Applicative, которые требуют, чтобы их экземплярами были конструкторы типа, принимающие один параметр.

Первой функцией является mempty. На самом деле это не функция, поскольку она не принимает параметров. Это полиморфная константа вроде minBoundиз класса Bounded. Значение memptyпредставляет единицу для конкретного моноида.

Далее, у нас есть функция mappend, которая, как вы уже, наверное, догадались, является бинарной. Она принимает два значения одного типа и возвращает ещё одно значение того же самого типа. Решение назвать так функцию mappendбыло отчасти неудачным, поскольку это подразумевает, что мы в некотором роде присоединяем два значения. Тогда как оператор ++действительно принимает два списка и присоединяет один в конец другого, оператор *на самом деле не делает какого-либо присоединения – два числа просто перемножаются. Когда вы встретите другие экземпляры класса Monoid, вы поймёте, что большинство из них тоже не присоединяют значения. Поэтому избегайте мыслить в терминах присоединения; просто рассматривайте mappendкак бинарную функцию, которая принимает два моноидных значения и возвращает третье.

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

Прежде чем перейти к более конкретным экземплярам класса Monoid, давайте кратко рассмотрим законы моноидов.

Вы узнали, что должно иметься значение, которое действует как тождество по отношению к бинарной функции, и что бинарная функция должна быть ассоциативна. Можно создать экземпляры класса Monoid, которые не следуют этим правилам, но такие экземпляры никому не нужны, поскольку, когда мы используем класс типов Monoid, мы полагаемся на то, что его экземпляры ведут себя как моноиды. Иначе какой в этом смысл? Именно поэтому при создании экземпляров класса Monoidмы должны убедиться, что они следуют нижеприведённым законам:

• mempty `mappend` x = x

• x `mappend` mempty = x

• (x `mappend` y) `mappend` z = x `mappend` (y `mappend` z)

Первые два закона утверждают, что значение memptyдолжно вести себя как единица по отношению к функции mappend, а третий говорит, что функция mappendдолжна быть ассоциативна (порядок, в котором мы используем функцию mappendдля сведения нескольких моноидных значений в одно, не имеет значения). Язык Haskell не проверяет определяемые экземпляры на соответствие этим законам, поэтому мы должны быть внимательными, чтобы наши экземпляры действительно выполняли их.

Теперь, когда вы знаете, что такое моноиды, давайте изучим некоторые типы в языке Haskell, которые являются моноидами, посмотрим, как выглядят экземпляры класса Monoidдля них, и поговорим об их использовании.

Да, списки являются моноидами! Как вы уже видели, функция ++с пустым списком []образуют моноид. Экземпляр очень прост:

instance Monoid [a] where

mempty = []

mappend = (++)

Для списков имеется экземпляр класса Monoidнезависимо от типа элементов, которые они содержат. Обратите внимание, что мы написали instance Monoid [a], а не instance Monoid [], поскольку класс Monoidтребует конкретный тип для экземпляра.

При тестировании мы не встречаем сюрпризов:

ghci> [1,2,3] `mappend` [4,5,6]

[1,2,3,4,5,6]

ghci> ("один" `mappend` "два") `mappend` "три"

"одиндватри"

ghci> "один" `mappend` ("два" `mappend` "три")

"одиндватри"

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

"одиндватри"

ghci> "бах" `mappend` mempty

"бах"

ghci> mconcat [[1,2],[3,6],[9]]

[1,2,3,6,9]

ghci> mempty :: [a]

[]

Обратите внимание, что в последней строке мы написали явную аннотацию типа. Если бы было написано просто mempty, то интерпретатор GHCi не знал бы, какой экземпляр использовать, поэтому мы должны были сказать, что нам нужен списковый экземпляр. Мы могли использовать общий тип [a](в отличие от указания [Int]или [String]), потому что пустой список может действовать так, будто он содержит любой тип.

Поскольку функция mconcatимеет реализацию по умолчанию, мы получаем её просто так, когда определяем экземпляр класса Monoidдля какого-либо типа. В случае со списком функция mconcatсоответствует просто функции concat. Она принимает список списков и «разглаживает» его, потому что это равнозначно вызову оператора ++между всеми смежными списками, содержащимися в списке.

Законы моноидов действительно выполняются для экземпляра списка. Когда у нас есть несколько списков и мы объединяем их с помощью функции mappend(или ++), не имеет значения, какие списки мы соединяем первыми, поскольку так или иначе они соединяются на концах. Кроме того, пустой список действует как единица, поэтому всё хорошо.

Обратите внимание, что моноиды не требуют, чтобы результат выражения a `mappend` bбыл равен результату выражения b `mappend` a. В случае со списками они очевидно не равны: