module StrategoAST where

type Name = String
data Op = Plus | Mult | IntEq | IntLess
data LS = Lazy | Strict deriving Eq

data P --- Nested Patterns
  = Pconst Integer          -- { 5 }
  | Pvar Name               -- { x }
  | Ptuple [P]              -- { (p1,p2) }
  | Pcondata Name [P]       -- data T1 = C1 t1 t2; {C1 p1 p1} = e 
  | Pnewdata Name P         -- newtype T2 = C2 t1;  {C2 p1} = e
  | Ptilde P                -- { ~p }
  | Paspat Name P           -- { x@p }
  | Pwildcard               -- { _ }

data E 
  = Var Name             -- { x }
  | Const Integer        -- { 5 }
  | App E E              -- { f x }
  | Abs [P] E            -- { \ p1 p2 -> e }
  | TupleExp [E]         -- { (e1,e2) }
  | ConApp Name [(E,LS)] -- data T1 = C1 t1 t2 \nl p = {C1 e1 e2}
  | NewApp Name E        -- newtype T2 = C2 t1 t2 \nl p = {C2 e1 e2}
  | Seq E E              -- { seq e1 e2 }               
  | Bin Op E E           -- { e1 + e2 }
  | Cond E E E           -- { if e1 then e2 else e3 }
  | Let [D] E            -- { let x=e1 \nl   y=e2 in e3 }
  | Case E [Match]       -- { case e of m1 \nl m2 }

type Match = 
      (P, B, [D])        -- case e of { pat -> body where decs } 

data D 
  = Fun Name [Clause]    -- { f p1 p2 = b where decs }
  | Val P B [D]          -- { p = b where decs }

type Clause = 
      ([P],B,[D])        -- f { p1 p2 = body where decs }
data B
  = Guarded [(E,E)]      -- f p { | e1 = e2 | e3 = e4 } where ds
  | Normal E             -- f p = { e } where ds