module Parser.Rw ( rwP, rwD, rwE ) where


import           A
import           Data.Bifunctor (second)

rwP :: Program a -> Program a
rwP :: forall a. Program a -> Program a
rwP (Program [D a]
ds E a
e) = [D a] -> E a -> Program a
forall a. [D a] -> E a -> Program a
Program (D a -> D a
forall a. D a -> D a
rwD (D a -> D a) -> [D a] -> [D a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [D a]
ds) (E a -> E a
forall a. E a -> E a
rwE E a
e)

rwD :: D a -> D a
rwD :: forall a. D a -> D a
rwD (FunDecl Nm a
n [Nm a]
bs E a
e) = Nm a -> [Nm a] -> E a -> D a
forall a. Nm a -> [Nm a] -> E a -> D a
FunDecl Nm a
n [Nm a]
bs (E a -> E a
forall a. E a -> E a
rwE E a
e); rwD D a
d = D a
d

mFi :: BBin -> Maybe Int
mFi :: BBin -> Maybe Int
mFi BBin
And        = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
3
mFi BBin
Or         = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2
mFi BBin
Eq         = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
4
mFi BBin
Geq        = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
4
mFi BBin
Gt         = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
4
mFi BBin
Lt         = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
4
mFi BBin
Leq        = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
4
mFi BBin
Neq        = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
4
mFi BBin
Exp        = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
8
mFi BBin
Plus       = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
6
mFi BBin
Minus      = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
6
mFi BBin
Times      = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
7
mFi BBin
Div        = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
7
mFi BBin
Map        = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
5
mFi BBin
MapMaybe   = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
5
mFi BBin
Filter     = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
5
mFi BBin
Fold1      = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
5
mFi BBin
Matches    = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
5
mFi BBin
MMatch     = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
5
mFi BBin
NotMatches = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
5
mFi BBin
Min        = Maybe Int
forall a. Maybe a
Nothing
mFi BBin
Max        = Maybe Int
forall a. Maybe a
Nothing
mFi BBin
Split      = Maybe Int
forall a. Maybe a
Nothing
mFi BBin
Splitc     = Maybe Int
forall a. Maybe a
Nothing
mFi BBin
Sprintf    = Maybe Int
forall a. Maybe a
Nothing
mFi BBin
Match      = Maybe Int
forall a. Maybe a
Nothing
mFi BBin
Drop       = Maybe Int
forall a. Maybe a
Nothing
mFi BBin
Take       = Maybe Int
forall a. Maybe a
Nothing
mFi BBin
Rein       = Maybe Int
forall a. Maybe a
Nothing
mFi BBin
Prior      = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
5
mFi BBin
DedupOn    = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
5
mFi BBin
Report     = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
4

pPre :: BUn -> Bool
pPre :: BUn -> Bool
pPre BUn
Dedup     = Bool
True
pPre BUn
Not       = Bool
True
pPre BUn
TallyList = Bool
True
pPre BUn
Tally     = Bool
True
pPre BUn
_         = Bool
False

-- FIXME: prefix-not should extend over vars...

rwE :: E a -> E a
rwE :: forall a. E a -> E a
rwE (EApp a
l0 (EApp a
l1 (EApp a
l2 ho :: E a
ho@TB{} E a
e3) E a
e2) E a
e1) =
    a -> E a -> E a -> E a
forall a. a -> E a -> E a -> E a
EApp a
l0 (a -> E a -> E a -> E a
forall a. a -> E a -> E a -> E a
EApp a
l1 (a -> E a -> E a -> E a
forall a. a -> E a -> E a -> E a
EApp a
l2 E a
ho (E a -> E a
forall a. E a -> E a
rwE E a
e3)) (E a -> E a
forall a. E a -> E a
rwE E a
e2)) (E a -> E a
forall a. E a -> E a
rwE E a
e1)
rwE (EApp a
l0 (EApp a
l1 e0 :: E a
e0@(BB a
_ BBin
op0) E a
e1) E a
e2) | Just Int
fi <- BBin -> Maybe Int
mFi BBin
op0 =
    case E a -> E a
forall a. E a -> E a
rwE E a
e2 of
        (EApp a
l2 (EApp a
l3 e3 :: E a
e3@(BB a
_ BBin
op1) E a
e4) E a
e5) | Just Int
fi' <- BBin -> Maybe Int
mFi BBin
op1, Int
fi Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
fi' -> a -> E a -> E a -> E a
forall a. a -> E a -> E a -> E a
EApp a
l0 (a -> E a -> E a -> E a
forall a. a -> E a -> E a -> E a
EApp a
l1 E a
e3 (E a -> E a
forall a. E a -> E a
rwE (a -> E a -> E a -> E a
forall a. a -> E a -> E a -> E a
EApp a
l2 (a -> E a -> E a -> E a
forall a. a -> E a -> E a -> E a
EApp a
l3 E a
e0 E a
e1) E a
e4))) E a
e5
        E a
e2'                                                                     -> a -> E a -> E a -> E a
forall a. a -> E a -> E a -> E a
EApp a
l0 (a -> E a -> E a -> E a
forall a. a -> E a -> E a -> E a
EApp a
l1 E a
e0 (E a -> E a
forall a. E a -> E a
rwE E a
e1)) E a
e2'
rwE (EApp a
l op :: E a
op@(UB a
_ BUn
Dedup) E a
e) = a -> E a -> E a -> E a
forall a. a -> E a -> E a -> E a
EApp a
l E a
op (E a -> E a
forall a. E a -> E a
rwE E a
e)
rwE (EApp a
l (RwB a
l0 BBin
b) E a
e') =
    case E a -> E a
forall a. E a -> E a
rwE E a
e' of
        (EApp a
lϵ E a
e1 E a
e2) -> a -> E a -> E a -> E a
forall a. a -> E a -> E a -> E a
EApp a
l (a -> E a -> E a -> E a
forall a. a -> E a -> E a -> E a
EApp a
lϵ (a -> BBin -> E a
forall a. a -> BBin -> E a
BB a
l0 BBin
b) E a
e1) E a
e2
        E a
eϵ              -> a -> E a -> E a -> E a
forall a. a -> E a -> E a -> E a
EApp a
l (a -> BBin -> E a
forall a. a -> BBin -> E a
BB a
l0 BBin
b) E a
eϵ
rwE (EApp a
l (RwT a
l0 BTer
t) E a
e') =
    case E a -> E a
forall a. E a -> E a
rwE E a
e' of
        (EApp a
lϵ (EApp a
lϵϵ E a
e1 E a
e2) E a
e3) -> a -> E a -> E a -> E a
forall a. a -> E a -> E a -> E a
EApp a
l (a -> E a -> E a -> E a
forall a. a -> E a -> E a -> E a
EApp a
lϵ (a -> E a -> E a -> E a
forall a. a -> E a -> E a -> E a
EApp a
lϵϵ (a -> BTer -> E a
forall a. a -> BTer -> E a
TB a
l0 BTer
t) E a
e1) E a
e2) E a
e3
        (EApp a
lϵ E a
e1 E a
e2)               -> a -> E a -> E a -> E a
forall a. a -> E a -> E a -> E a
EApp a
l (a -> E a -> E a -> E a
forall a. a -> E a -> E a -> E a
EApp a
lϵ (a -> BTer -> E a
forall a. a -> BTer -> E a
TB a
l0 BTer
t) E a
e1) E a
e2
        E a
eϵ                            -> a -> E a -> E a -> E a
forall a. a -> E a -> E a -> E a
EApp a
l (a -> BTer -> E a
forall a. a -> BTer -> E a
TB a
l0 BTer
t) E a
eϵ
rwE (EApp a
l E a
e0 E a
e') =
    case (E a
e0, E a -> E a
forall a. E a -> E a
rwE E a
e') of
        (E a
_, EApp a
lϵ (EApp a
lϵϵ e3 :: E a
e3@(BB a
_ BBin
op) E a
e4) E a
e2) | Just{} <- BBin -> Maybe Int
mFi BBin
op -> a -> E a -> E a -> E a
forall a. a -> E a -> E a -> E a
EApp a
l (a -> E a -> E a -> E a
forall a. a -> E a -> E a -> E a
EApp a
lϵϵ E a
e3 (E a -> E a
forall a. E a -> E a
rwE (E a -> E a) -> E a -> E a
forall a b. (a -> b) -> a -> b
$ a -> E a -> E a -> E a
forall a. a -> E a -> E a -> E a
EApp a
lϵ E a
e0 E a
e4)) E a
e2
        (UB a
_ BUn
f, E a
e2) | BUn -> Bool
pPre BUn
f                                         -> a -> E a -> E a -> E a
forall a. a -> E a -> E a -> E a
EApp a
l E a
e0 E a
e2
        (E a
_, EApp a
lϵ e1 :: E a
e1@EApp{} E a
e2)                                     -> a -> E a -> E a -> E a
forall a. a -> E a -> E a -> E a
EApp a
l (E a -> E a
forall a. E a -> E a
rwE (E a -> E a) -> E a -> E a
forall a b. (a -> b) -> a -> b
$ 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
e2
        (E a
_, EApp a
lϵ E a
e1 E a
e2)                                            -> a -> E a -> E a -> E a
forall a. a -> E a -> E a -> E a
EApp a
l (a -> E a -> E a -> E a
forall a. a -> E a -> E a -> E a
EApp a
lϵ (E a -> E a
forall a. E a -> E a
rwE E a
e0) E a
e1) E a
e2
        (E a
_, E a
eRw)                                                      -> a -> E a -> E a -> E a
forall a. a -> E a -> E a -> E a
EApp a
l (E a -> E a
forall a. E a -> E a
rwE E a
e0) E a
eRw
rwE e :: E a
e@Column{} = E a
e
rwE e :: E a
e@IParseCol{} = E a
e
rwE e :: E a
e@FParseCol{} = E a
e
rwE e :: E a
e@ParseCol{} = E a
e
rwE e :: E a
e@AllColumn{} = E a
e
rwE e :: E a
e@IParseAllCol{} = E a
e
rwE e :: E a
e@FParseAllCol{} = E a
e
rwE e :: E a
e@ParseAllCol{} = E a
e
rwE e :: E a
e@Field{} = E a
e
rwE e :: E a
e@LastField{} = E a
e
rwE e :: E a
e@FieldList{} = E a
e
rwE e :: E a
e@AllField{} = E a
e
rwE F{} = [Char] -> E a
forall a. HasCallStack => [Char] -> a
error [Char]
"impossible."; rwE RC{} = [Char] -> E a
forall a. HasCallStack => [Char] -> a
error [Char]
"impossible."
rwE (Guarded a
l E a
p E a
e) = a -> E a -> E a -> E a
forall a. a -> E a -> E a -> E a
Guarded a
l (E a -> E a
forall a. E a -> E a
rwE E a
p) (E a -> E a
forall a. E a -> E a
rwE E a
e)
rwE (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
forall a. E a -> E a
rwE E a
e)
rwE (Let a
l (Nm a
n, E a
e') E a
e) = a -> (Nm a, E a) -> E a -> E a
forall a. a -> (Nm a, E a) -> E a -> E a
Let a
l (Nm a
n, E a -> E a
forall a. E a -> E a
rwE E a
e') (E a -> E a
forall a. E a -> E a
rwE E a
e)
rwE e :: E a
e@Var{} = E a
e
rwE e :: E a
e@Lit{} = E a
e
rwE e :: E a
e@RegexLit{} = E a
e
rwE (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
forall a. E a -> E a
rwE E a
e)
rwE (Dfn a
l E a
e) = a -> E a -> E a
forall a. a -> E a -> E a
Dfn a
l (E a -> E a
forall a. E a -> E a
rwE E a
e)
rwE e :: E a
e@BB{} = E a
e
rwE e :: E a
e@TB{} = E a
e
rwE e :: E a
e@UB{} = E a
e
rwE e :: E a
e@NB{} = E a
e
rwE (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
forall a. E a -> E a
rwE(E a -> E a) -> [E a] -> [E a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>[E a]
es)
rwE (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 ((E a -> E a) -> (Nm a, E a) -> (Nm a, E a)
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 E a -> E a
forall a. E a -> E a
rwE((Nm a, E a) -> (Nm a, E a)) -> [(Nm a, E a)] -> [(Nm a, E a)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>[(Nm a, E a)]
es)
rwE e :: E a
e@ResVar{} = E a
e
rwE (Paren a
l E a
e) = a -> E a -> E a
forall a. a -> E a -> E a
Paren a
l (E a -> E a
forall a. E a -> E a
rwE E a
e)
rwE (Cond a
l E a
p E a
e E a
e') = 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
forall a. E a -> E a
rwE E a
p) (E a -> E a
forall a. E a -> E a
rwE E a
e) (E a -> E a
forall a. E a -> E a
rwE E a
e')
rwE (RwB a
l BBin
b) = a -> BBin -> E a
forall a. a -> BBin -> E a
BB a
l BBin
b
rwE (RwT a
l BTer
b) = a -> BTer -> E a
forall a. a -> BTer -> E a
TB a
l BTer
b