Значения внутри монад, вложенные в структуры данных?
-
18-09-2019 - |
Вопрос
Предположим, что в программе на Haskell у меня есть данные примерно такого типа:
IO [ IO (Int, String, Int) ]
, илиIO [ (Int, String, IO Int) ]
, или[ (Int, String, IO Int) ]
но у меня есть чистые функции, которые должны работать [ (Int, String, Int) ]
.Кажется, мне придется неуклюже удалять внутренние значения из монады IO, пока я не получу что-то вроде IO [ (Int, string, Int) ], а затем (изнутри монады IO) применить чистые функции.Полагаю, не существует простого заранее определенного способа сделать это?Что-то, что могло бы превратить всю структуру данных в монаду, превратив все внутри типы в чистые типы?(Это было бы очень удобно!)
Решение
Вы можете использовать liftM*
функция от Control.Монада модуль или liftA*
функции для аппликативы.
liftM
позволяет вам поднять чистую функцию для работы внутри монады, например:
ghci> let s = return "Hello" :: IO String
ghci> liftM reverse s
"olleH"
Таким образом, вам не придется вручную писать такие вещи, как "s >>= \x -> return (reverse x)
" повсюду.
Хотя это не поможет вам с вашим [(String, Int, IO Int)]
Например, если ваша чистая функция имеет дело с [(String, Int, Int)]
.Поскольку третий элемент кортежа на самом деле не является Int
.
В этом случае я бы предложил сначала написать функцию [(String, Int, IO Int)] -> IO [(String, Int, Int)]
и это применяет поднятую чистую функцию.
Это самая общая функция, которую я мог придумать для этого:
conv :: Monad m => (f (m a) -> m (f a)) -> [f (m a)] -> m [f a]
conv f = sequence . map f
Вы можете назвать это так:
liftTrd :: Monad m => (a, b, m c) -> m (a, b, c)
liftTrd (x, y, mz) = mz >>= \z -> return (x, y, z)
conv liftTrd [("hi", 4, return 2)] :: IO [(String, Int, Int)]
Эта функция будет работать только в том случае, если у вас есть единственная монада, которая находится где-то глубоко в типе.Если у вас их несколько, я думаю, вам действительно следует подумать о типе, с которым вы работаете, и посмотреть, нельзя ли упростить его.
Другие советы
Сначала пример использования приведенного ниже решения под названием reduce
(если вы не предложите лучшее имя):
> reduce [(["ab", "c"], "12")] :: [(String, String)]
[("ab","12"),("c","12")]
> reduce [(["ab", "c"], "12")] :: [(Char, Char)]
[('a','1'),('a','2'),('b','1'),('b','2'),('c','1'),('c','2')]
> reduce [("ab", "12"), ("cd", "3")] :: [(Char, Char)]
[('a','1'),('a','2'),('b','1'),('b','2'),('c','3'),('d','3')]
Ваш пример также решается с его помощью:
complexReduce :: Monad m => m (m (a, b, m [m (c, m d)])) -> m (a, b, [(c, d)])
complexReduce = reduce
И реализация reduce
:
{-# LANGUAGE FlexibleContexts, FlexibleInstances, IncoherentInstances, MultiParamTypeClasses, UndecidableInstances #-}
import Control.Monad
-- reduce reduces types to simpler types,
-- when the reduction is in one of the following forms:
-- * make a Monad disappear, like join
-- * move a Monad out, like sequence
-- the whole magic of Reduce is all in its instances
class Reduce s d where
reduce :: s -> d
-- Box is used only for DRY in Reduce instance definitions.
-- Without it we, a Reduce instance would need
-- to be tripled for each variable:
-- Once for a pure value, once for a monadic value,
-- and once for a reducable value
newtype Box a = Box { runBox :: a }
instance Monad m => Reduce (Box a) (m a) where
reduce = return . runBox
instance Reduce a b => Reduce (Box a) b where
reduce = reduce . runBox
redBox :: Reduce (Box a) b => a -> b
redBox = reduce . Box
-- we can join
instance (Monad m
, Reduce (Box a) (m b)
) => Reduce (m a) (m b) where
reduce = join . liftM redBox
-- we can sequence
-- * instance isnt "Reduce [a] (m [b])" so type is always reduced,
-- and thus we avoid overlapping instances.
-- * we cant make it general for any Traversable because then
-- the type system wont find the right patterns.
instance (Monad m
, Reduce (Box a) (m b)
) => Reduce (m [a]) (m [b]) where
reduce = join . liftM (sequence . fmap redBox)
instance (Monad m
, Reduce (Box a) (m c)
, Reduce (Box b) (m d)
) => Reduce (a, b) (m (c, d)) where
reduce (a, b) = liftM2 (,) (redBox a) (redBox b)
instance (Monad m
, Reduce (Box a) (m d)
, Reduce (Box b) (m e)
, Reduce (Box c) (m f)
) => Reduce (a, b, c) (m (d, e, f)) where
reduce (a, b, c) =
liftM3 (,,) (redBox a) (redBox b) (redBox c)