Основы функционального программирования/Haskell/Модули и монады: различия между версиями

Ни один языкЯзыки программирования не обходитсяобходятся без понятия [[w:модуль (программирование)|модуля]], разве что толькоза языкиисключением языков самого [[w:Низкоуровневый язык программирования|низкого уровня]], да и те в последнее время приобретают свойствавысокоуровневые языков более высокого уровнякачества. Модули пришли из давнего прошлого, когда [[w:программирование|программирование]] только развивалось. Возникла надобность разбивать программы на логические части, каждую из которых создавал бы отдельный разработчик или коллектив.

В [[w:Haskell|Хаскеле]] также есть понятие модуля. Но более завораживающее неофитовновичков явление в языке есть понятие '''монадымонада'''. В этой лекции будут подробно рассмотрены оба понятия.

В Хаскеле модули несут двоякое назначение: с одной стороны, они необходимы для контроля за пространством имён (как, собственно, и во всех других языках программирования), с другой стороны, при помощи модулей можно создавать абстрактные типы данных.

Определить модуль в Хаскеле достаточно просто. ИменемИмя можетмодуля бытьсостоит любойиз символлюбых символов, начинаетсялишь имяначинаться оно толькодолжно с прописной буквы. Дополнительно имяИмя модуля никак не связано с файловой системой (как, например, в [[w:Паскаль|Паскале]] и в [[w:Java|Java]]), то есть имя файла, содержащего модуль, может быть неотлично такимот же, как и названиеназвания модуля. На самом; делетакже, в одном файле может быть несколько модулей, так какибо модуль — это всего лишь навсего декларация самого высокого уровня.

Как известно, на верхнем уровне модуля в Хаскеле может быть множество деклараций (описаний и определений): типы, классы, данные, функции. Однако один вид деклараций должен стоять в модуле на первом месте (если этот вид деклараций вообще используется). Речь идет о включении в модуль других модулей;, длячто этогоделается используется служебное словословом <code>import</code>. Остальные определения могут появляться в любой последовательности.

Определение модуля должно начинаться со служебного слова <code>module</code>. Например, ниже приведено определение модуля <code>Tree</code>:

<code>module Tree (Tree (Leaf, Branch), fringe) where

fringe (Branch left right) = fringe left ++ fringe right</code>

В этом модуле описан один тип: (<code>Tree</code> — ничего(не страшногобеда, что имя типа совпадает с названием модуля,: в данном случаездесь они находятся в различных пространствах имён) и одна функция: (<code>fringe)</code>. Здесь модуль <code>Tree</code> явно экспортирует тип <code>Tree</code> (вместе со своими подтипами <code>Leaf</code> и <code>Branch</code>) и функцию <code>fringe</code> — для этого имена типа и функции указаны в скобках после имени модуля. Если наименование какого-либо объекта не указывать в скобках, то он не будет экспортироваться, то есть этот объект не будет виден извне текущего модуля.

<code>module Main where

main = print (fringe (Branch (Leaf 1) (Leaf 2)))</code>

В приведенном примере видно, что модуль <code>Main</code> импортирует модуль <code>Tree</code>, причём в декларации <code>import</code> явно описано, какие именно объекты импортируются из модуля Tree. Если это описание опустить, то импортироваться будут все объекты, которые модуль экспортирует, то есть в данном случае можно было просто написать: <code>import Tree</code>.

БываетВ так,обычной чтопрактике один модуль импортирует несколько других (надо заметить, что это обычная ситуация), но при этом в импортируемых модулях существуютесть объекты с одним и тем жеодинаковым именем. Естественно, что в этом случае возникает конфликт имён. Чтобы этого избежать в Хаскеле существует специальное служебное слово <code>qualified</code>, при помощи которого определяются те импортируемые модули, имена объектов в которых приобретают вид: <code><Имя Модуля>.<Имя Объекта></code>, то есть для того, чтобы обратиться к объекту из квалифицированного модуля, перед его именем необходимо написать имя модуля:

<code>module Main where

main = print (Tree.fringe (Tree.Leaf ’a’))</code>

=== Абстрактные типы данных ===

В Хаскеле модуль является единственным способом создать так называемые абстрактные типы данных, то есть такие, в которых скрыто представление типа, но открыты только специфические операции над созданным типом, набор которых вполне достаточен для работы с типом. Например, хотя тип <code>Tree</code> является достаточно простым, его все-таки лучше сделать абстрактным типом, то есть скрыть то, что <code>Tree</code> состоит из <code>Leaf</code> и <code>Branch</code>. Это делается следующим образом:

<code>module TreeADT (Tree, leaf, branch, cell, left, right, isLeaf) where

isLeaf _ = False</code>

*В декларации импорта (<code>import</code>) можно выборочно спрятать некоторые из экспортируемых объектов служебным словом <code>hiding</code>. Это бывает полезным для явного исключения определений некоторых объектов из импортируемого модуля.

*При импорте можно определить псевдоним модуля для квалификации имен экспортируемых из него объектов. Для этого используется служебное слово <code>as</code>. Это может быть полезным для того укорачивания имен модулей.

*Все программы неявно импортируют модуль <code>Prelude</code>. Если сделать явный импорт этого модуля, то в его декларации возможно скрыть некоторые объекты, чтобы впоследствии их переопределить.

*Все декларации <code>instance</code> неявно экспортируются и импортируются всеми модулями.

Монады суть типы, представляющие собой экземпляры одного из следующих монадических классов: <code>Functor</code>, <code>Monad</code> и <code>MonadPlus</code>. Ни один из этих классов не может быть предком для другого класса, то есть монадические классы ненаследуемы. В модуле <code>Prelude</code> определены три монады: <code>IO</code>, <code>[]</code> и <code>Maybe</code>, то есть список также является монадой.

<code>class Monad m where

m >> k = m >>= \_ -> k</code>

Две операции <code>(>>=)</code> и <code>(>>)</code> — это операции связывания. Они комбинируют два монадических значения, тогда как функция return преобразует переданное значение некоторого типа a в монадическое значения типа <code>m a</code>. Сигнатура операции (<code>>></code>) помогает понять операцию связывания: выражение (<code>m a >>= \v  m b)</code> комбинирует монадическое значение <code>m a</code>, содержащее объект типа <code>a</code>, с функцией, которая оперирует значением <code>v</code> типа <code>a</code> и возвращает результат типа <code>m b</code>. Результатом же комбинации будет монадическое значение типа <code>m b</code>. Операция <code>(>>)</code> используется тогда, когда функция не использует значения, полученного первым монадическим операндом.

Точное значение операция связывания конечно же зависит от конкретной реализации монады. Так, например, тип <code>IO</code> определяет операцию <code>(>>=)</code> как последовательное выполнение двух её операндов, а результат выполнения первого операнда последовательно передается во второй. Для двух других встроенных монадических типов (списки и <code>Maybe</code>) эта операция определена как передача нуля или более параметров из одного вычислительного процесса в следующий.

В Хаскеле определено служебное слово, на уровне языка поддерживающее использование монад: слово <code>do</code>, понимание которого можно увидеть в следующих правилах его применения:

<code>do e1 ; e2 = e1 >> e2

do p <- e1 ; e2 = e1 >>= \p -> e2</code>

Первое выражение выполняется всегда (переноса значений из первого операнда во второй не производится). Во втором выражении может произойти ошибка, в этом случае производится вызов функции <code>fail</code>, которая также определена в классе <code>Monad</code>. Поэтому более точное определение служебного слова <code>do</code> для второго случая будет выглядеть так:

<code>do p <- e1 ; e2 = e1 >>= (\v -> case v of

_ -> fail ”s”)</code>

где s — это строка, которая может определять местоположение оператора <code>do</code> в программе, а может просто нести некоторую семантическую нагрузку. Например, в монаде <code>IO</code> действие <code>(‘a’  getChar)</code> вызовет функцию <code>fail</code> в том случае, если считанный символ не является символом <code>‘a’</code>. Это действие прерывает исполнение программы, т.к. определенная в монаде <code>IO</code> функция <code>fail</code> в свою очередь вызывает системную функию <code>error</code>.

Класс <code>MonadPlus</code> используется для тех монад, в которых есть нулевой элемент и операция «<code>+</code>». Определение этого класса выглядит следующим образом:

<code>class (Monad m) => MonadPlus m where

mplus :: m a -> m a -> m a</code>

<code>m >>= \x -> mzero = mzero

mzero >>= m = mzero</code>

Например, для списков нулевым элементом является пустой список <code>[]</code>, а операцией «<code>+</code>» — конкатенация списков. Поэтому монада списков является экземпляром класса <code>MonadPlus</code>. С другой стороны монада <code>IO</code> не имеет нулевого элемента, поэтому монада IO является экземпляром только класса <code>Monad</code>.

Для списков операция связывания обретает смысл в соединении вместе набора операций, производимых над каждым элементом списка. При использовании со списками сигнатура операции <code>(>>=)</code> приобретаетобретает следующий вид:

<code>(>>=) :: [a] -> (a -> [b]) -> [b]</code>

Это обозначает, что дан список значений типа <code>a</code> и функция, которая проецирует значение типа <code>a</code> на список значений типа <code>b</code>. Связывание применяет функцию к каждому элементу данного списка значений типа <code>a</code> и возвращает полученный список значений типа <code>b</code>. Эта операция уже известна —: определители списков работают именно таким образом. Т.е.То значит, что следующие три выражения абсолютно одинаковы:

<code>[(x, y) | x <- [1, 2, 3], y <- [1, 2, 3], x /= y]</code>

<code>do x <- [1, 2, 3]

return (x, y)</code>

<code>[1, 2, 3] >>= (\x -> [1, 2, 3] >>= (\y -> return (x /= y) >>=

_ -> fail ””)))</code>

#1. Какое интуитивное понимание можно вложить в понятие «монада»?

#1. Какой практический смысл имеет применение монад в функциональном программировании?