-- | Common functions for implementing generic traversals
module Language.PureScript.Traversals where

import Prelude.Compat

fstM :: (Functor f) => (a -> f c) -> (a, b) -> f (c, b)
fstM :: (a -> f c) -> (a, b) -> f (c, b)
fstM a -> f c
f (a
a, b
b) = (c -> b -> (c, b)) -> b -> c -> (c, b)
forall a b c. (a -> b -> c) -> b -> a -> c
flip (,) b
b (c -> (c, b)) -> f c -> f (c, b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f c
f a
a

sndM :: (Functor f) => (b -> f c) -> (a, b) -> f (a, c)
sndM :: (b -> f c) -> (a, b) -> f (a, c)
sndM b -> f c
f (a
a, b
b) = (,) a
a (c -> (a, c)) -> f c -> f (a, c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> b -> f c
f b
b

thirdM :: (Functor f) => (c -> f d) -> (a, b, c) -> f (a, b, d)
thirdM :: (c -> f d) -> (a, b, c) -> f (a, b, d)
thirdM c -> f d
f (a
a, b
b, c
c) = (,,) a
a b
b (d -> (a, b, d)) -> f d -> f (a, b, d)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> c -> f d
f c
c

pairM :: (Applicative f) => (a -> f c) -> (b -> f d) -> (a, b) -> f (c, d)
pairM :: (a -> f c) -> (b -> f d) -> (a, b) -> f (c, d)
pairM a -> f c
f b -> f d
g (a
a, b
b)  = (,) (c -> d -> (c, d)) -> f c -> f (d -> (c, d))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f c
f a
a f (d -> (c, d)) -> f d -> f (c, d)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> b -> f d
g b
b

maybeM :: (Applicative f) => (a -> f b) -> Maybe a -> f (Maybe b)
maybeM :: (a -> f b) -> Maybe a -> f (Maybe b)
maybeM a -> f b
_ Maybe a
Nothing = Maybe b -> f (Maybe b)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe b
forall a. Maybe a
Nothing
maybeM a -> f b
f (Just a
a) = b -> Maybe b
forall a. a -> Maybe a
Just (b -> Maybe b) -> f b -> f (Maybe b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
a

eitherM :: (Applicative f) => (a -> f c) -> (b -> f d) -> Either a b -> f (Either c d)
eitherM :: (a -> f c) -> (b -> f d) -> Either a b -> f (Either c d)
eitherM a -> f c
f b -> f d
_ (Left a
a)  = c -> Either c d
forall a b. a -> Either a b
Left  (c -> Either c d) -> f c -> f (Either c d)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f c
f a
a
eitherM a -> f c
_ b -> f d
g (Right b
b) = d -> Either c d
forall a b. b -> Either a b
Right (d -> Either c d) -> f d -> f (Either c d)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> b -> f d
g b
b

defS :: (Monad m) => st -> val -> m (st, val)
defS :: st -> val -> m (st, val)
defS st
s val
val = (st, val) -> m (st, val)
forall (m :: * -> *) a. Monad m => a -> m a
return (st
s, val
val)