1 files changed, 25 insertions, 25 deletions
diff --git a/lambda-calcul/haskell/src/Minilang/REPL/Run.hs b/lambda-calcul/haskell/src/Minilang/REPL/Run.hs
index 26f3cad..ba09007 100644
--- a/lambda-calcul/haskell/src/Minilang/REPL/Run.hs
+++ b/lambda-calcul/haskell/src/Minilang/REPL/Run.hs
@@ -8,7 +8,7 @@ module Minilang.REPL.Run where
 
 import Control.Monad.Catch
 import Data.Text hiding (replicate)
-import Minilang.Lambda (loadProgram, evalInEnvWith)
+import Minilang.Lambda (evalInEnvWith, loadProgram)
 import Minilang.Lambda.Eval (newEnv)
 import Minilang.Lambda.Infer (extendContext, infer, newContext)
 import qualified Minilang.Lambda.Infer as Infer
@@ -20,21 +20,21 @@ import Minilang.REPL.Types
 runREPL ::
   (MonadCatch m, MonadREPL m) => m ()
 runREPL = go
-  where
-    go = do
-      prompt
-      raw <- input
-      case raw of
-        EOF -> output Bye
-        In txt -> handleUserInput txt >> go
-        Com cmd -> handleCommand cmd >> go
+ where
+  go = do
+    prompt
+    raw <- input
+    case raw of
+      EOF -> output Bye
+      In txt -> handleUserInput txt >> go
+      Com cmd -> handleCommand cmd >> go
 
 handleUserInput ::
   (MonadCatch m, MonadREPL m) =>
   Text ->
   m ()
 handleUserInput txt = do
-  repl@REPLEnv {language, evaluator, env, context} <- getEnv
+  repl@REPLEnv{language, evaluator, env, context} <- getEnv
   case parse txt of
     Left err -> output (Msg $ pack $ show err)
     Right (Def ident body) -> do
@@ -46,13 +46,13 @@ handleUserInput txt = do
             Right typ -> do
               setEnv $
                 repl
-                  { env = (ident, v) : env,
-                    context = extendContext ident typ context
+                  { env = (ident, v) : env
+                  , context = extendContext ident typ context
                   }
-              output (Defined ident typ)
+              output (Defined ident (Just typ))
         Untyped -> do
-          setEnv $ repl {env = (ident, v) : env}
-          output (Defined ident (TyVar "<?>"))
+          setEnv $ repl{env = (ident, v) : env}
+          output (Defined ident Nothing)
     Right expr -> do
       let v = evalInEnvWith evaluator env expr
           ast = resugar v
@@ -62,17 +62,17 @@ handleUserInput txt = do
             Left typeError -> output (Msg $ Infer.render typeError)
             Right typ -> do
               let
-              output (Evaluated ast v typ)
+              output (Evaluated ast v (Just typ))
         Untyped ->
-          output (Evaluated ast v (TyVar "<?>"))
+          output (Evaluated ast v Nothing)
 
 handleCommand ::
   (MonadCatch m, MonadREPL m) =>
   Command ->
   m ()
-handleCommand ClearEnv = getEnv >>= \e -> setEnv (e {env = newEnv, context = newContext})
+handleCommand ClearEnv = getEnv >>= \e -> setEnv (e{env = newEnv, context = newContext})
 handleCommand DumpEnv =
-  getEnv >>= \REPLEnv {..} ->
+  getEnv >>= \REPLEnv{..} ->
     output (CurrentEnv env context language)
 handleCommand (Load (File file)) = do
   t <- load file
@@ -80,15 +80,15 @@ handleCommand (Load (File file)) = do
     Left err -> output (Msg $ pack $ show err)
     Right prog -> loadProgramInEnv prog
 handleCommand (Load (Data prog)) = loadProgramInEnv prog
-handleCommand (Set (StepTypeChecker st)) = getEnv >>= \e -> setEnv (e {stepTypeCheck = st})
-handleCommand (Set (DebugParser st)) = getEnv >>= \e -> setEnv (e {debugParser = st})
+handleCommand (Set (StepTypeChecker st)) = getEnv >>= \e -> setEnv (e{stepTypeCheck = st})
+handleCommand (Set (DebugParser st)) = getEnv >>= \e -> setEnv (e{debugParser = st})
 handleCommand (Set (SelectLanguage lang)) =
   getEnv >>= \e ->
-    setEnv (e {language = lang})
+    setEnv (e{language = lang})
       >> output (Msg $ "Language set to " <> pack (show lang))
 handleCommand (Set (SelectEvaluator ev)) =
   getEnv >>= \e ->
-    setEnv (e {evaluator = ev})
+    setEnv (e{evaluator = ev})
       >> output (Msg $ "Evaluator set to " <> pack (show ev))
 handleCommand Help =
   output (Msg helpText)
@@ -98,12 +98,12 @@ loadProgramInEnv ::
   Text ->
   m ()
 loadProgramInEnv prog = do
-  repl@REPLEnv {env, context, language, evaluator} <- getEnv
+  repl@REPLEnv{env, context, language, evaluator} <- getEnv
   case parseProgram prog of
     Left err -> output (Msg $ pack $ show err)
     Right exprs -> do
       case loadProgram evaluator language env context exprs of
         Left typeError -> output (Msg $ pack $ show typeError)
         Right (results, env', context') -> do
-          setEnv (repl {env = env', context = context'})
+          setEnv (repl{env = env', context = context'})
           mapM_ (\(term, typ) -> output (Evaluated (resugar term) term typ)) results