{-# Language LambdaCase, Strict #-}

module Interpreter.Self where

import Chi
import Interpreter.Haskell

mapExp :: Exp
mapExp = parse
  "\\f. rec map = \\xs. case xs of \
  \ { Nil() -> Nil() \
  \ ; Cons(x,xs) -> Cons(f x, map xs)\
  \ }"

ifExp :: Exp
ifExp = parse
  "\\b. \\t. \\f. case b of \
  \ { True() -> t \
  \ ; False() -> f \
  \ }"

equalExp :: Exp
equalExp = parse
  "rec equal = \\m. \\n. case m of \
  \ { Zero() -> case n of { Zero() -> True(); Suc(n) -> False() } \
  \ ; Suc(m) -> case n of { Zero() -> False(); Suc(n) -> equal m n }\
  \ }"

elemExp :: Exp
elemExp =
  subst (Variable "equal") equalExp .
  subst (Variable "if") ifExp $ parse
  "\\x. rec elem = \\l. case l of \
  \ { Nil() -> False() \
  \ ; Cons(v,vs) -> if (equal x v) True() (elem vs)\ 
  \ }"

substBrExp :: Exp
substBrExp =
  subst (Variable "elem") elemExp $ parse
  "\\subst. \\var. \\b. case b of \
  \ { Branch(c,vs,e') -> if (elem var vs) Branch(c,vs,e') Branch(c,vs, subst e') \
  \ }"

substExp :: Exp
substExp =
  subst (Variable "if") ifExp .
  subst (Variable "equal") equalExp .
  subst (Variable "substBr") substBrExp .
  subst (Variable "map") mapExp $ parse
        "\\var. \\e. rec subst = \\x. case x of\
        \ { Apply(e1,e2) -> Apply(subst e1, subst e2) \
        \ ; Lambda(x,y) -> if (equal x var) Lambda(x,y) Lambda(x,subst y) \
        \ ; Var(x) -> if (equal x var) e Var(x) \
        \ ; Const(c,es) -> Const(c, map subst es) \
        \ ; Rec(x, e') -> if (equal x var) Rec(x,e') Rec(x,subst e')\
        \ ; Case(e',bs) -> Case(subst e', map (substBr subst var) bs) \
        \ }"