Fix traversable typeChecking

field/TinyLang/Field/Core.hs

@@ -9,11 +9,11 @@ import           GHC.Generics
 import           Quiet
 
 -- | Basic wrapper of statements
-newtype Statements stmt f = Statements { unStatements :: [stmt f] }
-    deriving (Generic, Eq)
-    deriving (Show) via (Quiet (Statements stmt f))
+newtype Statements stmt = Statements { unStatements :: [stmt] }
+    deriving (Generic, Eq, Functor, Foldable, Traversable)
+    deriving (Show) via (Quiet (Statements stmt))
 
 -- | Basic wrapper of program
-newtype Program stmt f = Program { unProgram :: (Statements stmt f) }
-    deriving (Generic, Eq)
-    deriving (Show) via (Quiet (Program stmt f))
+newtype Program stmt = Program { unProgram :: (Statements stmt) }
+    deriving (Generic, Eq, Functor, Foldable, Traversable)
+    deriving (Show) via (Quiet (Program stmt))

field/TinyLang/Field/Raw/Core.hs

@@ -50,8 +50,8 @@ statement level; the operations acting on statement level are not necessarily
 mappable over a list of statements.
 -}
 
-type Program v = C.Program (Statement v)
-type Statements v = C.Statements (Statement v)
+type Program v f    = C.Program    (Statement v f)
+type Statements v f = C.Statements (Statement v f)
 
 mkProgram :: Statements v f -> Program v f
 mkProgram = C.Program
@@ -106,7 +106,7 @@ data UnOp
 
 {-| = Utility Type Aliases
 -}
-type RawProgram    = Program Var
-type RawStatements = Statements Var
-type RawStatement  = Statement Var
-type RawExpr       = Expr Var
+type RawProgram    f = Program Var f
+type RawStatements f = Statements Var f
+type RawStatement  f = Statement Var f
+type RawExpr       f = Expr Var f

field/TinyLang/Field/Typed/Core.hs

@@ -93,8 +93,8 @@ data BinOp f a b c where
     BAt :: BinOp f (AField f) (Vector Bool) Bool
 
 
-type Program = C.Program Statement
-type Statements = C.Statements Statement
+type Program    f = C.Program    (Statement f)
+type Statements f = C.Statements (Statement f)
 
 mkProgram :: Statements f -> Program f
 mkProgram = C.Program

field/TinyLang/Field/Typed/TypeChecker.hs

@@ -223,9 +223,7 @@ checkExpr m = do
 checkProgram
     :: forall m f. (MonadTypeChecker m, TextField f)
     => R.Program R.Var f -> m (T.Program f)
-checkProgram =
-    -- fmap (T.mkProgram . T.mkStatements) . mapM checkStatement . R.unStatements .  R.unProgram
-    traverse checkStatement
+checkProgram = traverse checkStatement
 
 
 {-| Type checking judgement for statements of form