Почему побочные эффекты смоделированы как монады в Haskell?

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

Итак, для нечистой функции

f' :: Int -> Int

мы добавляем RealWorld к рассмотрению

f :: Int -> RealWorld -> (Int, RealWorld)
-- input some states of the whole world,
-- modify the whole world because of the side effects,
-- then return the new world.

, тогда f снова чисто. Мы определяем параметризованный тип данных IO a = RealWorld -> (a, RealWorld) , поэтому нам не нужно набирать RealWorld так много раз

f :: Int -> IO Int

Для программиста обращение с RealWorld напрямую слишком опасно - в частности, если программист получит в руки значение типа RealWorld, он может попытаться скопировать его, что в принципе невозможно. (Подумайте, например, о попытке скопировать всю файловую систему. Куда бы вы ее поместили?) Следовательно, наше определение ввода-вывода также инкапсулирует состояния всего мира.

Эти нечистые функции бесполезны, если мы не можем связать их вместе. Рассмотрим

getLine :: IO String               = RealWorld -> (String, RealWorld)
getContents :: String -> IO String = String -> RealWorld -> (String, RealWorld)
putStrLn :: String -> IO ()        = String -> RealWorld -> ((), RealWorld)

. Мы хотим получить имя файла из консоли, прочитать этот файл, а затем распечатать содержимое. Как бы мы это сделали, если бы мы могли получить доступ к состояниям реального мира?

printFile :: RealWorld -> ((), RealWorld)
printFile world0 = let (filename, world1) = getLine world0
                       (contents, world2) = (getContents filename) world1 
                   in  (putStrLn contents) world2 -- results in ((), world3)

Здесь мы видим шаблон: функции вызываются следующим образом:

...
(<result-of-f>, worldY) = f worldX
(<result-of-g>, worldZ) = g <result-of-f> worldY
...

Таким образом, мы могли бы определить оператор ~~~ для связывания они:

(~~~) :: (IO b) -> (b -> IO c) -> IO c

(~~~) ::      (RealWorld -> (b, RealWorld))
      -> (b -> RealWorld -> (c, RealWorld))
      ->       RealWorld -> (c, RealWorld)
(f ~~~ g) worldX = let (resF, worldY) = f worldX in
                        g resF worldY

тогда мы могли бы просто написать

printFile = getLine ~~~ getContents ~~~ putStrLn

, не касаясь реального мира.

Теперь предположим, что мы хотим сделать содержимое файла прописными. Верхний регистр - это чистая функция

upperCase :: String -> String

, но чтобы воплотить его в жизнь, он должен вернуть строку ввода-вывода . Такую функцию легко поднять:

impureUpperCase :: String -> RealWorld -> (String, RealWorld)
impureUpperCase str world = (upperCase str, world)

это можно обобщить:

impurify :: a -> IO a

impurify :: a -> RealWorld -> (a, RealWorld)
impurify a world = (a, world)

так, чтобы impureUpperCase = impurify.upperCase , и мы можем написать

printUpperCaseFile = 
    getLine ~~~ getContents ~~~ (impurify . upperCase) ~~~ putStrLn

_{(Примечание: обычно мы пишем getLine ~~~ getContents ~~~ (putStrLn. upperCase) )}

Теперь давайте посмотрим, что мы сделали:

1. Мы определили оператор (~~~) :: IO b -> (b -> IO c) -> IO c , который связывает две нечистые функции вместе
2. Мы определили функцию impurify :: a -> IO a , который преобразует чистое значение в нечистое.

Теперь мы производим идентификацию (>> =) = (~~~) и return = impurify , и видите? У нас есть монада.

(Чтобы проверить, действительно ли это монада, должно быть выполнено несколько аксиом:

(1) return a >> = f = fa

  impurify a               = (\world -> (a, world))
 (impurify a ~~~ f) worldX = let (resF, worldY) = (\world -> (a, world)) worldX 
                             in f resF worldY
                           = let (resF, worldY) =            (a, worldX))       
                             in f resF worldY
                           = f a worldX

(2) f >> = return = f

  (f ~~~ impurify) a worldX = let (resF, worldY) = impuify a worldX 
                              in f resF worldY
                            = let (resF, worldY) = (a, worldX)     
                              in f resF worldY
                            = f a worldX

(3) f >> = (\ x -> gx >> = h) = (f >> = g) >> = h

Упражнение.)