module I ( inline
         , β
         ) where

import           A
import           Control.Monad.State.Strict (State, gets, modify, runState)
import           Data.Bifunctor             (second)
import qualified Data.IntMap                as IM
import           Nm
import           Nm.IntMap
import           R
import           Ty
import           U

data ISt a = ISt { forall a. ISt a -> Rs
renames :: !Rs
                 , forall a. ISt a -> IntMap (E a)
binds   :: IM.IntMap (E a)
                 }

instance HasRs (ISt a) where
    rename :: Lens' (ISt a) Rs
rename Rs -> f Rs
f ISt a
s = (Rs -> ISt a) -> f Rs -> f (ISt a)
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Rs
x -> ISt a
s { renames = x }) (Rs -> f Rs
f (ISt a -> Rs
forall a. ISt a -> Rs
renames ISt a
s))

type M a = State (ISt a)

bind :: Nm a -> E a -> ISt a -> ISt a
bind :: forall a. Nm a -> E a -> ISt a -> ISt a
bind Nm a
n E a
e (ISt Rs
r IntMap (E a)
bs) = Rs -> IntMap (E a) -> ISt a
forall a. Rs -> IntMap (E a) -> ISt a
ISt Rs
r (Nm a -> E a -> IntMap (E a) -> IntMap (E a)
forall a b. Nm a -> b -> IntMap b -> IntMap b
insert Nm a
n E a
e IntMap (E a)
bs)

runI :: Int -> State (ISt a) a -> (a, Int)
runI Int
i = (ISt a -> Int) -> (a, ISt a) -> (a, Int)
forall b c a. (b -> c) -> (a, b) -> (a, c)
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second (Rs -> Int
max_(Rs -> Int) -> (ISt a -> Rs) -> ISt a -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
.ISt a -> Rs
forall a. ISt a -> Rs
renames) ((a, ISt a) -> (a, Int))
-> (State (ISt a) a -> (a, ISt a)) -> State (ISt a) a -> (a, Int)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (State (ISt a) a -> ISt a -> (a, ISt a))
-> ISt a -> State (ISt a) a -> (a, ISt a)
forall a b c. (a -> b -> c) -> b -> a -> c
flip State (ISt a) a -> ISt a -> (a, ISt a)
forall s a. State s a -> s -> (a, s)
runState (Rs -> IntMap (E a) -> ISt a
forall a. Rs -> IntMap (E a) -> ISt a
ISt (Int -> IntMap Int -> Rs
Rs Int
i IntMap Int
forall a. Monoid a => a
mempty) IntMap (E a)
forall a. Monoid a => a
mempty)

inline :: Int -> E (T ()) -> (E (T ()), Int)
inline :: Int -> E (T ()) -> (E (T ()), Int)
inline Int
i = Int -> State (ISt (T ())) (E (T ())) -> (E (T ()), Int)
forall {a} {a}. Int -> State (ISt a) a -> (a, Int)
runI Int
i(State (ISt (T ())) (E (T ())) -> (E (T ()), Int))
-> (E (T ()) -> State (ISt (T ())) (E (T ())))
-> E (T ())
-> (E (T ()), Int)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.E (T ()) -> State (ISt (T ())) (E (T ()))
iM

β :: Int -> E (T ()) -> (E (T ()), Int)
β :: Int -> E (T ()) -> (E (T ()), Int)
β Int
i = Int -> State (ISt (T ())) (E (T ())) -> (E (T ()), Int)
forall {a} {a}. Int -> State (ISt a) a -> (a, Int)
runI Int
i(State (ISt (T ())) (E (T ())) -> (E (T ()), Int))
-> (E (T ()) -> State (ISt (T ())) (E (T ())))
-> E (T ())
-> (E (T ()), Int)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.E (T ()) -> State (ISt (T ())) (E (T ()))
bM

hRi :: Idiom -> Bool
hRi :: Idiom -> Bool
hRi (AShLit [Int]
_ [E (T ())]
es) = (E (T ()) -> Bool) -> [E (T ())] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any E (T ()) -> Bool
forall a. E a -> Bool
hR [E (T ())]
es

hR :: E a -> Bool
hR :: forall a. E a -> Bool
hR (EApp a
_ (EApp a
_ (Builtin a
_ Builtin
R) E a
_) E a
_) = Bool
True
hR Builtin{}                           = Bool
False
hR FLit{}                              = Bool
False
hR ILit{}                              = Bool
False
hR BLit{}                              = Bool
False
hR (ALit a
_ [E a]
es)                         = (E a -> Bool) -> [E a] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any E a -> Bool
forall a. E a -> Bool
hR [E a]
es
hR (Tup a
_ [E a]
es)                          = (E a -> Bool) -> [E a] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any E a -> Bool
forall a. E a -> Bool
hR [E a]
es
hR (Cond a
_ E a
p E a
e E a
e')                     = E a -> Bool
forall a. E a -> Bool
hR E a
pBool -> Bool -> Bool
||E a -> Bool
forall a. E a -> Bool
hR E a
eBool -> Bool -> Bool
||E a -> Bool
forall a. E a -> Bool
hR E a
e'
hR (EApp a
_ E a
e E a
e')                       = E a -> Bool
forall a. E a -> Bool
hR E a
eBool -> Bool -> Bool
||E a -> Bool
forall a. E a -> Bool
hR E a
e'
hR (Lam a
_ Nm a
_ E a
e)                         = E a -> Bool
forall a. E a -> Bool
hR E a
e
hR (Let a
_ (Nm a
_, E a
e') E a
e)                   = E a -> Bool
forall a. E a -> Bool
hR E a
e'Bool -> Bool -> Bool
||E a -> Bool
forall a. E a -> Bool
hR E a
e
hR (Def a
_ (Nm a
_, E a
e') E a
e)                   = E a -> Bool
forall a. E a -> Bool
hR E a
e'Bool -> Bool -> Bool
||E a -> Bool
forall a. E a -> Bool
hR E a
e
hR (LLet a
_ (Nm a
_, E a
e') E a
e)                  = E a -> Bool
forall a. E a -> Bool
hR E a
e'Bool -> Bool -> Bool
||E a -> Bool
forall a. E a -> Bool
hR E a
e
hR Var{}                               = Bool
False
hR (Id a
_ Idiom
i)                            = Idiom -> Bool
hRi Idiom
i

-- assumes globally renamed already
-- | Inlining is easy because we don't have recursion
iM :: E (T ()) -> M (T ()) (E (T ()))
iM :: E (T ()) -> State (ISt (T ())) (E (T ()))
iM e :: E (T ())
e@Builtin{} = E (T ()) -> State (ISt (T ())) (E (T ()))
forall a. a -> StateT (ISt (T ())) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure E (T ())
e
iM e :: E (T ())
e@FLit{} = E (T ()) -> State (ISt (T ())) (E (T ()))
forall a. a -> StateT (ISt (T ())) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure E (T ())
e
iM e :: E (T ())
e@ILit{} = E (T ()) -> State (ISt (T ())) (E (T ()))
forall a. a -> StateT (ISt (T ())) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure E (T ())
e
iM e :: E (T ())
e@BLit{} = E (T ()) -> State (ISt (T ())) (E (T ()))
forall a. a -> StateT (ISt (T ())) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure E (T ())
e
iM (ALit T ()
l [E (T ())]
es) = T () -> [E (T ())] -> E (T ())
forall a. a -> [E a] -> E a
ALit T ()
l ([E (T ())] -> E (T ()))
-> StateT (ISt (T ())) Identity [E (T ())]
-> State (ISt (T ())) (E (T ()))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (E (T ()) -> State (ISt (T ())) (E (T ())))
-> [E (T ())] -> StateT (ISt (T ())) Identity [E (T ())]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse E (T ()) -> State (ISt (T ())) (E (T ()))
iM [E (T ())]
es
iM (Tup T ()
l [E (T ())]
es) = T () -> [E (T ())] -> E (T ())
forall a. a -> [E a] -> E a
Tup T ()
l ([E (T ())] -> E (T ()))
-> StateT (ISt (T ())) Identity [E (T ())]
-> State (ISt (T ())) (E (T ()))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (E (T ()) -> State (ISt (T ())) (E (T ())))
-> [E (T ())] -> StateT (ISt (T ())) Identity [E (T ())]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse E (T ()) -> State (ISt (T ())) (E (T ()))
iM [E (T ())]
es
iM (Cond T ()
l E (T ())
p E (T ())
e0 E (T ())
e1) = T () -> E (T ()) -> E (T ()) -> E (T ()) -> E (T ())
forall a. a -> E a -> E a -> E a -> E a
Cond T ()
l (E (T ()) -> E (T ()) -> E (T ()) -> E (T ()))
-> State (ISt (T ())) (E (T ()))
-> StateT (ISt (T ())) Identity (E (T ()) -> E (T ()) -> E (T ()))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> E (T ()) -> State (ISt (T ())) (E (T ()))
iM E (T ())
p StateT (ISt (T ())) Identity (E (T ()) -> E (T ()) -> E (T ()))
-> State (ISt (T ())) (E (T ()))
-> StateT (ISt (T ())) Identity (E (T ()) -> E (T ()))
forall a b.
StateT (ISt (T ())) Identity (a -> b)
-> StateT (ISt (T ())) Identity a -> StateT (ISt (T ())) Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> E (T ()) -> State (ISt (T ())) (E (T ()))
iM E (T ())
e0 StateT (ISt (T ())) Identity (E (T ()) -> E (T ()))
-> State (ISt (T ())) (E (T ())) -> State (ISt (T ())) (E (T ()))
forall a b.
StateT (ISt (T ())) Identity (a -> b)
-> StateT (ISt (T ())) Identity a -> StateT (ISt (T ())) Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> E (T ()) -> State (ISt (T ())) (E (T ()))
iM E (T ())
e1
iM (EApp T ()
l E (T ())
e0 E (T ())
e1) = T () -> E (T ()) -> E (T ()) -> E (T ())
forall a. a -> E a -> E a -> E a
EApp T ()
l (E (T ()) -> E (T ()) -> E (T ()))
-> State (ISt (T ())) (E (T ()))
-> StateT (ISt (T ())) Identity (E (T ()) -> E (T ()))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> E (T ()) -> State (ISt (T ())) (E (T ()))
iM E (T ())
e0 StateT (ISt (T ())) Identity (E (T ()) -> E (T ()))
-> State (ISt (T ())) (E (T ())) -> State (ISt (T ())) (E (T ()))
forall a b.
StateT (ISt (T ())) Identity (a -> b)
-> StateT (ISt (T ())) Identity a -> StateT (ISt (T ())) Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> E (T ()) -> State (ISt (T ())) (E (T ()))
iM E (T ())
e1
iM (Lam T ()
l Nm (T ())
n E (T ())
e) = T () -> Nm (T ()) -> E (T ()) -> E (T ())
forall a. a -> Nm a -> E a -> E a
Lam T ()
l Nm (T ())
n (E (T ()) -> E (T ()))
-> State (ISt (T ())) (E (T ())) -> State (ISt (T ())) (E (T ()))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> E (T ()) -> State (ISt (T ())) (E (T ()))
iM E (T ())
e
iM (LLet T ()
l (Nm (T ())
n, E (T ())
e') E (T ())
e) = do
    e'I <- E (T ()) -> State (ISt (T ())) (E (T ()))
iM E (T ())
e'
    eI <- iM e
    pure $ LLet l (n, e'I) eI
iM (Let T ()
l (Nm (T ())
n, E (T ())
e') E (T ())
e) | Bool -> Bool
not(E (T ()) -> Bool
forall a. E a -> Bool
hR E (T ())
e')= do
    eI <- E (T ()) -> State (ISt (T ())) (E (T ()))
iM E (T ())
e'
    modify (bind n eI) *> iM e
                     | Bool
otherwise = E (T ()) -> State (ISt (T ())) (E (T ()))
iM(T () -> (Nm (T ()), E (T ())) -> E (T ()) -> E (T ())
forall a. a -> (Nm a, E a) -> E a -> E a
LLet T ()
l (Nm (T ())
n,E (T ())
e') E (T ())
e)
iM (Def T ()
_ (Nm (T ())
n, E (T ())
e') E (T ())
e) = do
    eI <- E (T ()) -> State (ISt (T ())) (E (T ()))
iM E (T ())
e'
    modify (bind n eI) *> iM e
iM e :: E (T ())
e@(Var T ()
t (Nm Text
_ (U Int
i) T ()
_)) = do
    st <- (ISt (T ()) -> IntMap (E (T ())))
-> StateT (ISt (T ())) Identity (IntMap (E (T ())))
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets ISt (T ()) -> IntMap (E (T ()))
forall a. ISt a -> IntMap (E a)
binds
    case IM.lookup i st of
        Just E (T ())
e' -> do {er <- E (T ()) -> State (ISt (T ())) (E (T ()))
forall s (m :: * -> *) a.
(HasRs s, Monad m) =>
E a -> StateT s m (E a)
rE E (T ())
e'; pure $ fmap (rwArr.aT (match (eAnn er) t)) er}
        Maybe (E (T ()))
Nothing -> E (T ()) -> State (ISt (T ())) (E (T ()))
forall a. a -> StateT (ISt (T ())) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure E (T ())
e

-- beta reduction
bM :: E (T ()) -> M (T ()) (E (T ()))
bM :: E (T ()) -> State (ISt (T ())) (E (T ()))
bM e :: E (T ())
e@Builtin{} = E (T ()) -> State (ISt (T ())) (E (T ()))
forall a. a -> StateT (ISt (T ())) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure E (T ())
e
bM e :: E (T ())
e@FLit{} = E (T ()) -> State (ISt (T ())) (E (T ()))
forall a. a -> StateT (ISt (T ())) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure E (T ())
e
bM e :: E (T ())
e@ILit{} = E (T ()) -> State (ISt (T ())) (E (T ()))
forall a. a -> StateT (ISt (T ())) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure E (T ())
e
bM e :: E (T ())
e@BLit{} = E (T ()) -> State (ISt (T ())) (E (T ()))
forall a. a -> StateT (ISt (T ())) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure E (T ())
e
bM (ALit T ()
l [E (T ())]
es) = T () -> [E (T ())] -> E (T ())
forall a. a -> [E a] -> E a
ALit T ()
l ([E (T ())] -> E (T ()))
-> StateT (ISt (T ())) Identity [E (T ())]
-> State (ISt (T ())) (E (T ()))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (E (T ()) -> State (ISt (T ())) (E (T ())))
-> [E (T ())] -> StateT (ISt (T ())) Identity [E (T ())]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse E (T ()) -> State (ISt (T ())) (E (T ()))
bM [E (T ())]
es
bM (Tup T ()
l [E (T ())]
es) = T () -> [E (T ())] -> E (T ())
forall a. a -> [E a] -> E a
Tup T ()
l ([E (T ())] -> E (T ()))
-> StateT (ISt (T ())) Identity [E (T ())]
-> State (ISt (T ())) (E (T ()))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (E (T ()) -> State (ISt (T ())) (E (T ())))
-> [E (T ())] -> StateT (ISt (T ())) Identity [E (T ())]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse E (T ()) -> State (ISt (T ())) (E (T ()))
bM [E (T ())]
es
bM (Cond T ()
l E (T ())
p E (T ())
e0 E (T ())
e1) = T () -> E (T ()) -> E (T ()) -> E (T ()) -> E (T ())
forall a. a -> E a -> E a -> E a -> E a
Cond T ()
l (E (T ()) -> E (T ()) -> E (T ()) -> E (T ()))
-> State (ISt (T ())) (E (T ()))
-> StateT (ISt (T ())) Identity (E (T ()) -> E (T ()) -> E (T ()))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> E (T ()) -> State (ISt (T ())) (E (T ()))
bM E (T ())
p StateT (ISt (T ())) Identity (E (T ()) -> E (T ()) -> E (T ()))
-> State (ISt (T ())) (E (T ()))
-> StateT (ISt (T ())) Identity (E (T ()) -> E (T ()))
forall a b.
StateT (ISt (T ())) Identity (a -> b)
-> StateT (ISt (T ())) Identity a -> StateT (ISt (T ())) Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> E (T ()) -> State (ISt (T ())) (E (T ()))
bM E (T ())
e0 StateT (ISt (T ())) Identity (E (T ()) -> E (T ()))
-> State (ISt (T ())) (E (T ())) -> State (ISt (T ())) (E (T ()))
forall a b.
StateT (ISt (T ())) Identity (a -> b)
-> StateT (ISt (T ())) Identity a -> StateT (ISt (T ())) Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> E (T ()) -> State (ISt (T ())) (E (T ()))
bM E (T ())
e1
bM (EApp T ()
l (Lam T ()
_ Nm (T ())
n E (T ())
e') E (T ())
e) | Bool -> Bool
not(E (T ()) -> Bool
forall a. E a -> Bool
hR E (T ())
e) = do
    eI <- E (T ()) -> State (ISt (T ())) (E (T ()))
bM E (T ())
e
    modify (bind n eI) *> bM e'
                           | Bool
otherwise = do
    eI <- E (T ()) -> State (ISt (T ())) (E (T ()))
bM E (T ())
e
    LLet l (n, eI) <$> bM e'
bM (EApp T ()
l E (T ())
e0 E (T ())
e1) = do
    e0' <- E (T ()) -> State (ISt (T ())) (E (T ()))
bM E (T ())
e0
    e1' <- bM e1
    case e0' of
        Lam{} -> E (T ()) -> State (ISt (T ())) (E (T ()))
bM (T () -> E (T ()) -> E (T ()) -> E (T ())
forall a. a -> E a -> E a -> E a
EApp T ()
l E (T ())
e0' E (T ())
e1')
        E (T ())
_     -> E (T ()) -> State (ISt (T ())) (E (T ()))
forall a. a -> StateT (ISt (T ())) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (E (T ()) -> State (ISt (T ())) (E (T ())))
-> E (T ()) -> State (ISt (T ())) (E (T ()))
forall a b. (a -> b) -> a -> b
$ T () -> E (T ()) -> E (T ()) -> E (T ())
forall a. a -> E a -> E a -> E a
EApp T ()
l E (T ())
e0' E (T ())
e1'
bM (Lam T ()
l Nm (T ())
n E (T ())
e) = T () -> Nm (T ()) -> E (T ()) -> E (T ())
forall a. a -> Nm a -> E a -> E a
Lam T ()
l Nm (T ())
n (E (T ()) -> E (T ()))
-> State (ISt (T ())) (E (T ())) -> State (ISt (T ())) (E (T ()))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> E (T ()) -> State (ISt (T ())) (E (T ()))
bM E (T ())
e
bM e :: E (T ())
e@(Var T ()
_ (Nm Text
_ (U Int
i) T ()
_)) = do
    st <- (ISt (T ()) -> IntMap (E (T ())))
-> StateT (ISt (T ())) Identity (IntMap (E (T ())))
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets ISt (T ()) -> IntMap (E (T ()))
forall a. ISt a -> IntMap (E a)
binds
    case IM.lookup i st of
        -- TODO: track if looked up once before (avoid spurious clones?)
        Just E (T ())
e' -> E (T ()) -> State (ISt (T ())) (E (T ()))
forall s (m :: * -> *) a.
(HasRs s, Monad m) =>
E a -> StateT s m (E a)
rE E (T ())
e' -- rE vs. match ... t?
        Maybe (E (T ()))
Nothing -> E (T ()) -> State (ISt (T ())) (E (T ()))
forall a. a -> StateT (ISt (T ())) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure E (T ())
e
bM (LLet T ()
l (Nm (T ())
n, E (T ())
e') E (T ())
e) = do
    e'B <- E (T ()) -> State (ISt (T ())) (E (T ()))
bM E (T ())
e'
    eB <- bM e
    pure $ LLet l (n, e'B) eB
bM (Id T ()
l Idiom
idm) = T () -> Idiom -> E (T ())
forall a. a -> Idiom -> E a
Id T ()
l (Idiom -> E (T ()))
-> StateT (ISt (T ())) Identity Idiom
-> State (ISt (T ())) (E (T ()))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Idiom -> StateT (ISt (T ())) Identity Idiom
bid Idiom
idm

bid :: Idiom -> M (T ()) Idiom
bid :: Idiom -> StateT (ISt (T ())) Identity Idiom
bid (FoldSOfZip E (T ())
seed E (T ())
op [E (T ())]
es) = E (T ()) -> E (T ()) -> [E (T ())] -> Idiom
FoldSOfZip (E (T ()) -> E (T ()) -> [E (T ())] -> Idiom)
-> State (ISt (T ())) (E (T ()))
-> StateT (ISt (T ())) Identity (E (T ()) -> [E (T ())] -> Idiom)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> E (T ()) -> State (ISt (T ())) (E (T ()))
bM E (T ())
seed StateT (ISt (T ())) Identity (E (T ()) -> [E (T ())] -> Idiom)
-> State (ISt (T ())) (E (T ()))
-> StateT (ISt (T ())) Identity ([E (T ())] -> Idiom)
forall a b.
StateT (ISt (T ())) Identity (a -> b)
-> StateT (ISt (T ())) Identity a -> StateT (ISt (T ())) Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> E (T ()) -> State (ISt (T ())) (E (T ()))
bM E (T ())
op StateT (ISt (T ())) Identity ([E (T ())] -> Idiom)
-> StateT (ISt (T ())) Identity [E (T ())]
-> StateT (ISt (T ())) Identity Idiom
forall a b.
StateT (ISt (T ())) Identity (a -> b)
-> StateT (ISt (T ())) Identity a -> StateT (ISt (T ())) Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (E (T ()) -> State (ISt (T ())) (E (T ())))
-> [E (T ())] -> StateT (ISt (T ())) Identity [E (T ())]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse E (T ()) -> State (ISt (T ())) (E (T ()))
bM [E (T ())]
es
bid (FoldOfZip E (T ())
zop E (T ())
op [E (T ())]
es)   = E (T ()) -> E (T ()) -> [E (T ())] -> Idiom
FoldOfZip (E (T ()) -> E (T ()) -> [E (T ())] -> Idiom)
-> State (ISt (T ())) (E (T ()))
-> StateT (ISt (T ())) Identity (E (T ()) -> [E (T ())] -> Idiom)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> E (T ()) -> State (ISt (T ())) (E (T ()))
bM E (T ())
zop StateT (ISt (T ())) Identity (E (T ()) -> [E (T ())] -> Idiom)
-> State (ISt (T ())) (E (T ()))
-> StateT (ISt (T ())) Identity ([E (T ())] -> Idiom)
forall a b.
StateT (ISt (T ())) Identity (a -> b)
-> StateT (ISt (T ())) Identity a -> StateT (ISt (T ())) Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> E (T ()) -> State (ISt (T ())) (E (T ()))
bM E (T ())
op StateT (ISt (T ())) Identity ([E (T ())] -> Idiom)
-> StateT (ISt (T ())) Identity [E (T ())]
-> StateT (ISt (T ())) Identity Idiom
forall a b.
StateT (ISt (T ())) Identity (a -> b)
-> StateT (ISt (T ())) Identity a -> StateT (ISt (T ())) Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (E (T ()) -> State (ISt (T ())) (E (T ())))
-> [E (T ())] -> StateT (ISt (T ())) Identity [E (T ())]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse E (T ()) -> State (ISt (T ())) (E (T ()))
bM [E (T ())]
es
bid (AShLit [Int]
ds [E (T ())]
es)          = [Int] -> [E (T ())] -> Idiom
AShLit [Int]
ds ([E (T ())] -> Idiom)
-> StateT (ISt (T ())) Identity [E (T ())]
-> StateT (ISt (T ())) Identity Idiom
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (E (T ()) -> State (ISt (T ())) (E (T ())))
-> [E (T ())] -> StateT (ISt (T ())) Identity [E (T ())]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse E (T ()) -> State (ISt (T ())) (E (T ()))
bM [E (T ())]
es
bid (FoldGen E (T ())
seed E (T ())
f E (T ())
g E (T ())
n)    = E (T ()) -> E (T ()) -> E (T ()) -> E (T ()) -> Idiom
FoldGen (E (T ()) -> E (T ()) -> E (T ()) -> E (T ()) -> Idiom)
-> State (ISt (T ())) (E (T ()))
-> StateT
     (ISt (T ())) Identity (E (T ()) -> E (T ()) -> E (T ()) -> Idiom)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> E (T ()) -> State (ISt (T ())) (E (T ()))
bM E (T ())
seed StateT
  (ISt (T ())) Identity (E (T ()) -> E (T ()) -> E (T ()) -> Idiom)
-> State (ISt (T ())) (E (T ()))
-> StateT (ISt (T ())) Identity (E (T ()) -> E (T ()) -> Idiom)
forall a b.
StateT (ISt (T ())) Identity (a -> b)
-> StateT (ISt (T ())) Identity a -> StateT (ISt (T ())) Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> E (T ()) -> State (ISt (T ())) (E (T ()))
bM E (T ())
f StateT (ISt (T ())) Identity (E (T ()) -> E (T ()) -> Idiom)
-> State (ISt (T ())) (E (T ()))
-> StateT (ISt (T ())) Identity (E (T ()) -> Idiom)
forall a b.
StateT (ISt (T ())) Identity (a -> b)
-> StateT (ISt (T ())) Identity a -> StateT (ISt (T ())) Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> E (T ()) -> State (ISt (T ())) (E (T ()))
bM E (T ())
g StateT (ISt (T ())) Identity (E (T ()) -> Idiom)
-> State (ISt (T ())) (E (T ()))
-> StateT (ISt (T ())) Identity Idiom
forall a b.
StateT (ISt (T ())) Identity (a -> b)
-> StateT (ISt (T ())) Identity a -> StateT (ISt (T ())) Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> E (T ()) -> State (ISt (T ())) (E (T ()))
bM E (T ())
n