Если вы видите что-то необычное, просто сообщите мне. Skip to main content

Монады

Добро пожаловать в часть 3 нашей серии абстрактных структур! Мы, наконец, коснемся идеи монад! Множежство людей пытаются изучить монады без попытки заиметь понимания того. как абстрактные структуры типов класса работают. Это главная причина борьбы. Если вы всё еще этого не пониматете, обратитесь к 1 и 2 части этой серии.

После этой статьи вы будете готовы к тому, чтобы писать свой собственный код Haskell.

Букварь монад

Есть множество инструкций и поисаний монад в интернете. Количество аналогий просто смешно. Но вот мои 5 копеек в определении: Монада - обертка значения или вычисления с определенным контекстом. Монада должна определять и смысл обернутого значения в контексте и способ объединения вычислений в контексте.

Это определение достатоно широко. Давайте взглянем на конкретный пример, и попробуем понять.

Классы типы монад

Так же как с функторами и аппликативными функторами, Haskell отражает монады с помощью тип класса. На это есть две функции:

class Monad m where
  return :: a -> m a
  (>>=) :: m a -> (a -> m b) -> m b

Эти две функции отвечают двум идеям выше. Функция возвращения определяем как обернуть значения в контексте монад. Оператор >>=, который мы назовем его функцией "связывания", определяет как объединить две операции с контекстом. Давайте проясним это далее узучив несколько определенным экземпляров монад.

Монада Maybe

Just как Maybe это функтор и аппликативный функтор, но еще и монада. Чтобы понять смысл монады Maybe давайте посмотрим представим код:

maybeFunc1 :: String -> Maybe Int
maybeFunc1 "" = Nothing
maybeFunc1 str = Just $ length str

maybeFunc2 :: Int -> Maybe Float
maybeFunc2 i = if i `mod` 2 == 0
  then Nothing
  else Just ((fromIntegral i) * 3.14159)

maybeFunc3 :: Float -> Maybe [Int]
maybeFunc3 f = if f > 15.0
  then Nothing
  else Just [floor f, ceiling f]

runMaybeFuncs :: String -> Maybe [Int]
runMaybeFuncs input = case maybeFunc1 input of
  Nothing -> Nothing
  Just i -> case maybeFunc2 i of
    Nothing -> Nothing
    Just f -> maybeFunc3 f

Можно увидеть, что мы начинаем разрабатывать отвратительный треугольный шаблон, в качестве продолжения шаблона соответствия результатов успешного вызова функций. Если мы добавили еще больше функций Maybe в него, то всё станет еще хуже. Если мы считаем Maybe в качестве монады, мы можем сделать код гораздо чище. Давайте взглянем на то, как Haskell реализует Maybe монаду, чтобы понять как это делать.

instance Monad Maybe where
  return = Just
  Nothing >>= _ = Nothing
  Just a >>= f = f a

Внутри Maybe монада проста. Вычисления созначением в Maybe могут как пройти, так и не пройти успешно. Мы можем взять любое значение обернуть его в этом контексте вызовом значения success. Мы делаем это с помощью конструктора Just. Неуспех обозначается с помощью Nothing.

Объединим вычисления в контексте проверяя результа первого вычисления. Если успешно, мы берем его значение и передаем во второе вычисление. Если неуспешно, тогда у нас нет значения для передачи дальше. Поэтому результирующее вычисление не будет успешно. Взглянем на то, как мы можем исопльзовать bind(>>=) оператор для объединения наших операторов:

runMaybeFuncsBind :: String -> Maybe [Int]
runMaybeFuncsBind input = maybeFunc1 input >>= maybeFunc2 >>= maybeFunc3

Выглядит гораздо чище! Давайте взглянем почему работают типы. Результат maybeFunc1 просто Maybe Int. Затем оператор bind(>>=) позволяет нам взять это Maybe Int значение и объединить с maybeFunc2, чей тип Int -> Maybe Float. Оператор bind(>>=) разрешает значение в Maybe Float. Затем мы передаем походим образом через оператор bind(>>=) в maybeFunc3 результатом которой является конечный тип: Maybe [Int].

Ваша функции не всегд будут так ясно сочитаться. Тут в силу вступает запись do. Код выше можно переписать следующим образом:

runMaybeFuncsDo :: String -> Maybe [Int]
runMaybeFuncsDo input = do
  i <- maybeFunc1 input
  f <- maybeFunc2 i
  maybeFunc3 f

Оператор <- особенный. Он эффективно разворачивает значение с правой стороны монады. Это значит, что значение i имеет типа Int, даже не смотря на результат maybeFunc1 как Maybe Int. Оператор bind(>>=) работает без нашего участия. Если функция возвращает Nothing, тогда вся функция runMaybeFuncs вернет Nothing.

При беглом осмотре, это выглядит гораздо сложнее, чем пример с bind(>>=). Однако, оно дает нам гораздо больше гибкости. Предположим, мы хотим добавить 2 к целому числу перед вызовом MaybeFunc2. Это проще сделать с помощью do записи, но гораздо сложноее используя связывания.

runMaybeFuncsDo2 :: String -> Maybe [Int]
runMaybeFuncsDo2 input = do
  i <- maybeFunc1 input
  f <- maybeFunc2 (i + 2)
  maybeFunc3 f

-- Not so nice
runMaybeFuncsBind2 :: String -> Maybe [Int]
runMaybeFuncsBind2 input = maybeFunc1 input
  >>= (\i -> maybeFunc2 (i + 2))
  >>= maybeFunc3

Преимущества гораздо очевидны если мы хотим использовать множество прошедших результатов при вызове функии. Используя связывания, мы сможем постоянно складывать аргументы в анонимную функцию.

Мы никогда не используем <- для развернывания последней операции в блоке do.

Наш вызов maybeFunc3 имеет тип Maybe [Int]. Это наш последний тип(не [Int]) поэтому его не нужно разворачивать.

монада Either

Теперь, давайте посмотрим на монаду Either, которая очень похожа на монаду Maybe. Вот её определение:

instance Monad (Either a) where
  return r = Right r
  (Left l) >>= _ = Left l
  (Right r) >>= f = f r

Поскольку Maybe имеет успех или не успех со значением, монада Either прикладывает информацию к неуспеху. Just как Maybe обертывает значение в его контексте вызова делая его упешным. Монадическое поведение так же объединяет операции завершаясь на первом не успехе. Давайте посмотрим как мы можем использовать это чтобы сделать наш код выше чище.

eitherFunc1 :: String -> Either String Int
eitherFunc1 "" = Left "String cannot be empty!"
eitherFunc1 str = Right $ length str

eitherFunc2 :: Int -> Either String Float
eitherFunc2 i = if i `mod` 2 == 0
  then Left "Length cannot be even!"
  else Right ((fromIntegral i) * 3.14159)

eitherFunc3 :: Float -> Either String [Int]
eitherFunc3 f = if f > 15.0
  then Left "Float is too large!"
  else Right [floor f, ceiling f]

runEitherFuncs :: String -> Either String [Int]
runEitherFuncs input = do
  i <- eitherFunc1 input
  f <- eitherFunc2 i
  eitherFunc3 f

Любой не успех просто даст нам значение Nothing:

>> runMaybeFuncs ""
Nothing
>> runMaybeFuncs "Hi"
Nothing
>> runMaybeFuncs "Hithere"
Nothing
>> runMaybeFuncs "Hit"
Just [9,10]

когда мы запустим наш код, мы можем посмотреть на строковый результат ошибки, и она расскажет нам о том, какая функция не смогла произвести вычисления.

>> runMaybeFuncs ""
Left "String cannot be empty!"
>> runMaybeFuncs "Hi"
Left "Length cannot be even!"
>> runMaybeFuncs "Hithere"
Left "Float is too large!"
>> runMaybeFuncs "Hit"
Right [9,10]

Заметим, что мы параметризовали монаду Either с помощью нашего типа ошибки. Если у нас есть:

data CustomError = CustomError

maybeFunc2 :: Either CustomError Float
...

Это функция теперь новая монада. Объединения с другими функциями не будет легким.

Монада IO

Монада IO, возмоно, самая важная монада в Haskell. Это так же одна из самых сложных монад для понимания начинающих. Её реализация достаточна сложна для обсуждения при первом знакомстве с языком. Поэтому будем учиться по примерам.

IO монада обертывает вычисления с ледующем случае: "Вычисления могут читать информацию или писать в терминал, файловую систему, ОС или сеть". Если выхотите получить пользовательский ввод, выведите сообщение пользователю, прочитайте информацию из файла, или сделайте сетевой вызов, для этого понадобиться IO монада. Эти вызовы имеют "сторонние эффекты", мы нне может произвести их из "чистого" Haskell кода.

Важная работа почти любого компьютера это взаимодействие с внешним миром, каким-то образом. На этот случай, корнем всего выполняемого Haskell кода это функция называемая main, с типом IO(). Поэтому любая программа начинается с IO монады. Отсюда вы можете получить любой необходимый ввод, вызвать относительно "чистый" код с помощью ввода, и затем вывести результат каким-то образом. Обратное не работает. Вы не можете взывать внутри IO кода, код, как тот, который вы можете вызвать в Maybe функции из чистого кода.

Давайте взглянем на простой пример показывающий несколько базовых IO функций. Мы будем использовать do-запись для того, чтобы показать схожесть с другими монадами, которые мы уже встречали. Выведем тип каждой IO функции для ясности.

main :: IO ()
main = do
  -- getLine :: IO String
  input <- getLine
  let uppercased = map Data.Char.toUpper input
  -- print :: String -> IO ()
  print uppercased

Каждый раз мы видим строку нашей программы и она имеет тип IO. Так же как мы можем развернуть i в примере maybe для получения Int взамен Maybe Int, мы можем использовать <-, чтобы развернуть результат getLine в качестве String. Мы можем затем использовать это значение с помощью строковой функции, и передаавть результат в функцию print.

Это просто эхо-программа. Она читает строку из терминала и затем выводит строку обратно с капсом. Надеюсь она дает вам базовое понимание того как IO работает. Мы залезем глубже в детали в следующей паре статей.

SUMMARYВыводы

AtС thisэтой point,точки, weмы shouldдолжны finallyнаконец haveиметь aлучшее decentпонимание graspтого, onчто whatтакое monadsмонады. are.Но Butесли ifони theyне don'tимеют makeсмысла senseдо yet,сих don'tпор, fret!не Itраздражайтесь! tookМне meпришлось aпотратить fewнесколько differentпопыток, triesпрежде beforeчем Iя reallyсмог understoodпонять them!их. Don'tНе beбойтесь afraidвзглянуть toеще takeразок another look at partна 1 and partи 2 toчасти, giveчтобы yourself a refresher onосвежить Haskell structureзнания. basics.И Andопределенно definitelyстоит feelпрочитать freeеще toразок readэту this article again!статью.

ButЕсли ifже youвам areвсё feelingпонятно, good,вы thenготовы you'reдвигаться readyк to move on to partчасти 4, whereгде you'llвы learnизучите aboutо theReader Readerи andWriter Writerмонадах, monads.что Theseпозволит startвам toпривнести bringвозможность usиспользовать accessнекий toфункционал someв ofHaskell, theо functionalityкотором youвы thinkдумали, Haskellчто mightон beне "missing"доступен.

If you've never programmed in Haskell before, hopefully I've convinced you that it's not that scary and you're ready to check it out! Download our Beginners Checklist to learn how to get started.

Back to top