Изучай Haskell во имя добра!

Инструкция нашего канатоходца может также быть выражена с использованием нотации do. Функции landLeft и landRight принимают количество птиц и шест и производят шест, обёрнутый в Just. Исключение – это когда канатоходец соскальзывает, и тогда возвращается значение Nothing. Мы использовали операцию >>= для сцепления последовательных шагов, потому что каждый из них зависел от предыдущего и каждый обладал добавленным контекстом возможной неудачи. Здесь две птицы приземляются с левой стороны, затем две птицы – с правой, а потом одна птица – снова с левой:

routine :: Maybe Pole

routine = do

   start <– return (0, 0)

   first <– landLeft 2 start

   second <– landRight 2 first

   landLeft 1 second

Давайте посмотрим, окончится ли это удачно для Пьера:

ghci> routine

Just (3,2)

Окончилось удачно!

Когда мы выполняли эти инструкции, явно записывая вызовы оператора >>=, мы обычно писали что-то вроде return (0, 0) >>= landLeft 2, потому что функция landLeft является функцией, которая возвращает значение типа Maybe. Однако при использовании выражения do каждая строка должна представлять монадическое значение. Поэтому мы явно передаём предыдущее значение типа Pole функциям landLeft и landRight. Если бы мы проверили образцы, к которым привязали наши значения типа Maybe, то start был бы равен (0, 0), first был бы равен (2,

0) и т. д.

Поскольку выражения do записываются построчно, некоторым людям они могут показаться императивным кодом. Но эти выражения просто находятся в последовательности, поскольку каждое значение в каждой строке зависит от результатов выражений в предыдущих строках вместе с их контекстами (в данном случае контекстом является успешное либо неуспешное окончание их вычислений).

Ещё раз давайте взглянем на то, как выглядел бы этот кусок кода, если бы мы не использовали монадические стороны типа Maybe:

routine :: Maybe Pole

routine =

   case Just (0, 0) of

      Nothing –> Nothing

      Just start –> case landLeft 2 start of

         Nothing –> Nothing

         Just first –> case landRight 2 first of

            Nothing –> Nothing

            Just second –> landLeft 1 second

Видите, как в случае успеха образец start получает значение кортежа внутри Just (0, 0), образец

first получает значение результата выполнения landLeft 2 start и т. д.?

Если мы хотим бросить Пьеру банановую кожуру в нотации do, можем сделать следующее:

routine :: Maybe Pole

routine = do

   start <– return (0, 0)

   first <– landLeft 2 start

   Nothing

   second <– landRight 2 first

   landLeft 1 second

Когда мы записываем в нотации do строку, не связывая монадическое значение с помощью символа <–, это похоже на помещение вызова функции >> за монадическим значением, результат которого мы хотим игнорировать. Мы помещаем монадическое значение в последовательность, но игнорируем его результат, так как нам неважно, чем он является. Плюс ко всему это красивее, чем записывать эквивалентную форму _ <– Nothing.

Когда использовать нотацию do

, а когда явно использовать вызов операции >>=, зависит от вас. Я думаю, этот пример хорошо подходит для того, чтобы явно использовать операцию >>=, потому что каждый шаг прямо зависит от предыдущего. При использовании нотации do мы должны явно записывать, на каком шесте садятся птицы, но каждый раз мы просто используем шест, который был результатом предшествующего приземления. Тем не менее это дало нам некоторое представление о нотации do.

Сопоставление с образцом и неудача в вычислениях

Привязывая монадические значения к идентификаторам в нотации do, мы можем использовать сопоставление с образцом так же, как в выражениях let и параметрах функции. Вот пример сопоставления с образцом в выражении do:

justFirst :: Maybe Char

justFirst = do

   (x:xs) <– Just "привет"

   return x

Мы используем сопоставление с образцом для получения первого символа строки "привет", а затем возвращаем его в качестве результата. Поэтому justFirst возвращает значение Just 'п'.