Зачем нужны все эти фунткоры и монады?

в 7:38, , рубрики: haskell, монады, Программирование, функциональное программирование, метки: ,

Очень часто в статьях про Хаскель сплошь и рядом встречаются функторы и особенно монады.
Так часто, что порой не реже встречаются комментарии «сколько можно про какие-то новые монады» и «пишите о чём-либо полезном».
На мой взгляд это свидетельствует о том, что люди порой не понимают зачем же нужны все эти функторы и монады.

Это статья попытка показать, что сила функциональных языков и в первую очередь Хаскеля — это в том числе и силе функторов и монад.
Зачем нужны все эти фунткоры и монады?

Чистые данные

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

Термин «чистый» перенагружено в программировании.
Например, фразу «Руби — чисто объектный язык» мы понимаем как «Руби — язык, где всё — объекты».
А вот фразу «Хаскель — это чистый функциональный язык» следует понимать как «Хаскель — функциональный язык без побочных эффектов».
В этой статье мы будем использовать термин «чистый» ещё в одном контексте.
«Чистые данные» — это данные, которые я хочу получить.
В основном примитивные типы — это числа, строки, иногда более сложные, например — картинка или несколько значений.
Соответственно, «грязные данные» — это данные, которые содержат, помимо того что я хочу, дополнительную информацию.

Вот сочиняем программку:

module Main where

foo = undefined

main :: IO ()
main = do
    putStrLn "Input a: "
    a <- getLine
	putStrLn "Input b: "
	b <- getLine
	print (foo a b)

Программа проста до безобразия — мы просим ввести пользователю 2 строчки, а после выводим результат вычисления.
Видим, что наша функция foo ещё не определена (она всегда вызывает падение программы), хотя Хаскель уже может откомпилировать наш код.

Теперь перепишем более детально нашу функцию, используя только «чистые» данные:

baz :: Int -> Int -> Int
baz = (+)

baz1 :: Int -> Int
baz1 = (+ 1)

bar :: Int -> Int -> Int
bar = div

foo :: String -> String -> Int
foo a b = bar a''' b''
    where
	  a' :: Int
	  a' = read a
	  
	  b' :: Int
	  b' = read b
	  
	  b'' :: Int
	  b'' = baz1 b'
	  
	  a'' :: Int
	  a'' = baz a' b''
	  
	  a''' :: Int
	  a''' = bar a' a''

Как видим, тут тоже понятно, функцию foo мы выражаем через функцию bar, а её мы взяли как обычное целочисленное деление.
Большинство функциональных языков программирования позволяют легко и просто создавать функции, основанные на чистых данных.

Казалось бы всё замечательно — простая и элегантная программка. Но нетушки!
Результат функции намного сложнее, чем нам того хотелось бы.
Как мы понимаем, на 0 делить нельзя, да и пользователь может ввести не числа, а левые строки. Наш код получился небезопасным.
Императивный подход к разрешения подобных проблем делится на 2 группы: или использовать ветвления, или использовать исключения. Зачастую оба подхода комбинируется.
Эти подходы настолько эффективны, что в основном используются и в функциональных языках.
Скажем прямо — в Хаскеле присутствуют исключения, однако они недоразвиты, нуждаются в реформировании, не лучшим образом отлавливаются. Да и самое важное — в большинстве случаев они просто не нужны.
Но нем не менее — можно.
Поэтому попытаемся переписать наш код используя ветвления и исключения.

module Main where

import Control.Exception (IOException, catch)

printError :: IOException -> IO ()
printError = print


baz :: Int -> Int -> Int
baz = (+)

baz1 :: Int -> Int
baz1 = (+ 1)

bar :: Int -> Int -> Int
bar a b = if b == 0 
		  then error "Error 'bar' : wrong 2nd argument = 0"  --unsafe
		  else div a b

foo :: String -> String -> Int
foo a b = bar a''' b''
    where
	  
	  a' :: Int
	  a' = read a   --unsafe
	  
	  b' :: Int
	  b' = read b   --unsafe
	  
	  b'' :: Int
	  b'' = baz1 b'
	  
	  a'' :: Int
	  a'' = baz a' b''
	  
	  a''' :: Int
	  a''' = bar a' a''

main :: IO ()
main = do
    putStrLn "Input a: "
    a <- getLine
	putStrLn "Input b: "
	b <- getLine
	catch (print (foo a b)) printError

Грязные данные

В Хаскеле (да и многих функциональных языках) есть достойный ответ на подобные задачи.
Основная сила заключена в Алгебраических Типах Данных.

Если мы рассматриваем вышеприведённый пример, видно, что наши функции могут падать.
Решение — пользоваться нулабельными типами данных.
В ML языках и Scala такой тип называется Option, в Хаскеле он называется Maybe a.

import Prelude hiding (Maybe) -- этот тип уже описан в стандартной библиотеке. Мы попробуем создать его с нуля

data Maybe a = Nothing | Just a  
                    deriving Show

Мы не обращаем внимание на deriving часть, мы тут просто говорим, что просим компилятор самостоятельно уметь переводить в строку наш тип данных.
А именно,

show Nothing  == "Nothing"
show (Just 3) == "Just 3"

Тип данных принимает значение Nothing если у нас нет данных, и Just a, если есть.
Как видим, тип данных — «грязный», так как содержит лишнюю информацию.
Давайте перепишем наши функции более правильно, более безопасно и без исключений.

Прежде всего заменим функции, которые вызывали падение на безопасные аналоги:

bar :: Int -> Int -> Maybe Int
bar a b = if b == 0 
		  then Nothing         --safe
		  else Just (div a b)
		  

...		  
	  a' :: Maybe Int
	  a' = readMaybe a      --safe
	  
	  b' :: Maybe Int
	  b' = readMaybe b      --safe

Теперь эти функции вместо падения дают результат Nothing, если всё в порядке — то Just результат.

Но весь остальной код у нас зависит от этих функций. Нам придётся изменить почти все функции, в том числе и те, которые много раз тестировались.

baz :: Int -> Int -> Int
baz = (+)

safeBaz :: Maybe Int -> Maybe Int -> Maybe Int
safebaz a b = case a of
			Nothing -> Nothing
			Just a' -> case b of
				Nothing -> Nothing
				Just b' -> Just (baz a' b')

baz1 :: Int -> Int
baz1 = (+ 1)

safeBaz1 :: Maybe Int -> Maybe Int
safeBaz1 a = case a of
			Nothing -> Nothing
			Just a' -> Just (baz1 a')

bar :: Int -> Int -> Maybe Int
bar a b = if b == 0 
		  then Nothing 
		  else Just (div a b)

foo :: String -> String -> Maybe Int
foo a b = case a''' of
			Nothing -> Nothing
			Just a3  -> case b'' of
				Nothing -> Nothing
				Just b2  -> bar a3 b2
    where
	  
	  a' :: Maybe Int
	  a' = readMaybe a
	  
	  b' :: Maybe Int
	  b' = readMaybe b
	  
	  b'' :: Maybe Int
	  b'' = safeBaz1 b'
	  
	  a'' :: Maybe Int
	  a'' = safeBaz a' b''
	  
	  a''' = case a' of
			Nothing -> Nothing
			Just a1  -> case a'' of
				Nothing -> Nothing
				Just a2  -> bar a1 a2

printMaybe :: Show a => Maybe a -> IO ()
printMaybe Nothing  = print "Something Wrong"
printMaybe (Just a) = print a

main :: IO ()
main = do
    putStrLn "Input a: "
    a <- getLine
	putStrLn "Input b: "
	b <- getLine
	printMaybe (foo a b)	

Как видим простая программа превратилась в достаточно монстро-образный код.
Много обёрточных функций, много избыточного кода, много изменено.
Но именно на этом останавливаются многие функциональные языки программирования.
Теперь можно понять почему в тех языках, несмотря на возможность создания множества АТД, АТД не так уж часто используются в коде.

Можно жить с АТД, но без подобной вакханалии? Оказывается можно.

Функторы

На помощь нам в начале приходят функторы.

Функторы — это такие типы данных, для которых существует функция fmap

class Functor f where
    fmap :: (a -> b) -> f a -> f b

а так же его инфиксный синоним:

(<$>) :: Functor f => (a -> b) -> f a -> f b
(<$>) = fmap

такая что для всех значений типа данных всегда выполняются следующие условия:

Условие идентичности:
fmap id == id
Условие композиции:
fmap (f . g) == fmap f . fmap g

Где id — функция идентичности

 id :: a -> a
 id x = x

И (.) — функциональная композиция

 (.) :: (b -> c) -> (a -> b) -> a -> c
 f . g = x -> f (g x)

Функтор — это класс типов, где мы создали специальную функцию fmap. Посмотрим на её аргументы — она берёт одну «чистую» функцию a -> b, берём «грязное» функторное значение f a и получаем на выходе функторное значение f b.

Тип данных Maybe является функтором. Создадим инстанс (экземпляр) для типа Maybe, так чтобы не нарушались законы функторов:

instance Functor Maybe where
   fmap _ Nothing  = Nothing
   fmap f (Just a) = Just (f a)

Как нам использовать чистую функцию с функтором Maybe? Очень просто:

safeBaz1 :: Maybe Int -> Maybe Int
safeBaz1 = fmap baz1

Мы тут видим главное — мы не переписывали нашу функцию baz, а значит нам не надо её ещё раз тестировать на баги и ко всему она осталась универсальной и чистой, зато мы с лёгкостью создали её безопасную версию, которая на вход принимает не числа, а нулабельные числа.

Однако, если мы захотим применить функтор, пытаясь переписать safeBaz, мы потерпим фиаско.
Функторы работают только с функциями с единственным функторно-«грязным» аргументом.
Что же делать для функций с несколькими параметрами?

Аппликативные функторы

Тут нам на помощь приходят аппликативные функторы:

Аппликативные функторы — такие функторы, для которых определены 2 функции: pure и (<*>)

class Functor f => Applicative f where
    pure  :: a -> f a
	(<*>) :: f (a -> b) -> f a -> f b

Такие, что для них для любых значений одного типа данных всегда выполняются следующие правила:

Условие идентичности:
pure id <*> v == v
Условие композиции:
pure (.) <*> u <*> v <*> w == u <*> (v <*> w)
Условие гомоморфизма:
pure f <*> pure x == pure (f x)
Условие обмена:
u <*> pure y == pure ($ y) <*> u

Основное отличение фунтора от аппликативного фунтора состоит в том, что фунтор протаскивает сквозь функторное значение чистую функцию, в то время как аппликативный фукнтор позволяет нам протаскивать сквозь функторное значение функторную функцию f (a -> b).

Maybe является аппликативным функтором и определяется следующим образом:

instance Applicative Maybe where
    pure = Just
	
	Nothing  <*> _        = Nothing
	_        <*> Nothing  = Nothing
	(Just f) <*> (Just a) = Just (f a)

Самое время переписать safeBaz.
В основном функцию переписывают, совмещая функторый fmap для первого аргумента, и аппликативное нанизывание остальных аргументов:

safeBaz :: Maybe Int -> Maybe Int -> Maybe Int
safebaz a b = baz <$> a <*> b

Но можно переписать функцию, пользуясь исключительно аппликативными функциями (монадный стиль) — вначале «чистую» функцию делаем чисто-аппликативной, и аппликативно нанизываем аргументы:

safeBaz :: Maybe Int -> Maybe Int -> Maybe Int
safebaz a b = (pure baz) <*> a <*> b

Замечательно!
Может можно заодно переписать функцию a'''с помощью аппликативных функторов? Увы.

Монады

Давайте обратим внимание на подпись функции bar:
bar :: Int -> Int -> Maybe Int
Функция берёт на вход «чистые» аргументы, и выдаёт на выходе «грязный» результат.
Так вот, в большинстве своём в реальном программировании, именно такие функции встречаются чаще всего — берут на вход «чистые» аргументы, и на выходе — «грязный» результат.
И когда у нас есть несколько таких функций, вместе совместить их помогают монады.

Монады — это такие типы данных, для которых существует функции return и (>>=)

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

такие, что выполняются правила для любых значений типа:

Левой идентичности:
return a >>= k == k a
Правой идентичности:
m >>= return == m
Ассоциативности:
m >>= (x -> k x >>= h) == (m >>= k) >>= h

Для удобства, есть дополнительная функция с обратным порядком аргументов:

(=<<) :: Monad m => (a -> m b) -> m a -> m b
(=<<) = flip (>>=)

Где

flip :: (a -> b -> c) -> b -> a -> c
flip f a b = f b a

Мы понимаем, что тип Maybe является монадой, а значит можно определить его инстанс (экземпляр):

instance  Monad Maybe  where
    return              = Just
	
    (Just x) >>= k      = k x
    Nothing  >>= _      = Nothing

Кстати, если мы присмотримся внимательнее к внутреннему содержанию, и подписям, увидим, что:
pure == return
fmap f xs == xs >>= return . f

Пришло время переписать функцию a'''

 a''' = a' >>= (a1 -> a'' >>= (bar a1))

Да уж, вышло не намного красивее. Это связано с тем, что монады красиво пишутся для одной переменной. К счастью существуют много дополнительных функций.
Можно воспользоваться функцией liftM2

bind2 :: Monad m => (a -> b -> m c) -> m a -> m b -> m c
bind2 mf mx my =  do 
       x <- mx
       y <- my
       mf x y

 a''' = bind2 bar a' a''

Или использовать функцию liftM2 и join

liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
join :: Monad m => m (m a) -> m a

a''' = join $ liftM2 bar a' a''

На крайний случай, можно воспользоваться синтаксическим сахаром для монад, используя do нотацию:

    a''' = do
		a1 <- a'
		a2 <- a''
		bar a1 a2

Различие в применении фунторов и монад

Если мы сведём основные функции к одному виду, то увидим:

(<$>) :: Functor     f =>   (a ->   b) -> f a -> f b
(<*>) :: Applicative f => f (a ->   b) -> f a -> f b
(=<<) :: Monad       f =>   (a -> f b) -> f a -> f b

Все используются для того, чтобы передавать функциям «грязные» значения, тогда как функции ожидают «чистые» значения на входе.
Фунторы используют «чистую» функцию.
Аппликативные функторы — «чистую» функцию внутри «загрязнения».
Монады используют функции, которые на выходе имеют «грязное» значение.

Программа без рутины

Что ж, наконец, можно полностью и аккуратно переписать всю программу:

module Main where

import Control.Monad
import Control.Applicative
import Text.Read (readMaybe)

bind2 :: Monad m => (a -> b -> m c) -> m a -> m b -> m c
bind2 mf mx my =  do 
       x <- mx
       y <- my
       mf x y

baz :: Int -> Int -> Int
baz = (+)

baz1 :: Int -> Int
baz1 = (+ 1)

bar :: Int -> Int -> Maybe Int
bar a b = if b == 0 
		  then Nothing           --safe
		  else Just (div a b)

foo :: String -> String -> Maybe Int
foo a b = bind2 bar a''' b''
    where
	  
	  a' :: Maybe Int
	  a' = readMaybe a       --safe
	  
	  b' :: Maybe Int
	  b' = readMaybe b       --safe
	  
	  b'' :: Maybe Int
	  b'' = fmap baz1 b'
	  
	  a'' :: Maybe Int
	  a'' = baz <$> a' <*> b''
	  
	  a''' :: Maybe Int
	  a''' = bind2 bar a' a''

printMaybe :: Show a => Maybe a -> IO ()
printMaybe Nothing  = print "Something Wrong"
printMaybe (Just a) = print a

main :: IO ()
main = do
    putStrLn "Input a: "
    a <- getLine
	putStrLn "Input b: "
	b <- getLine
	printMaybe (foo a b)

Код снова стал прост и понятен!
При этом мы не поступились ни пядью безопасности!
При этом мы почти не изменили код!
При этом чистые функции остались чистыми!
При этом избежали рутины!

Вывод

Можно ли жить в функциональном мире без функторов и монад? Можно.
Но, если мы хотим вовсю использовать всю силу Алгебраических Типов Данных, нам для удобной функциональной композиции различных функций придётся использовать функторы и монады.
Ибо это отличное средство от рутины и путь к краткому, понятному и часто пере-используемому коду!

P.S. Следует понимать, что для различных типов данных, аналогия с «чистыми» и «грязными» типами данных не совсем уместна.
Например, для списков
fmap = map
А монада:

    a = do
		c <- cs
		d <- ds
		return (zet c d)

на самом деле является

a = [zet c d | c <- cs, d <- ds]

Что не всегда очевидно с первого взгляда.

Автор: Vitter

Источник

Поделиться

* - обязательные к заполнению поля