CurryInfo: verify-non-fail-2.0.0 / FlatCurry.Simplify.simpArithExp

 
simpArithExp :: Expr -> Expr
simpArithExp exp = case exp of
  Comb FuncCall qt1 [Comb FuncCall qt2 [op, e1], e2]
   | qt1 == pre "apply" && qt2 == qt1
   -- apply (apply op e1) e2 ==> op [e1,e2]
   -> case op of Comb FuncCall qn []           -> replaceBinOp qn e1 e2
                 Typed (Comb FuncCall qn []) _ -> replaceBinOp qn e1 e2
                 _                             -> exp
  Comb FuncCall qt1 [Typed (Comb FuncCall qt2 [op, e1]) _, e2]
   | qt1 == pre "apply" && qt2 == qt1
   -- apply (apply op e1 :: type) e2 ==> op [e1,e2]
   -> case op of Comb FuncCall qn []           -> replaceBinOp qn e1 e2
                 Typed (Comb FuncCall qn []) _ -> replaceBinOp qn e1 e2
                 _                             -> exp
  Comb FuncCall qt1 [op, e1] | qt1 == pre "apply" -- apply op e1 ==> op [e1]
    -> case op of Comb FuncCall qn []           -> replaceUnOp qn e1
                  Typed (Comb FuncCall qn []) _ -> replaceUnOp qn e1
                  _                             -> exp
  Comb FuncCall qn [e1,e2] -> replaceBinOp qn e1 e2
  Comb FuncCall qn [e1]    -> replaceUnOp qn e1
  _                        -> exp
 where
  replaceBinOp (mn,fn) e1 e2
    | mn == "Prelude" = maybe exp
                              (\fp -> Comb FuncCall (mn,fp) [e1,e2])
                              (lookup fn binaryPrimOps)
    | otherwise       = exp

  replaceUnOp (mn,fn) e1
    | mn == "Prelude" = maybe exp
                              (\fp -> Comb FuncCall (mn,fp) [e1])
                              (lookup fn unaryPrimOps)
    | otherwise       = exp

 argument 1

 deterministic operation

 
Simplify applications of primitive operations, i.e.,
    apply (apply op e1) e2      ==> op [e1,e2]
    apply (apply op e1 :: t) e2 ==> op [e1,e2]
    apply op e1                 ==> op [e1]

 _

 referentially transparent operation

 no fixity defined

 {({Comb}) |-> _ || ({Var}) |-> {Var} || ({Lit}) |-> {Lit} || ({Let}) |-> {Let} || ({Free}) |-> {Free} || ({Or}) |-> {Or} || ({Case}) |-> {Case} || ({Typed}) |-> {Typed}}

 simpArithExp

 no precedence defined

 _

 FlatCurry.Types.Expr -> FlatCurry.Types.Expr

 operation might suspend on free variables

 possibly non-terminating

 possibly non-reducible on same data term