Update typesafe imperative language post draft.

code/typesafe-imperative/TypesafeImp.idr

@@ -2,20 +2,20 @@ data Reg = A | B | R
 
 data Ty = IntTy | BoolTy
 
-RegState : Type
-RegState = (Ty, Ty, Ty)
+TypeState : Type
+TypeState = (Ty, Ty, Ty)
 
-getRegTy : Reg -> RegState -> Ty
+getRegTy : Reg -> TypeState -> Ty
 getRegTy A (a, _, _) = a
 getRegTy B (_, b, _) = b
 getRegTy R (_, _, r) = r
 
-setRegTy : Reg -> Ty -> RegState -> RegState
+setRegTy : Reg -> Ty -> TypeState -> TypeState
 setRegTy A a (_, b, r) = (a, b, r)
 setRegTy B b (a, _, r) = (a, b, r)
 setRegTy R r (a, b, _) = (a, b, r)
 
-data Expr : RegState -> Ty -> Type where
+data Expr : TypeState -> Ty -> Type where
   Lit : Int -> Expr s IntTy
   Load : (r : Reg) -> Expr s (getRegTy r s)
   Add : Expr s IntTy -> Expr s IntTy -> Expr s IntTy
@@ -23,17 +23,17 @@ data Expr : RegState -> Ty -> Type where
   Not : Expr s BoolTy -> Expr s BoolTy
 
 mutual
-  data Stmt : RegState -> RegState -> RegState -> Type where
+  data Stmt : TypeState -> TypeState -> TypeState -> Type where
     Store : (r : Reg) -> Expr s t -> Stmt l s (setRegTy r t s)
     If : Expr s BoolTy -> Prog l s n -> Prog l s n -> Stmt l s n
     Loop : Prog s s s -> Stmt l s s
     Break : Stmt s s s
 
-  data Prog : RegState -> RegState -> RegState -> Type where
+  data Prog : TypeState -> TypeState -> TypeState -> Type where
     Nil : Prog l s s
     (::) : Stmt l s n -> Prog l n m -> Prog l s m
 
-initialState : RegState
+initialState : TypeState
 initialState = (IntTy, IntTy, IntTy)
 
 testProg : Prog Main.initialState Main.initialState Main.initialState
@@ -64,7 +64,7 @@ repr : Ty -> Type
 repr IntTy = Int
 repr BoolTy = Bool
 
-data State : RegState -> Type where
+data State : TypeState -> Type where
   MkState : (repr a, repr b, repr c) -> State (a, b, c)
 
 getReg : (r : Reg) -> State s -> repr (getRegTy r s)
@@ -97,3 +97,6 @@ mutual
   prog : Prog l s n -> State s -> Either (State l) (State n)
   prog Nil s = Right s
   prog (st::p) s = stmt st s >>= prog p
+
+run : Prog l s l -> State s -> State l
+run p s = either id id $ prog p s