Предположим, что функция имеет побочные эффекты. Если мы возьмем все эффекты, которые он производит, в качестве входных и выходных параметров, то функция будет чистой для внешнего мира.
Так что для нечистой функции
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, он может попытаться скопировать его, что в принципе невозможно. (Подумайте, например, о попытке скопировать всю файловую систему. Где бы вы ее разместили?) Поэтому наше определение IO также включает в себя состояния всего мира.
Эти нечистые функции бесполезны, если мы не можем связать их вместе. Рассмотрим
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
Но чтобы попасть в реальный мир, он должен вернуть IO 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))
Теперь посмотрим, что мы сделали:
- Мы определили оператор
(~~~) :: IO b -> (b -> IO c) -> IO c, который объединяет две нечистые функции вместе
- Мы определили функцию
impurify :: a -> IO a, которая преобразует чистое значение в нечистое.
Теперь мы делаем идентификацию (>>=) = (~~~) и return = impurify, и видите? У нас есть монада.
(Чтобы проверить, действительно ли это монада, нужно выполнить несколько аксиом:
(1) return a >>= f = f a
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 -> g x >>= h) = (f >>= g) >>= h
Упражнение.)