|
definition:
|
simpExpr :: Expr -> Expr
simpExpr exp = case exp of
Var _ -> exp
Lit _ -> exp
Comb ct qf args -> simpComb ct qf (map simpExpr args)
Let bs e -> Let (map (\ (v,b) -> (v, simpExpr b)) bs) (simpExpr e)
Or e1 e2 -> Or (simpExpr e1) (simpExpr e2)
Case ct e brs -> if isOtherwise e
then simpExpr (trueBranch brs)
else Case ct (simpExpr e) (map simpBranch brs)
Typed e te -> Typed (simpExpr e) te
Free vs e -> Free vs (simpExpr e)
where
simpComb ct qf args
-- simplify application of `Prelude.apply` to partially applied functions:
| qf == pre "apply" && length args == 2
= case head args of
Comb (FuncPartCall n) qft1 fargs ->
simpComb (if n==1 then FuncCall else FuncPartCall (n-1)) qft1
(fargs ++ [args!!1])
_ -> moreSimpComb (Comb ct qf args)
-- inline application of `Prelude.$`:
| qf == pre "$"
= simpComb ct (pre "apply") args
-- simplify `Prelude.otherwise`:
| qf == pre "otherwise"
= fcTrue
| qf == pre "not" && length args == 1
= fcNot (head args)
| qf == pre "||" && length args == 2
= fcOr (head args) (args!!1)
| qf == pre "&&" && length args == 2
= fcAnd (head args) (args!!1)
-- simplify equality instance on lists:
| ct == FuncCall && qf == pre "_impl#==#Prelude.Eq#[]#0##"
= Comb ct (pre "==") (tail args)
| ct == FuncCall && qf == pre "_impl#===#Prelude.Data#[]#0##"
= Comb ct (pre "===") (tail args)
-- simplify equal class calls:
| otherwise
= moreSimpComb (Comb ct qf args)
moreSimpComb e = simpArithExp (simpClassEq e)
simpBranch (Branch p e) = Branch p (simpExpr e)
isOtherwise e = case e of Comb _ qf _ -> qf == pre "otherwise"
_ -> False
trueBranch brs =
maybe (error "simpExpr: Branch with True pattern does not exist!")
(\ (Branch _ e) -> e)
(find (\ (Branch p _) -> isTruePattern p) brs)
isTruePattern p = case p of Pattern qf [] -> qf == pre "True"
_ -> False
|
|
demand:
|
argument 1
|
|
deterministic:
|
deterministic operation
|
|
documentation:
|
--- Implements the following transformations:
--- * simplify equality instance on lists
--- * simplify EQ.== calls
--- * simplify uses of otherwise:
--- case otherwise of { True -> e1 ; False -> e2 } ==> e1
--- * simplify application of `Prelude.$`:
--- f $ e ==> f e
--- * simplify `Prelude.apply` for partially applied first arguments
--- * replace `Prelude.otherwise` by `True`
|
|
failfree:
|
<FAILING>
|
|
indeterministic:
|
referentially transparent operation
|
|
infix:
|
no fixity defined
|
|
iotype:
|
{({Var}) |-> {Var} || ({Lit}) |-> {Lit} || ({Comb}) |-> _ || ({Let}) |-> {Let} || ({Or}) |-> {Or} || ({Case}) |-> _ || ({Typed}) |-> {Typed} || ({Free}) |-> {Free}}
|
|
name:
|
simpExpr
|
|
precedence:
|
no precedence defined
|
|
result-values:
|
_
|
|
signature:
|
FlatCurry.Types.Expr -> FlatCurry.Types.Expr
|
|
solution-complete:
|
operation might suspend on free variables
|
|
terminating:
|
possibly non-terminating
|
|
totally-defined:
|
possibly non-reducible on same data term
|