Interpreter.hs

diff --git a/.stack-work/install/x86_64-linux/8cdb7c01c61379baa5b2837611a8d2fb3f850d1861b2491d8477dd76d5414e84/8.8.4/bin/lang-exe b/.stack-work/install/x86_64-linux/8cdb7c01c61379baa5b2837611a8d2fb3f850d1861b2491d8477dd76d5414e84/8.8.4/bin/lang-exe
index e2a2032..b8af926 100644
Binary files a/.stack-work/install/x86_64-linux/8cdb7c01c61379baa5b2837611a8d2fb3f850d1861b2491d8477dd76d5414e84/8.8.4/bin/lang-exe and b/.stack-work/install/x86_64-linux/8cdb7c01c61379baa5b2837611a8d2fb3f850d1861b2491d8477dd76d5414e84/8.8.4/bin/lang-exe differ
diff --git a/.stack-work/install/x86_64-linux/8cdb7c01c61379baa5b2837611a8d2fb3f850d1861b2491d8477dd76d5414e84/8.8.4/lib/x86_64-linux-ghc-8.8.4/lang-0.1.0.0-I6GnE3ne2ULBziaMLhbHDe/libHSlang-0.1.0.0-I6GnE3ne2ULBziaMLhbHDe.a b/.stack-work/install/x86_64-linux/8cdb7c01c61379baa5b2837611a8d2fb3f850d1861b2491d8477dd76d5414e84/8.8.4/lib/x86_64-linux-ghc-8.8.4/lang-0.1.0.0-I6GnE3ne2ULBziaMLhbHDe/libHSlang-0.1.0.0-I6GnE3ne2ULBziaMLhbHDe.a
index a805323..49f0720 100644
Binary files a/.stack-work/install/x86_64-linux/8cdb7c01c61379baa5b2837611a8d2fb3f850d1861b2491d8477dd76d5414e84/8.8.4/lib/x86_64-linux-ghc-8.8.4/lang-0.1.0.0-I6GnE3ne2ULBziaMLhbHDe/libHSlang-0.1.0.0-I6GnE3ne2ULBziaMLhbHDe.a and b/.stack-work/install/x86_64-linux/8cdb7c01c61379baa5b2837611a8d2fb3f850d1861b2491d8477dd76d5414e84/8.8.4/lib/x86_64-linux-ghc-8.8.4/lang-0.1.0.0-I6GnE3ne2ULBziaMLhbHDe/libHSlang-0.1.0.0-I6GnE3ne2ULBziaMLhbHDe.a differ
diff --git a/.stack-work/install/x86_64-linux/8cdb7c01c61379baa5b2837611a8d2fb3f850d1861b2491d8477dd76d5414e84/8.8.4/lib/x86_64-linux-ghc-8.8.4/libHSlang-0.1.0.0-I6GnE3ne2ULBziaMLhbHDe-ghc8.8.4.so b/.stack-work/install/x86_64-linux/8cdb7c01c61379baa5b2837611a8d2fb3f850d1861b2491d8477dd76d5414e84/8.8.4/lib/x86_64-linux-ghc-8.8.4/libHSlang-0.1.0.0-I6GnE3ne2ULBziaMLhbHDe-ghc8.8.4.so
index 382a918..3975808 100644
Binary files a/.stack-work/install/x86_64-linux/8cdb7c01c61379baa5b2837611a8d2fb3f850d1861b2491d8477dd76d5414e84/8.8.4/lib/x86_64-linux-ghc-8.8.4/libHSlang-0.1.0.0-I6GnE3ne2ULBziaMLhbHDe-ghc8.8.4.so and b/.stack-work/install/x86_64-linux/8cdb7c01c61379baa5b2837611a8d2fb3f850d1861b2491d8477dd76d5414e84/8.8.4/lib/x86_64-linux-ghc-8.8.4/libHSlang-0.1.0.0-I6GnE3ne2ULBziaMLhbHDe-ghc8.8.4.so differ
diff --git a/.stack-work/install/x86_64-linux/8cdb7c01c61379baa5b2837611a8d2fb3f850d1861b2491d8477dd76d5414e84/8.8.4/pkgdb/lang-0.1.0.0-I6GnE3ne2ULBziaMLhbHDe.conf b/.stack-work/install/x86_64-linux/8cdb7c01c61379baa5b2837611a8d2fb3f850d1861b2491d8477dd76d5414e84/8.8.4/pkgdb/lang-0.1.0.0-I6GnE3ne2ULBziaMLhbHDe.conf
deleted file mode 100644
index c82affd..0000000
--- a/.stack-work/install/x86_64-linux/8cdb7c01c61379baa5b2837611a8d2fb3f850d1861b2491d8477dd76d5414e84/8.8.4/pkgdb/lang-0.1.0.0-I6GnE3ne2ULBziaMLhbHDe.conf
+++ /dev/null
@@ -1,41 +0,0 @@
-name:                 lang
-version:              0.1.0.0
-visibility:           public
-id:                   lang-0.1.0.0-I6GnE3ne2ULBziaMLhbHDe
-key:                  lang-0.1.0.0-I6GnE3ne2ULBziaMLhbHDe
-license:              BSD-3-Clause
-copyright:            2021 Author name here
-maintainer:           example@example.com
-author:               Author name here
-homepage:             https://github.com/githubuser/lang#readme
-description:
-    Please see the README on GitHub at <https://github.com/githubuser/lang#readme>
-
-abi:                  731721d47cc135454cbfaf15efa2bf0c
-exposed:              True
-exposed-modules:
-    CCExc CState Environment FunParser FunSyntax Interpreter Parsing
-
-hidden-modules:       Paths_lang
-import-dirs:
-    "/mnt/c/Users/Blade/Documents/OxCS/4th Year Proj/concurrent-fp/.stack-work/install/x86_64-linux/8cdb7c01c61379baa5b2837611a8d2fb3f850d1861b2491d8477dd76d5414e84/8.8.4/lib/x86_64-linux-ghc-8.8.4/lang-0.1.0.0-I6GnE3ne2ULBziaMLhbHDe"
-
-library-dirs:
-    "/mnt/c/Users/Blade/Documents/OxCS/4th Year Proj/concurrent-fp/.stack-work/install/x86_64-linux/8cdb7c01c61379baa5b2837611a8d2fb3f850d1861b2491d8477dd76d5414e84/8.8.4/lib/x86_64-linux-ghc-8.8.4/lang-0.1.0.0-I6GnE3ne2ULBziaMLhbHDe"
-
-dynamic-library-dirs:
-    "/mnt/c/Users/Blade/Documents/OxCS/4th Year Proj/concurrent-fp/.stack-work/install/x86_64-linux/8cdb7c01c61379baa5b2837611a8d2fb3f850d1861b2491d8477dd76d5414e84/8.8.4/lib/x86_64-linux-ghc-8.8.4"
-
-data-dir:
-    "/mnt/c/Users/Blade/Documents/OxCS/4th Year Proj/concurrent-fp/.stack-work/install/x86_64-linux/8cdb7c01c61379baa5b2837611a8d2fb3f850d1861b2491d8477dd76d5414e84/8.8.4/share/x86_64-linux-ghc-8.8.4/lang-0.1.0.0"
-
-hs-libraries:         HSlang-0.1.0.0-I6GnE3ne2ULBziaMLhbHDe
-depends:
-    CC-delcont-0.2.1.0-7oCrSV9gweO1ar9PQ3I6Vp base-4.13.0.0
-    containers-0.6.2.1 mtl-2.2.2 unix-2.7.2.2
-
-haddock-interfaces:
-    "/mnt/c/Users/Blade/Documents/OxCS/4th Year Proj/concurrent-fp/.stack-work/install/x86_64-linux/8cdb7c01c61379baa5b2837611a8d2fb3f850d1861b2491d8477dd76d5414e84/8.8.4/doc/lang-0.1.0.0/lang.haddock"
-
-haddock-html:
-    "/mnt/c/Users/Blade/Documents/OxCS/4th Year Proj/concurrent-fp/.stack-work/install/x86_64-linux/8cdb7c01c61379baa5b2837611a8d2fb3f850d1861b2491d8477dd76d5414e84/8.8.4/doc/lang-0.1.0.0"
diff --git a/.stack-work/install/x86_64-linux/8cdb7c01c61379baa5b2837611a8d2fb3f850d1861b2491d8477dd76d5414e84/8.8.4/pkgdb/package.cache b/.stack-work/install/x86_64-linux/8cdb7c01c61379baa5b2837611a8d2fb3f850d1861b2491d8477dd76d5414e84/8.8.4/pkgdb/package.cache
index d569be4..b3cae5c 100644
Binary files a/.stack-work/install/x86_64-linux/8cdb7c01c61379baa5b2837611a8d2fb3f850d1861b2491d8477dd76d5414e84/8.8.4/pkgdb/package.cache and b/.stack-work/install/x86_64-linux/8cdb7c01c61379baa5b2837611a8d2fb3f850d1861b2491d8477dd76d5414e84/8.8.4/pkgdb/package.cache differ
diff --git a/.stack-work/stack.sqlite3 b/.stack-work/stack.sqlite3
index aafafa5..78fea72 100644
Binary files a/.stack-work/stack.sqlite3 and b/.stack-work/stack.sqlite3 differ
diff --git a/lang/app/Main.hs b/lang/app/Main.hs
index 342da27..ade1761 100644
--- a/lang/app/Main.hs
+++ b/lang/app/Main.hs
@@ -6,4 +6,4 @@ import FunParser
 import Parsing
 
 main :: IO ()
-main = dialog funParser obey (init_env, init_cst)
+main = putStr "32" --dialog funParser obey (init_env, init_cst)
diff --git a/lang/lang.cabal b/lang/lang.cabal
index 696f75c..822a88f 100644
--- a/lang/lang.cabal
+++ b/lang/lang.cabal
@@ -39,7 +39,8 @@ library
   hs-source-dirs:
       src
   build-depends:
-      CC-delcont
+      fclabels
+    , lens
     , base >=4.7 && <5
     , containers
     , mtl
@@ -54,7 +55,7 @@ executable lang-exe
       app
   ghc-options: -threaded -rtsopts -with-rtsopts=-N
   build-depends:
-      CC-delcont
+      fclabels
     , base >=4.7 && <5
     , containers
     , lang
diff --git a/lang/package.yaml b/lang/package.yaml
index 3c943f7..1629635 100644
--- a/lang/package.yaml
+++ b/lang/package.yaml
@@ -23,9 +23,10 @@ dependencies:
 - base >= 4.7 && < 5
 - containers
 - unix
-- CC-delcont >= 0
+- fclabels > 2
 - mtl
 
+
 library:
   source-dirs: src
 
diff --git a/lang/src/Interpreter.hs b/lang/src/Interpreter.hs
index 537066d..0a0ec5a 100644
--- a/lang/src/Interpreter.hs
+++ b/lang/src/Interpreter.hs
@@ -1,8 +1,9 @@
 {- 
   Monadic definitional interpreter.
 -}
+{-# LANGUAGE TemplateHaskell, TypeOperators #-}
 
-module Interpreter(obey, init_cst, init_env) where
+module Interpreter({-obey, init_GlobState, init_env-}) where
 
 import Parsing
 import FunSyntax
@@ -11,57 +12,26 @@ import Environment
 import CState
 
 import Data.List (intercalate)
+import Control.Lens
+
+import Data.Label
+import Data.Label.Monadic
 
 import Control.Monad
+import Control.Monad.State
 import Control.Monad.Trans (lift)
 import CCExc
 
 import Debug.Trace
 
--- TODO: A more algebraic approach, to allow easy combination of ``pure"
---       algebraic effects (i.e. create a class for state as a first step)
-
------ State monad -----
-newtype State s a = State { runS :: s -> (a, s) }
-
-instance Monad (State s) where
-  return a = State $ \s -> (a, s)
-  (State sm) >>= f = State $ \s -> 
-    let (a, newS) = sm s
-        (State rs) = f a 
-    in rs newS
-
-instance Functor (State s) where
-  fmap f (State m) = State $ \s -> 
-    let (a, newS) = m s
-    in (f a, newS)
-
-instance Applicative (State s) where
-  pure = return
-
-instance MonadFail (State s) where
-  fail = error "state matching failed"
-
------ Operations for the state monad -----
-get :: ChanID -> State CST (CType Value (Kont Value))
-get l = State $ \(CST chs) -> (contents chs l, CST chs)
-
-put :: ChanID -> CType Value (Kont Value) -> State CST ()
-put l ct = State $ \(CST chs) -> ((), CST $ update chs l ct)
-
-new :: State CST ChanID
-new = State $ \(CST chs) -> let (l, chs') = fresh chs in (l, CST chs')
-
 ----- Helper types -----
-type Env       = Environment Value
-
-newtype CST    = CST (ChanState Value (Kont Value))
+type Env          = Environment Value
 
-type Kont      = CC PromptT (State CST)
-type PromptT   = P2 Value Value
-type ProgState = (Env, CST)
-type Arg       = String
-type Name      = String
+type Kont         = CC PromptT (State GlobState)
+type PromptT      = P2 Value Value
+type ProgState    = (Env, GlobState)
+type Arg          = String
+type Name         = String
 
 -- Patterns in our language are Expressions themselves; see the comment
 -- for the `matchPat' function
@@ -81,9 +51,28 @@ data Value =
   -- Below we have denotable but not expressible values
   | Resume (Kont Value)
   | Halted ChanID
-  | Waiting ChanID              
+  | Waiting ChanID     
+
+----- State and its labels (lenses) -----
+data GlobState = GlobState { _cst   :: ChanState Value (Kont Value), 
+                             _sched :: Int}
+
+-- TH creates some labels for us
+mkLabel ''GlobState
+
+----- Operations for the state monad -----  
+getCh :: ChanID -> State GlobState (CType Value (Kont Value))
+getCh l = do cs <- Data.Label.Monadic.gets cst
+             return (contents cs l) 
 
+modifyCh :: ChanID -> CType Value (Kont Value) -> State GlobState ()
+modifyCh l ct = Data.Label.Monadic.modify cst (\gs -> update gs l ct)
 
+putCh :: State GlobState ChanID
+putCh = do cs <- Data.Label.Monadic.gets
+           return 
+           
+         
 ----- Some useful instances -----
 instance Eq Value where
   IntVal a == IntVal b         = a == b
@@ -110,294 +99,294 @@ instance Show Value where
 
 ---------------------------- Start of evaluator ----------------------------
 
-eval :: Expr -> Env -> Kont Value
-
------ Basics -----
-eval (Number n) _ = return (IntVal n)
-
-eval (Variable v) env = return (find env v)
-
-eval (Apply f e) env = 
-  do Closure id env' body <- eval f env
-     v                    <- eval e env
-     eval body (define env' id v)
-
-eval (If cond et ef) env =
-  do cond <- eval cond env  
-     case cond of
-       BoolVal True -> eval et env
-       BoolVal False -> eval ef env
-       _ -> error "Boolean required in conditional"
-
-eval (Lambda x e1) env = return $ Closure x env e1
-
-eval (Pipe e1 e2) env = 
-  do eval e1 env -- we discard the first expression's result
-     eval e2 env
-
-eval (Let d e1) env =
-  do env' <- elab d env 
-     eval e1 env'
-
------ Pattern matching -----
-eval (Injector name args) env = 
-  do vs <- values evs 
-     return $ Injection name vs
-  where evs = map (`eval` env) args
-
-eval (Match ex pats) env = 
-  do v <- eval ex env 
-     case matchpat v pats env of
-       Just (pex, env') -> eval pex env'
-       Nothing          -> return $ Injection "ExcMatch" []
-
------ Concurrency -----
-eval (Send ce ve) env =
-  do v <- eval (SendP ce ve) env
-     case v of 
-       Exception _ -> shift pX $ \_ -> return v
-       _           -> return v
-
-eval (SendP ce ve) env = 
-  shift pP$ \rest -> 
-  do 
-    ChanHandle l <- eval ce env 
-    v <- eval ve env 
-    sus <- lift $ -- descend to the state monad, to see if we suspend or not
-      get l >>= \ chanState -> 
-        -- based on the state, we decide what the next state is
-        case chanState of 
-          Empty -> 
-            do put l (WR v rest)
-               return $ Halted l
-          Ready res _ -> 
-            do put l $ Ready res (WR v rest)
-               return $ Halted l
-          WW rk -> 
-            do put l $ Ready (rk v) Empty
-               return $ Resume (rest Unit)
-          Closed -> 
-            return (Resume $ rest (Exception $ Injection "ExcClosed" []))
-    case sus of 
-      Resume res -> res              -- resume execution, no scheduler involved
-      Halted init_cst -> return sus  -- return to scheduler
-
--- The code for Receive is almost identical to the one for Send
-eval (Receive ce) env =
-  do v <- eval (ReceiveP ce) env
-     case v of 
-       Exception _ -> (shift pX $ \_ -> return v)
-       _           -> return v
-
-eval (ReceiveP ce) env = 
-  shift pP$ \rest ->
-  do 
-    ChanHandle l <- eval ce env
-    sus <- lift $ 
-      get l >>= \ chanState -> 
-        case chanState of 
-          Empty -> 
-            do put l (WW rest)
-               return $ Halted l
-          Ready res _ -> 
-            do put l $ Ready res (WW rest)
-               return $ Halted l
-          WR v sk -> 
-            do put l (Ready (sk Unit) Empty) 
-               return (Resume $ rest v)
-          Closed -> 
-            return (Resume $ rest (Exception $ Injection "ExcClosed" []))
-    case sus of 
-      Resume res -> res 
-      Halted _ -> return sus 
-
-eval (Parallel cs) env = scheduler (components, []) 0
-  where components = map (`createComponent` env) cs
-        createComponent c env = pushPrompt pP (eval c env)
-
-eval NewChan env = 
-  lift $  
-  do l <- new 
-     put l Empty
-     return $ ChanHandle l
-
-eval (Close c) env = 
-  do
-    ChanHandle l <- eval c env
-    lift $ 
-      get l >>= \ chanState -> case chanState of 
-        Empty        -> put l Closed
-        Closed       -> error "already closed"
-        Ready res _  -> put l (Ready res Closed)
-        WR _ wk      -> put l (Ready (wk (Exception (Injection "ExcClosed" [])))
-                                     Closed)
-        WW rk        -> put l (Ready (rk (Exception (Injection "ExcClosed" [])))
-                                     Closed)
-    return Unit
-
------ Exception handling -----
-eval (TryCatch ex pats) env =   
-  do 
-    -- First we delimit the context in which we evaluate the expression. If 
-    -- we end in an error, we essentially discard this computation, since we 
-    -- discard everything up to the closest `px' prompt.
-    val <- pushPrompt pX (eval ex env)
-    -- Check whether we have ended with an exception or not.
-    case val of
-      Exception e -> case matchpat e pats env of
-                      Just (pex, env') -> eval pex env'
-                      -- If no handler handles our error, propagate
-                      Nothing          -> shift pX $ \_ -> return $ Exception e
-      _           -> return val -- No error, so just return the value.
+-- eval :: Expr -> Env -> Kont Value
+
+-- ----- Basics -----
+-- eval (Number n) _ = return (IntVal n)
+
+-- eval (Variable v) env = return (find env v)
+
+-- eval (Apply f e) env = 
+--   do Closure id env' body <- eval f env
+--      v                    <- eval e env
+--      eval body (define env' id v)
+
+-- eval (If cond et ef) env =
+--   do cond <- eval cond env  
+--      case cond of
+--        BoolVal True -> eval et env
+--        BoolVal False -> eval ef env
+--        _ -> error "Boolean required in conditional"
+
+-- eval (Lambda x e1) env = return $ Closure x env e1
+
+-- eval (Pipe e1 e2) env = 
+--   do eval e1 env -- we discard the first expression's result
+--      eval e2 env
+
+-- eval (Let d e1) env =
+--   do env' <- elab d env 
+--      eval e1 env'
+
+-- ----- Pattern matching -----
+-- eval (Injector name args) env = 
+--   do vs <- values evs 
+--      return $ Injection name vs
+--   where evs = map (`eval` env) args
+
+-- eval (Match ex cases) env = 
+--   do v <- eval ex env 
+--      case matchpat v cases env of
+--        Just (pex, env') -> eval pex env'
+--        Nothing          -> return $ Injection "ExcMatch" []
+
+-- ----- Concurrency -----
+-- eval (Send ce ve) env =
+--   do v <- eval (SendP ce ve) env
+--      case v of 
+--        Exception _ -> shift pX $ \_ -> return v
+--        _           -> return v
+
+-- eval (SendP ce ve) env = 
+--   shift pP$ \rest -> 
+--   do 
+--     ChanHandle l <- eval ce env 
+--     v <- eval ve env 
+--     sus <- lift $ -- descend to the state monad, to see if we suspend or not
+--       getCh l >>= \ chanState -> 
+--         -- based on the state, we decide what the next state is
+--         case chanState of 
+--           Empty -> 
+--             do putCh l (WR v rest)
+--                return $ Halted l
+--           Ready res _ -> 
+--             do putCh l $ Ready res (WR v rest)
+--                return $ Halted l
+--           WW rk -> 
+--             do putCh l $ Ready (rk v) Empty
+--                return $ Resume (rest Unit)
+--           Closed -> 
+--             return (Resume $ rest (Exception $ Injection "ExcClosed" []))
+--     case sus of 
+--       Resume res -> res              -- resume execution, no scheduler involved
+--       Halted _   -> return sus       -- return to scheduler
+
+-- -- The code for Receive is almost identical to the one for Send
+-- eval (Receive ce) env =
+--   do v <- eval (ReceiveP ce) env
+--      case v of 
+--        Exception _ -> (shift pX $ \_ -> return v)
+--        _           -> return v
+
+-- eval (ReceiveP ce) env = 
+--   shift pP$ \rest ->
+--   do 
+--     ChanHandle l <- eval ce env
+--     sus <- lift $ 
+--       getCh l >>= \ chanState -> 
+--         case chanState of 
+--           Empty -> 
+--             do putCh l (WW rest)
+--                return $ Halted l
+--           Ready res _ -> 
+--             do putCh l $ Ready res (WW rest)
+--                return $ Halted l
+--           WR v sk -> 
+--             do putCh l (Ready (sk Unit) Empty) 
+--                return (Resume $ rest v)
+--           Closed -> 
+--             return (Resume $ rest (Exception $ Injection "ExcClosed" []))
+--     case sus of 
+--       Resume res -> res 
+--       Halted _ -> return sus 
+
+-- eval (Parallel cs) env = scheduler (components, []) 0
+--   where components = map (`createComponent` env) cs
+--         createComponent c env = pushPrompt pP (eval c env)
+
+-- eval NewChan env = 
+--   lift $  
+--   do l <- newCh 
+--      putCh l Empty
+--      return $ ChanHandle l
+
+-- eval (Close c) env = 
+--   do
+--     ChanHandle l <- eval c env
+--     lift $ 
+--       getCh l >>= \ chanState -> case chanState of 
+--         Empty        -> putCh l Closed
+--         Closed       -> error "already closed"
+--         Ready res _  -> putCh l (Ready res Closed)
+--         WR _ wk      -> putCh l (Ready (wk (Exception (Injection "ExcClosed" [])))
+--                                      Closed)
+--         WW rk        -> putCh l (Ready (rk (Exception (Injection "ExcClosed" [])))
+--                                      Closed)
+--     return Unit
+
+-- ----- Exception handling -----
+-- eval (TryCatch ex pats) env =   
+--   do 
+--     -- First we delimit the context in which we evaluate the expression. If 
+--     -- we end in an error, we essentially discard this computation, since we 
+--     -- discard everything up to the closest `px' prompt.
+--     val <- pushPrompt pX (eval ex env)
+--     -- Check whether we have ended with an exception or not.
+--     case val of
+--       Exception e -> case matchpat e pats env of
+--                       Just (pex, env') -> eval pex env'
+--                       -- If no handler handles our error, propagate
+--                       Nothing          -> shift pX $ \_ -> return $ Exception e
+--       _           -> return val -- No error, so just return the value.
     
-eval (Throw th) env = 
-  shift pX $ \_ ->
-  do v <- eval th env 
-     case v of
-       Injection n vs -> return $ Exception v
-       _              -> error "Must throw a sum type"
-
------ Primitive operations -----
-eval (BinPrim bop e1 e2) env = case bop of
-  Plus -> arithmeticBOP (+) e1 e2 env
-  Minus -> arithmeticBOP (-) e1 e2 env
-  Times -> arithmeticBOP (*) e1 e2 env
-  Div -> arithmeticBOP (div) e1 e2 env
-  Mod -> arithmeticBOP (mod) e1 e2 env
-  And -> logicBOP (&&) e1 e2 env
-  Or -> logicBOP (||) e1 e2 env
-  Equal -> do v1 <- eval e1 env 
-              v2 <- eval e2 env 
-              return $ BoolVal (v1 == v2)
-
-eval (MonPrim mop e) env = 
-  case mop of
-    Neg -> 
-      do IntVal n <- eval e env 
-         return $ IntVal (-n)
-
--- Helper functions that abstract the pattern of evaluation for 
--- binary primitive operations
-arithmeticBOP :: (Integer -> Integer -> Integer) -> 
-                 Expr -> Expr -> Env -> Kont Value
-arithmeticBOP op e1 e2 env = 
-  do IntVal n1 <- eval e1 env 
-     IntVal n2 <- eval e2 env  
-     return $ IntVal (op n1 n2)
-
-logicBOP :: (Bool -> Bool -> Bool) -> 
-            Expr -> Expr -> Env -> Kont Value
-logicBOP funcop e1 e2 env = 
-  do BoolVal b1 <- eval e1 env 
-     BoolVal b2 <- eval e2 env 
-     return $ BoolVal (funcop b1 b2)
-
------ Environment expansion -----
-elab :: Defn -> Env -> Kont Env
-elab (Val x e) env =
-  do v <- eval e env 
-     return (define env x v)
-elab (Rec x e) env =
-  case e of
-    Lambda fp body -> return env' 
-      where env' = define env x (Closure fp env' body)
-    _ -> error "RHS of letrec must be a lambda"
-elab (Data _ ctors) env = foldM (\ env' cdef -> elab cdef env') env ctors
-
------ Scheduler -----
-scheduler :: ([Kont Value], [Kont Value]) -> Int -> Kont Value
-scheduler ([], rs) w = if w == 0 
-                       then 
-                        do vs <- values rs
-                           return $ Tuple (reverse vs)
-                       else scheduler (reverse rs, []) w
-scheduler ((k:ks), rs) w = k >>= (\v -> case v of 
-    Halted l     -> scheduler (ks, (return $ Waiting l):rs) (w + 1)
-    Waiting l    -> lift (get l >>= (\cst -> case cst of 
-                      Ready sk next -> put l next >>= (\() -> return $ Left sk)
-                      _             -> return $ Right (return $ Waiting l)
-                    )) >>= (\val -> case val of 
-                      Left r -> scheduler ((r:ks), rs) (w - 1)
-                      Right r -> scheduler (ks, (r:rs)) w
-                    )
-    v            -> scheduler (ks, (return v:rs)) w
-  )
-
------ Helpers -----
-values :: [Kont Value] -> Kont [Value]
-values [] = return []
-values (c:cvs) = 
-  do v <- c 
-     vs <- values cvs 
-     return (v:vs)
-
--- TODO: Fix no error when undefined exception because of lazyness
--- Expr for the following two functions is a pattern (leaves are variables)
--- Note: while Pattern in the signatures below is a type synonym for Expr, 
--- we require that it is restricted to `Variable' and `Apply ...', where the
--- `Apply' would yield an injection. This could have been handled in a 
--- cleaner manner, but for ease of understanding we have imposed this 
--- "soft" restriction.  
-matchpat :: Value -> [Pattern] -> Env -> Maybe (Expr, Env)
-matchpat v [] env = Nothing
-matchpat v ((Case pat ex):ps) env = 
-  case (trymatch v pat env) of
-    Just env' -> Just (ex, env')
-    Nothing   -> matchpat v ps env
-
--- The following two mutually recursive functions try
--- to recursively match patterns, so we can match arbitrary 
--- deep patterns
-trymatch :: Value -> Pattern -> Env -> Maybe Env
-trymatch v (Variable i) env = Just $ define env i v
-trymatch (Injection n vs) pat env =
-    if n == n' 
-    then accumBindings vs ps env
-    else Nothing
-  where 
-    -- We transform the application to an injection for ease
-    Injector n' ps = appToInj pat [] 
-trymatch a b _ = error $ show a ++ show b
-
-accumBindings :: [Value] -> [Pattern] -> Env -> Maybe Env
-accumBindings [] [] env = Just env
-accumBindings (v:vs) (p:ps) env = case trymatch v p env of
-  Just env' -> accumBindings vs ps env'
-  Nothing   -> Nothing 
-
--- Helper function that 
-appToInj :: Expr -> [Expr] -> Expr
-appToInj (Apply (Variable v) x) ps = Injector v (x:ps)
-appToInj (Apply x y) ps = appToInj x (y:ps)
-
----------------------------- End of evaluator ----------------------------
-
--- Initial environment, which only exposes primitive data
--- We deal with primitive operations during parsing, by converting them into
--- non-application expressions, similar to OCaml
-init_env :: Env
-init_env =
-  make_env [
-    -- some primitive data 
-    ("true", BoolVal True), 
-    ("false", BoolVal False),
-    ("unit", Unit),
-    -- some primitive exceptions
-    ("ExcClosed", Injection "ExcClosed" []),
-    ("ExcInvalid", Injection "ExcInvalid" []),
-    ("ExcMatch", Injection "ExcMatch" [])]
-
-init_cst :: CST
-init_cst = CST empty_cst  
-
--- Deal with top-state exprs and defs. Observe the nice compositionality: 
--- first run the (continuation) computation to produce a state computation,
--- which when ran produces the new state, together with the desired result.
-obey :: Phrase -> ProgState -> (String, ProgState)
-obey (Calculate exp) (env, mem) =
-  let (v, mem') = (runS . runCC) (pushPrompt pX (eval exp env)) mem in 
-  (show v, (env, mem'))
-obey (Define def) (env, mem) =
-  let x = def_lhs def in
-  let (env', mem') = (runS . runCC) (elab def env) mem in 
-  ("Added definition: " ++ x, (env', mem'))
+-- eval (Throw th) env = 
+--   shift pX $ \_ ->
+--   do v <- eval th env 
+--      case v of
+--        Injection n vs -> return $ Exception v
+--        _              -> error "Must throw a sum type"
+
+-- ----- Primitive operations -----
+-- eval (BinPrim bop e1 e2) env = case bop of
+--   Plus -> arithmeticBOP (+) e1 e2 env
+--   Minus -> arithmeticBOP (-) e1 e2 env
+--   Times -> arithmeticBOP (*) e1 e2 env
+--   Div -> arithmeticBOP (div) e1 e2 env
+--   Mod -> arithmeticBOP (mod) e1 e2 env
+--   And -> logicBOP (&&) e1 e2 env
+--   Or -> logicBOP (||) e1 e2 env
+--   Equal -> do v1 <- eval e1 env 
+--               v2 <- eval e2 env 
+--               return $ BoolVal (v1 == v2)
+
+-- eval (MonPrim mop e) env = 
+--   case mop of
+--     Neg -> 
+--       do IntVal n <- eval e env 
+--          return $ IntVal (-n)
+
+-- -- Helper functions that abstract the pattern of evaluation for 
+-- -- binary primitive operations
+-- arithmeticBOP :: (Integer -> Integer -> Integer) -> 
+--                  Expr -> Expr -> Env -> Kont Value
+-- arithmeticBOP op e1 e2 env = 
+--   do IntVal n1 <- eval e1 env 
+--      IntVal n2 <- eval e2 env  
+--      return $ IntVal (op n1 n2)
+
+-- logicBOP :: (Bool -> Bool -> Bool) -> 
+--             Expr -> Expr -> Env -> Kont Value
+-- logicBOP funcop e1 e2 env = 
+--   do BoolVal b1 <- eval e1 env 
+--      BoolVal b2 <- eval e2 env 
+--      return $ BoolVal (funcop b1 b2)
+
+-- ----- Environment expansion -----
+-- elab :: Defn -> Env -> Kont Env
+-- elab (Val x e) env =
+--   do v <- eval e env 
+--      return (define env x v)
+-- elab (Rec x e) env =
+--   case e of
+--     Lambda fp body -> return env' 
+--       where env' = define env x (Closure fp env' body)
+--     _ -> error "RHS of letrec must be a lambda"
+-- elab (Data _ ctors) env = foldM (\ env' cdef -> elab cdef env') env ctors
+
+-- ----- Scheduler -----
+-- scheduler :: ([Kont Value], [Kont Value]) -> Int -> Kont Value
+-- scheduler ([], rs) w = if w == 0 
+--                        then 
+--                          do vs <- values rs
+--                             return $ Tuple (reverse vs)
+--                        else scheduler (reverse rs, []) w
+-- scheduler ((k:ks), rs) w = k >>= (\v -> case v of 
+--     Halted l     -> scheduler (ks, (return $ Waiting l):rs) (w + 1)
+--     Waiting l    -> lift (getCh l >>= (\GlobState -> case GlobState of 
+--                       Ready sk next -> putCh l next >>= (\() -> return $ Left sk)
+--                       _             -> return $ Right (return $ Waiting l)
+--                     )) >>= (\val -> case val of 
+--                       Left r -> scheduler ((r:ks), rs) (w - 1)
+--                       Right r -> scheduler (ks, (r:rs)) w
+--                     )
+--     v            -> scheduler (ks, (return v:rs)) w
+--   )
+
+-- ----- Helpers -----
+-- values :: [Kont Value] -> Kont [Value]
+-- values [] = return []
+-- values (c:cvs) = 
+--   do v <- c 
+--      vs <- values cvs 
+--      return (v:vs)
+
+-- -- TODO: Fix no error when undefined exception because of lazyness
+-- -- Expr for the following two functions is a pattern (leaves are variables)
+-- -- Note: while Pattern in the signatures below is a type synonym for Expr, 
+-- -- we require that it is restricted to `Variable' and `Apply ...', where the
+-- -- `Apply' would yield an injection. This could have been handled in a 
+-- -- cleaner manner, but for ease of understanding we have imposed this 
+-- -- "soft" restriction.  
+-- matchpat :: Value -> [Pattern] -> Env -> Maybe (Expr, Env)
+-- matchpat v [] env = Nothing
+-- matchpat v ((Case pat ex):ps) env = 
+--   case (trymatch v pat env) of
+--     Just env' -> Just (ex, env')
+--     Nothing   -> matchpat v ps env
+
+-- -- The following two mutually recursive functions try
+-- -- to recursively match patterns, so we can match arbitrary 
+-- -- deep patterns
+-- trymatch :: Value -> Pattern -> Env -> Maybe Env
+-- trymatch v (Variable i) env = Just $ define env i v
+-- trymatch (Injection n vs) pat env =
+--     if n == n' 
+--     then accumBindings vs ps env
+--     else Nothing
+--   where 
+--     -- We transform the application to an injection for ease
+--     Injector n' ps = appToInj pat [] 
+-- trymatch a b _ = error $ show a ++ show b
+
+-- accumBindings :: [Value] -> [Pattern] -> Env -> Maybe Env
+-- accumBindings [] [] env = Just env
+-- accumBindings (v:vs) (p:ps) env = case trymatch v p env of
+--   Just env' -> accumBindings vs ps env'
+--   Nothing   -> Nothing 
+
+-- -- Helper function that 
+-- appToInj :: Expr -> [Expr] -> Expr
+-- appToInj (Apply (Variable v) x) ps = Injector v (x:ps)
+-- appToInj (Apply x y) ps = appToInj x (y:ps)
+
+-- ---------------------------- End of evaluator ----------------------------
+
+-- -- Initial environment, which only exposes primitive data
+-- -- We deal with primitive operations during parsing, by converting them into
+-- -- non-application expressions, similar to OCaml
+-- init_env :: Env
+-- init_env =
+--   make_env [
+--     -- some primitive data 
+--     ("true", BoolVal True), 
+--     ("false", BoolVal False),
+--     ("unit", Unit),
+--     -- some primitive exceptions
+--     ("ExcClosed", Injection "ExcClosed" []),
+--     ("ExcInvalid", Injection "ExcInvalid" []),
+--     ("ExcMatch", Injection "ExcMatch" [])]
+
+-- init_GlobState :: GlobState
+-- init_GlobState = GlobState empty_GlobState  
+
+-- -- Deal with top-state exprs and defs. Observe the nice compositionality: 
+-- -- first run the (continuation) computation to produce a state computation,
+-- -- which when ran produces the new state, together with the desired result.
+-- obey :: Phrase -> ProgState -> (String, ProgState)
+-- obey (Calculate exp) (env, mem) =
+--   let (v, mem') = (runState . runCC) (pushPrompt pX (eval exp env)) mem in 
+--   (show v, (env, mem'))
+-- obey (Define def) (env, mem) =
+--   let x = def_lhs def in
+--   let (env', mem') = (runState . runCC) (elab def env) mem in 
+--   ("Added definition: " ++ x, (env', mem'))
diff --git a/lang/stack.yaml b/lang/stack.yaml
index ddac32b..76e54cd 100644
--- a/lang/stack.yaml
+++ b/lang/stack.yaml
@@ -34,8 +34,8 @@ packages:
 # These entries can reference officially published versions as well as
 # forks / in-progress versions pinned to a git hash. For example:
 #
-# extra-deps:
-# - acme-missiles-0.3
+extra-deps:
+- fclabels-2.0.3.3@sha256:9fc5d1e4466c400710d3a1d59e8cad4e659883da1f56ad4c491c52f9080ef626,4438
 # - git: https://github.com/commercialhaskell/stack.git
 #   commit: e7b331f14bcffb8367cd58fbfc8b40ec7642100a
 #
diff --git a/lang/test/tests b/lang/test/tests
index a05fff8..af25612 100644
--- a/lang/test/tests
+++ b/lang/test/tests
@@ -41,4 +41,28 @@ main;;
 
 ---------- Pattern matching ----------
 data A = B 1 | C 2;;
-match C (B (C 4 3)) 4 with C (C x q) y => x | C (B (C x y)) z => x;;
\ No newline at end of file
+match C (B (C 4 3)) 4 with C (C x q) y => x | C (B (C x y)) z => x;;

+

+

+--- Expected ---

+Added definition: x

+(23,2,unit)

+Added definition: x

+234

+<unhandled exception -> ExcClosed>

+Added definition: x

+<unhandled exception -> ExcClosed>

+Added definition: c

+(5,2,unit)

+Added definition: x

+Added definition: y

+<unhandled exception -> ExcClosed>

+Added definition: x

+Added definition: y

+(unit,2,2)

+Added definition: server

+Added definition: client

+Added definition: main

+(unit,1000)

+Added definition: A

+4
\ No newline at end of file
diff --git a/stack.yaml b/stack.yaml
index 59463e7..d17796f 100644
--- a/stack.yaml
+++ b/stack.yaml
@@ -35,7 +35,7 @@ packages:
 # forks / in-progress versions pinned to a git hash. For example:
 #
 extra-deps:
-- CC-delcont-0.2.1.0@sha256:3791184e55c0f59549443f8dde86131b3479f7eb4b540549aceff6db2b2e3006,2276
+- fclabels-2.0.5@sha256:817006077632bd29e637956154aa33d3c10a59be0791c308cef955eb951b2675,4473
 # - acme-missiles-0.3
 # - git: https://github.com/commercialhaskell/stack.git
 #   commit: e7b331f14bcffb8367cd58fbfc8b40ec7642100a
diff --git a/stack.yaml.lock b/stack.yaml.lock
index f011a77..b1faa6d 100644
--- a/stack.yaml.lock
+++ b/stack.yaml.lock
@@ -5,12 +5,12 @@
 
 packages:
 - completed:
-    hackage: CC-delcont-0.2.1.0@sha256:3791184e55c0f59549443f8dde86131b3479f7eb4b540549aceff6db2b2e3006,2276
+    hackage: fclabels-2.0.5@sha256:817006077632bd29e637956154aa33d3c10a59be0791c308cef955eb951b2675,4473
     pantry-tree:
-      size: 481
-      sha256: 5bd0b5b5318c0ca1707316b138faa323dea5c198ca339d7f00286b50a37cdccb
+      size: 1008
+      sha256: 8a9254b7f80c3586d6e51d35c1355e700c3f9b0b3d8e3ae6e6ab939580188e1b
   original:
-    hackage: CC-delcont-0.2.1.0@sha256:3791184e55c0f59549443f8dde86131b3479f7eb4b540549aceff6db2b2e3006,2276
+    hackage: fclabels-2.0.5@sha256:817006077632bd29e637956154aa33d3c10a59be0791c308cef955eb951b2675,4473
 snapshots:
 - completed:
     size: 533053