module interp4 where

-- No scoping errors for this interpreter
-- No typing errors 

open import Data.Unit
open import Data.Product
open import Data.Nat
open import Data.List

data Typ : Set where
 Nat  : Typ
 _~>_ : Typ -> Typ -> Typ

Ctx : Set
Ctx = List Typ

data Var : Ctx -> Typ -> Set where
  VZ   : forall {g t} -> Var (t ∷ g) t
  VS   : forall {g t' t} -> Var g t -> Var (t' ∷ g) t 

data Exp : Ctx -> Typ -> Set where 
  EVar : forall {g t} -> Var g t -> Exp g t
  ELit : forall {g} -> ℕ -> Exp g Nat 
  ELam : forall {g a b} -> Exp (a ∷ g) b -> Exp g (a ~> b)
  EApp : forall {g a b} -> Exp g (a ~> b) -> Exp g a -> Exp g b

i : Typ -> Set
i Nat = ℕ
i (a ~> b) = i a -> i b

data Env : Ctx -> Set where
  ENil  : Env []
  ECons : forall { g t } -> i t -> Env g -> Env ( t ∷ g )

{-
h : List Typ -> Set
h [] = ⊤ 
h ( t ∷ g ) = i t × h g
-}

sLookup : forall {g t} -> Var g t -> Env g -> i t
sLookup VZ     (ECons v g) = v
sLookup (VS x) (ECons v g) = sLookup x g

interp : forall {g t} -> Env g -> Exp g t -> i t
interp e (EVar x)     = sLookup x e
interp e (ELit i)     = i
interp e (ELam t)     = \x -> interp (ECons x e) t
interp e (EApp t1 t2) = (interp e t1) (interp e t2)

t0 = interp ENil (EApp (ELam (EVar VZ)) (ELit 2))

-- doesn't type check
-- t1 = interp () (Var (S Z))

-- doesn't type check
-- t2 = interp () (App (Lit 2) (Lit 3))