module A.I ( RM, UM, ISt (..)
           , ib, lβ
           ) where

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

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

instance HasRenames (ISt a) where rename :: Lens' (ISt a) Renames
rename Renames -> f Renames
f ISt a
s = (Renames -> ISt a) -> f Renames -> 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 (\Renames
x -> ISt a
s { renames = x }) (Renames -> f Renames
f (ISt a -> Renames
forall a. ISt a -> Renames
renames ISt a
s))

type RM a = State (ISt a); type UM = State Int

bind :: Nm a -> E a -> RM a ()
bind :: forall a. Nm a -> E a -> RM a ()
bind (Nm Text
_ (U Int
u) a
_) E a
e = (ISt a -> ISt a) -> StateT (ISt a) Identity ()
forall (m :: * -> *) s. Monad m => (s -> s) -> StateT s m ()
modify (\(ISt Renames
r IntMap (E a)
bs) -> Renames -> IntMap (E a) -> ISt a
forall a. Renames -> IntMap (E a) -> ISt a
ISt Renames
r (Int -> E a -> IntMap (E a) -> IntMap (E a)
forall a. Int -> a -> IntMap a -> IntMap a
IM.insert Int
u 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 (Renames -> Int
max_(Renames -> Int) -> (ISt a -> Renames) -> ISt a -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
.ISt a -> Renames
forall a. ISt a -> Renames
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 (Renames -> IntMap (E a) -> ISt a
forall a. Renames -> IntMap (E a) -> ISt a
ISt (Int -> IntMap Int -> Renames
Rs Int
i IntMap Int
forall a. Monoid a => a
mempty) IntMap (E a)
forall a. Monoid a => a
mempty)

ib :: Int -> Program T -> (E T, Int)
ib :: Int -> Program T -> (E T, Int)
ib Int
i = (E T -> Int -> (E T, Int)) -> (E T, Int) -> (E T, Int)
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry ((Int -> E T -> (E T, Int)) -> E T -> Int -> (E T, Int)
forall a b c. (a -> b -> c) -> b -> a -> c
flip Int -> E T -> (E T, Int)
forall {a}. Int -> E a -> (E a, Int)
β)((E T, Int) -> (E T, Int))
-> (Program T -> (E T, Int)) -> Program T -> (E T, Int)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.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))
-> (Program T -> State (ISt T) (E T)) -> Program T -> (E T, Int)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.Program T -> State (ISt T) (E T)
iP where iP :: Program T -> State (ISt T) (E T)
iP (Program [D T]
ds E T
e) = (D T -> StateT (ISt T) Identity ())
-> [D T] -> StateT (ISt T) Identity ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
(a -> f b) -> t a -> f ()
traverse_ D T -> StateT (ISt T) Identity ()
iD [D T]
ds StateT (ISt T) Identity ()
-> State (ISt T) (E T) -> State (ISt T) (E T)
forall a b.
StateT (ISt T) Identity a
-> StateT (ISt T) Identity b -> StateT (ISt T) Identity b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> E T -> State (ISt T) (E T)
iE E T
e

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

lβ :: E a -> UM (E a)
lβ :: forall a. E a -> UM (E a)
lβ E a
e = (Int -> (E a, Int)) -> StateT Int Identity (E a)
forall (m :: * -> *) s a. Monad m => (s -> (a, s)) -> StateT s m a
state (Int -> E a -> (E a, Int)
forall {a}. Int -> E a -> (E a, Int)
`β` E a
e)

iD :: D T -> RM T ()
iD :: D T -> StateT (ISt T) Identity ()
iD (FunDecl Nm T
n [] E T
e) = do {eI <- E T -> State (ISt T) (E T)
iE E T
e; bind n eI}
iD SetFS{} = () -> StateT (ISt T) Identity ()
forall a. a -> StateT (ISt T) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (); iD SetRS{} = () -> StateT (ISt T) Identity ()
forall a. a -> StateT (ISt T) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (); iD D T
SetAsv = () -> StateT (ISt T) Identity ()
forall a. a -> StateT (ISt T) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (); iD D T
SetUsv = () -> StateT (ISt T) Identity ()
forall a. a -> StateT (ISt T) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (); iD D T
SetCsv = () -> StateT (ISt T) Identity ()
forall a. a -> StateT (ISt T) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
iD SetORS{} = () -> StateT (ISt T) Identity ()
forall a. a -> StateT (ISt T) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (); iD SetOFS{} = () -> StateT (ISt T) Identity ()
forall a. a -> StateT (ISt T) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (); iD FlushDecl{} = () -> StateT (ISt T) Identity ()
forall a. a -> StateT (ISt T) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
iD FunDecl{} = StateT (ISt T) Identity ()
forall {a}. a
desugar

desugar :: a
desugar = [Char] -> a
forall a. HasCallStack => [Char] -> a
error [Char]
"Internal error. Should have been de-sugared in an earlier stage!"

bM :: E a -> RM a (E a)
bM :: forall a. E a -> RM a (E a)
bM (EApp a
_ (EApp a
_ (Lam a
_ Nm a
n (Lam a
_ Nm a
n' E a
e')) E a
e'') E a
e) = do
    eI <- E a -> RM a (E a)
forall a. E a -> RM a (E a)
bM E a
e; bind n' eI
    eI'' <- bM e''; bind n eI''
    bM e'
bM (EApp a
_ (Lam a
_ Nm a
n E a
e') E a
e) = do
    eI <- E a -> RM a (E a)
forall a. E a -> RM a (E a)
bM E a
e; bind n eI
    bM e'
bM (EApp a
l E a
e0 E a
e1) = do
    e0' <- E a -> RM a (E a)
forall a. E a -> RM a (E a)
bM E a
e0; e1' <- bM e1
    case e0' of
        Lam{} -> E a -> RM a (E a)
forall a. E a -> RM a (E a)
bM (a -> E a -> E a -> E a
forall a. a -> E a -> E a -> E a
EApp a
l E a
e0' E a
e1')
        E a
_     -> E a -> RM a (E a)
forall a. a -> StateT (ISt a) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a -> E a -> E a -> E a
forall a. a -> E a -> E a -> E a
EApp a
l E a
e0' E a
e1')
bM e :: E a
e@(Var a
_ (Nm Text
_ (U Int
i) a
_)) = do
    st <- (ISt a -> IntMap (E a)) -> StateT (ISt a) Identity (IntMap (E a))
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets ISt a -> IntMap (E a)
forall a. ISt a -> IntMap (E a)
binds
    case IM.lookup i st of
        Just E a
e' -> E a -> RM a (E a)
forall s (m :: * -> *) a.
(HasRenames s, MonadState s m) =>
E a -> m (E a)
rE E a
e'
        Maybe (E a)
Nothing -> E a -> RM a (E a)
forall a. a -> StateT (ISt a) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure E a
e
bM (Let a
l (Nm a
n, E a
e') E a
e) = do
    e'B <- E a -> RM a (E a)
forall a. E a -> RM a (E a)
bM E a
e'; eB <- bM e
    pure $ Let l (n, e'B) eB
bM (Tup a
l [E a]
es) = a -> [E a] -> E a
forall a. a -> [E a] -> E a
Tup a
l ([E a] -> E a) -> StateT (ISt a) Identity [E a] -> RM a (E a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (E a -> RM a (E a)) -> [E a] -> StateT (ISt a) Identity [E a]
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 a -> RM a (E a)
forall a. E a -> RM a (E a)
bM [E a]
es; bM (Arr a
l Vector (E a)
es) = a -> Vector (E a) -> E a
forall a. a -> Vector (E a) -> E a
Arr a
l (Vector (E a) -> E a)
-> StateT (ISt a) Identity (Vector (E a)) -> RM a (E a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (E a -> RM a (E a))
-> Vector (E a) -> StateT (ISt a) Identity (Vector (E a))
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) -> Vector a -> f (Vector b)
traverse E a -> RM a (E a)
forall a. E a -> RM a (E a)
bM Vector (E a)
es
bM (Rec a
l [(Nm a, E a)]
es) = a -> [(Nm a, E a)] -> E a
forall a. a -> [(Nm a, E a)] -> E a
Rec a
l ([(Nm a, E a)] -> E a)
-> StateT (ISt a) Identity [(Nm a, E a)] -> RM a (E a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((Nm a, E a) -> StateT (ISt a) Identity (Nm a, E a))
-> [(Nm a, E a)] -> StateT (ISt a) Identity [(Nm a, E a)]
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 a -> RM a (E a))
-> (Nm a, E a) -> StateT (ISt a) Identity (Nm a, E a)
forall (m :: * -> *) b b' a.
Functor m =>
(b -> m b') -> (a, b) -> m (a, b')
secondM E a -> RM a (E a)
forall a. E a -> RM a (E a)
bM) [(Nm a, E a)]
es
bM (Anchor a
l [E a]
es) = a -> [E a] -> E a
forall a. a -> [E a] -> E a
Anchor a
l ([E a] -> E a) -> StateT (ISt a) Identity [E a] -> RM a (E a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (E a -> RM a (E a)) -> [E a] -> StateT (ISt a) Identity [E a]
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 a -> RM a (E a)
forall a. E a -> RM a (E a)
bM [E a]
es; bM (OptionVal a
l Maybe (E a)
es) = a -> Maybe (E a) -> E a
forall a. a -> Maybe (E a) -> E a
OptionVal a
l (Maybe (E a) -> E a)
-> StateT (ISt a) Identity (Maybe (E a)) -> RM a (E a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (E a -> RM a (E a))
-> Maybe (E a) -> StateT (ISt a) Identity (Maybe (E a))
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) -> Maybe a -> f (Maybe b)
traverse E a -> RM a (E a)
forall a. E a -> RM a (E a)
bM Maybe (E a)
es
bM (Lam a
l Nm a
n E a
e) = a -> Nm a -> E a -> E a
forall a. a -> Nm a -> E a -> E a
Lam a
l Nm a
n (E a -> E a) -> RM a (E a) -> RM a (E a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> E a -> RM a (E a)
forall a. E a -> RM a (E a)
bM E a
e
bM (Implicit a
l E a
e) = a -> E a -> E a
forall a. a -> E a -> E a
Implicit a
l (E a -> E a) -> RM a (E a) -> RM a (E a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> E a -> RM a (E a)
forall a. E a -> RM a (E a)
bM E a
e
bM (Guarded a
l E a
e0 E a
e1) = a -> E a -> E a -> E a
forall a. a -> E a -> E a -> E a
Guarded a
l (E a -> E a -> E a)
-> RM a (E a) -> StateT (ISt a) Identity (E a -> E a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> E a -> RM a (E a)
forall a. E a -> RM a (E a)
bM E a
e0 StateT (ISt a) Identity (E a -> E a) -> RM a (E a) -> RM a (E a)
forall a b.
StateT (ISt a) Identity (a -> b)
-> StateT (ISt a) Identity a -> StateT (ISt a) Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> E a -> RM a (E a)
forall a. E a -> RM a (E a)
bM E a
e1
bM (Cond a
l E a
p E a
e0 E a
e1) = a -> E a -> E a -> E a -> E a
forall a. a -> E a -> E a -> E a -> E a
Cond a
l (E a -> E a -> E a -> E a)
-> RM a (E a) -> StateT (ISt a) Identity (E a -> E a -> E a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> E a -> RM a (E a)
forall a. E a -> RM a (E a)
bM E a
p StateT (ISt a) Identity (E a -> E a -> E a)
-> RM a (E a) -> StateT (ISt a) Identity (E a -> E a)
forall a b.
StateT (ISt a) Identity (a -> b)
-> StateT (ISt a) Identity a -> StateT (ISt a) Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> E a -> RM a (E a)
forall a. E a -> RM a (E a)
bM E a
e0 StateT (ISt a) Identity (E a -> E a) -> RM a (E a) -> RM a (E a)
forall a b.
StateT (ISt a) Identity (a -> b)
-> StateT (ISt a) Identity a -> StateT (ISt a) Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> E a -> RM a (E a)
forall a. E a -> RM a (E a)
bM E a
e1
bM e :: E a
e@Column{} = E a -> RM a (E a)
forall a. a -> StateT (ISt a) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure E a
e; bM e :: E a
e@IParseCol{} = E a -> RM a (E a)
forall a. a -> StateT (ISt a) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure E a
e; bM e :: E a
e@FParseCol{} = E a -> RM a (E a)
forall a. a -> StateT (ISt a) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure E a
e; bM e :: E a
e@AllField{} = E a -> RM a (E a)
forall a. a -> StateT (ISt a) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure E a
e
bM e :: E a
e@LastField{} = E a -> RM a (E a)
forall a. a -> StateT (ISt a) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure E a
e; bM e :: E a
e@Field{} = E a -> RM a (E a)
forall a. a -> StateT (ISt a) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure E a
e; bM e :: E a
e@FieldList{} = E a -> RM a (E a)
forall a. a -> StateT (ISt a) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure E a
e; bM e :: E a
e@ParseCol{} = E a -> RM a (E a)
forall a. a -> StateT (ISt a) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure E a
e
bM e :: E a
e@AllColumn{} = E a -> RM a (E a)
forall a. a -> StateT (ISt a) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure E a
e; bM e :: E a
e@FParseAllCol{} = E a -> RM a (E a)
forall a. a -> StateT (ISt a) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure E a
e; bM e :: E a
e@IParseAllCol{} = E a -> RM a (E a)
forall a. a -> StateT (ISt a) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure E a
e; bM e :: E a
e@ParseAllCol{} = E a -> RM a (E a)
forall a. a -> StateT (ISt a) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure E a
e
bM e :: E a
e@RC{} = E a -> RM a (E a)
forall a. a -> StateT (ISt a) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure E a
e; bM e :: E a
e@Lit{} = E a -> RM a (E a)
forall a. a -> StateT (ISt a) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure E a
e; bM e :: E a
e@RegexLit{} = E a -> RM a (E a)
forall a. a -> StateT (ISt a) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure E a
e
bM e :: E a
e@BB{} = E a -> RM a (E a)
forall a. a -> StateT (ISt a) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure E a
e; bM e :: E a
e@NB{} = E a -> RM a (E a)
forall a. a -> StateT (ISt a) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure E a
e; bM e :: E a
e@UB{} = E a -> RM a (E a)
forall a. a -> StateT (ISt a) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure E a
e; bM e :: E a
e@TB{} = E a -> RM a (E a)
forall a. a -> StateT (ISt a) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure E a
e
bM ResVar{} = RM a (E a)
forall {a}. a
desugar; bM Dfn{} = RM a (E a)
forall {a}. a
desugar; bM Paren{} = RM a (E a)
forall {a}. a
desugar
bM RwT{} = RM a (E a)
forall {a}. a
desugar; bM RwB{} = RM a (E a)
forall {a}. a
desugar; bM F{} = [Char] -> RM a (E a)
forall a. HasCallStack => [Char] -> a
error [Char]
"impossible."

iE :: E T -> RM T (E T)
iE :: E T -> State (ISt T) (E T)
iE e :: E T
e@NB{} = 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; iE e :: E T
e@UB{} = 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; iE e :: E T
e@BB{} = 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; iE e :: E T
e@TB{} = 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
iE e :: E T
e@Column{} = 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; iE e :: E T
e@ParseCol{} = 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; iE e :: E T
e@IParseCol{} = 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; iE e :: E T
e@FParseCol{} = 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
iE e :: E T
e@Field{} = 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; iE e :: E T
e@LastField{} = 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; iE e :: E T
e@AllField{} = 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; iE e :: E T
e@FieldList{} = 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
iE e :: E T
e@AllColumn{} = 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; iE e :: E T
e@FParseAllCol{} = 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; iE e :: E T
e@IParseAllCol{} = 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; iE e :: E T
e@ParseAllCol{} = 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
iE e :: E T
e@Lit{} = 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
iE e :: E T
e@RegexLit{} = 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; iE e :: E T
e@RC{} = 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
iE (EApp T
t E T
e E T
e') = T -> E T -> E T -> E T
forall a. a -> E a -> E a -> E a
EApp T
t (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)
iE E T
e 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)
iE E T
e'
iE (Guarded T
t E T
p E T
e) = T -> E T -> E T -> E T
forall a. a -> E a -> E a -> E a
Guarded T
t (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)
iE E T
p 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)
iE E T
e
iE (Implicit T
t E T
e) = T -> E T -> E T
forall a. a -> E a -> E a
Implicit T
t (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)
iE E T
e
iE (Lam T
t Nm T
n E T
e) = T -> Nm T -> E T -> E T
forall a. a -> Nm a -> E a -> E a
Lam T
t 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)
iE E T
e
iE (Tup T
t [E T]
es) = T -> [E T] -> E T
forall a. a -> [E a] -> E a
Tup T
t ([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)
iE [E T]
es
iE (Rec T
t [(Nm T, E T)]
es) = T -> [(Nm T, E T)] -> E T
forall a. a -> [(Nm a, E a)] -> E a
Rec T
t ([(Nm T, E T)] -> E T)
-> StateT (ISt T) Identity [(Nm T, E T)] -> State (ISt T) (E T)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((Nm T, E T) -> StateT (ISt T) Identity (Nm T, E T))
-> [(Nm T, E T)] -> StateT (ISt T) Identity [(Nm T, 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))
-> (Nm T, E T) -> StateT (ISt T) Identity (Nm T, E T)
forall (m :: * -> *) b b' a.
Functor m =>
(b -> m b') -> (a, b) -> m (a, b')
secondM E T -> State (ISt T) (E T)
iE) [(Nm T, E T)]
es
iE (Arr T
t Vector (E T)
es) = T -> Vector (E T) -> E T
forall a. a -> Vector (E a) -> E a
Arr T
t (Vector (E T) -> E T)
-> StateT (ISt T) Identity (Vector (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))
-> Vector (E T) -> StateT (ISt T) Identity (Vector (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) -> Vector a -> f (Vector b)
traverse E T -> State (ISt T) (E T)
iE Vector (E T)
es
iE (Anchor T
t [E T]
es) = T -> [E T] -> E T
forall a. a -> [E a] -> E a
Anchor T
t ([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)
iE [E T]
es
iE (OptionVal T
t Maybe (E T)
es) = T -> Maybe (E T) -> E T
forall a. a -> Maybe (E a) -> E a
OptionVal T
t (Maybe (E T) -> E T)
-> StateT (ISt T) Identity (Maybe (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))
-> Maybe (E T) -> StateT (ISt T) Identity (Maybe (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) -> Maybe a -> f (Maybe b)
traverse E T -> State (ISt T) (E T)
iE Maybe (E T)
es
iE (Cond T
t E T
p E T
e E T
e') = T -> E T -> E T -> E T -> E T
forall a. a -> E a -> E a -> E a -> E a
Cond T
t (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)
iE 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)
iE E T
e 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)
iE E T
e'
iE (Let T
_ (Nm T
n, E T
e') E T
e) = do
    eI <- E T -> State (ISt T) (E T)
iE E T
e'; bind n eI; iE e
iE 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 (m :: * -> *) s a. Monad m => (s -> a) -> StateT s 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.
(HasRenames s, MonadState s m) =>
E a -> m (E a)
rE E T
e'; pure $ fmap (aT (match (eLoc 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
iE Dfn{} = State (ISt T) (E T)
forall {a}. a
desugar; iE Paren{} = State (ISt T) (E T)
forall {a}. a
desugar; iE ResVar{} = State (ISt T) (E T)
forall {a}. a
desugar
iE RwB{} = State (ISt T) (E T)
forall {a}. a
desugar; iE RwT{} = State (ISt T) (E T)
forall {a}. a
desugar; iE F{} = [Char] -> State (ISt T) (E T)
forall a. HasCallStack => [Char] -> a
error [Char]
"impossible."