Proposal: Add mapAccumLM and mapAccumRM to Data.Traversable

[Reed Mullanix]

I propose adding a pair of functions to Data.Traversable: mapAccumLM and
mapAccumRM with the type '(Traversable t, Monad m) => (a -> b -> m (a,c))
-> a -> t b -> m (a, t c)'. These would behave exactly the same as
mapAccumL and mapAccumR, but would allow the addition of monadic effects.

This would allow the traversal of structures with an accumulator, without
resorting to using foldlM or foldrM, both of which require the extra
boilerplate of reconstructing the structure after applying the action,
which can be somewhat frustrating and error-prone.

A possible implementation would be to add transformer counterparts to
StateL/StateR in Data.Functor.Util: (gist:
https://gist.github.com/TOTBWF/dc6020be28df7b00372ab8e507aa54b7)

    newtype StateLT s m a = StateLT { runStateLT :: s -> m (s,a) }

    instance (Functor m) => Functor (StateLT s m) where
      fmap f (StateLT k) = StateLT $ \s -> fmap (\(s',a) -> (s', f a)) $ k s

    instance Monad m => Applicative (StateLT s m) where
      pure a = StateLT $ \s -> return (s, a)
      StateLT kf <*> StateLT kv = StateLT $ \s -> do
        (s', f) <- kf s
        (s'', v) <- kv s'
        return (s'', f v)
      liftA2 f (StateLT kx) (StateLT ky) = StateLT $ \s -> do
        (s', x) <- kx s
        (s'', y) <- ky s'
        return (s'', f x y)

    mapAccumLM :: (Monad m, Traversable t) => (a -> b -> m (a,c)) -> a -> t
b -> m (a, t c)
    mapAccumLM f s t = runStateLT (traverse (StateLT . flip f) t) s

    newtype StateRT s m a = StateRT { runStateRT :: s -> m (s,a) }

    type StateR s = StateRT s Identity

    instance (Functor m) => Functor (StateRT s m) where
      fmap f (StateRT k) = StateRT $ \s -> fmap (\(s',a) -> (s', f a)) $ k s

    instance Monad m => Applicative (StateRT s m) where
      pure a = StateRT $ \s -> return (s, a)
      StateRT kf <*> StateRT kv = StateRT $ \s -> do
        (s', v) <- kv s
        (s'', f) <- kf s'
        return (s'', f v)
      liftA2 f (StateRT kx) (StateRT ky) = StateRT $ \s -> do
        (s', y) <- ky s
        (s'', x) <- kx s'
        return (s'', f x y)

    mapAccumRM :: (Monad m, Traversable t) => (a -> b -> m (a,c)) -> a -> t
b -> m (a, t c)
    mapAccumRM f s t = runStateRT (traverse (StateRT . flip f) t) s
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/libraries/attachments/20180902/16463e94/attachment.html>