REPL namespaces; lib function for pattern matching

Adds support for REPL namespacing, primarily to avoid `main` collisions.
Also adds a library function for an ergonomic pattern matching function
that I've been noodling on. I might explore ways to make list syntax
less annoying specifically for pattern matching like this.

src/REPL.hs

@@ -6,21 +6,35 @@ import Lexer
 import Parser
 import Research
 
-import Control.Exception      (SomeException, catch)
-import Control.Monad.IO.Class (liftIO)
-import Control.Monad.Catch    (handle, MonadCatch)
-import Data.Char              (isSpace)
-import Data.List              ( dropWhile
-                              , dropWhileEnd
-                              , intercalate
-                              , isPrefixOf)
+import Control.Exception         (SomeException, catch)
+import Control.Monad.IO.Class    (liftIO)
+import Control.Monad.Catch       (handle, MonadCatch)
+import Control.Monad.Trans.Class (lift)
+import Control.Monad.Trans.Maybe (MaybeT(..), runMaybeT)
+import Data.Char                 (isSpace)
+import Data.List                 ( dropWhile
+                                 , dropWhileEnd
+                                 , isPrefixOf)
 import System.Console.Haskeline
 
 import qualified Data.Map as Map
 
 repl :: Env -> IO ()
-repl env = runInputT defaultSettings (withInterrupt (loop env True))
+repl env = runInputT settings (withInterrupt (loop env True))
   where
+    settings :: Settings IO
+    settings = Settings
+      { complete = completeWord Nothing " \t" completeCommands
+      , historyFile = Just ".tricu_history"
+      , autoAddHistory = True
+      }
+
+    completeCommands :: String -> IO [Completion]
+    completeCommands str = return $ map simpleCompletion $
+      filter (str `isPrefixOf`) commands
+      where
+        commands = ["!exit", "!decode", "!definitions", "!import"]
+
     loop :: Env -> Bool -> InputT IO ()
     loop env decode = handle (interruptHandler env decode) $ do
       minput <- getInputLine "tricu < "
@@ -32,26 +46,48 @@ repl env = runInputT defaultSettings (withInterrupt (loop env True))
           | strip s == "!decode" -> do
               outputStrLn $ "Decoding " ++ (if decode then "disabled" else "enabled")
               loop env (not decode)
-          | "!import" `isPrefixOf` strip s -> do
-              let afterImport = dropWhile (== ' ') $ drop (length ("!import" :: String)) (strip s)
-              if not (null afterImport)
-                then outputStrLn "Warning: REPL imports are interactive; \
-                                  \additional arguments are ignored."
-                else pure ()
-              path <- getInputLine "File path to load < "
-              case path of
-                Nothing -> do
-                  outputStrLn "No input received; stopping import."
-                  loop env decode
-                Just p -> do
-                  loadedEnv <- liftIO $ evaluateFileWithContext env
-                    (strip p) `catch` \e -> errorHandler env e
-                  loop (Map.delete "!result" (Map.union loadedEnv env)) decode
+          | strip s == "!definitions" -> do
+              let defs = Map.keys $ Map.delete "!result" env
+              if null defs
+                then outputStrLn "No definitions discovered."
+                else do
+                  outputStrLn "Available definitions:"
+                  mapM_ outputStrLn defs
+              loop env decode
+          | "!import" `isPrefixOf` strip s -> handleImport env decode
           | take 2 s == "--" -> loop env decode
           | otherwise -> do
               newEnv <- liftIO $ processInput env s decode `catch` errorHandler env
               loop newEnv decode
 
+    handleImport :: Env -> Bool -> InputT IO ()
+    handleImport env decode = do
+      result <- runMaybeT $ do
+        let fileSettings = setComplete completeFilename defaultSettings
+        path <- MaybeT $ runInputT fileSettings $
+          getInputLineWithInitial "File path to load < " ("", "")
+
+        contents <- liftIO $ readFile (strip path)
+
+        if | Left err <- parseProgram (lexTricu contents) -> do
+               lift $ outputStrLn $ "Parse error: " ++ handleParseError err
+               MaybeT $ return Nothing
+           | Right ast <- parseProgram (lexTricu contents) -> do
+               ns <- MaybeT $ runInputT defaultSettings $
+                 getInputLineWithInitial "Namespace (or !Local for no namespace) < " ("", "")
+
+               processedAst <- liftIO $ preprocessFile (strip path)
+               let namespacedAst | strip ns == "!Local" = processedAst
+                                | otherwise = nsDefinitions (strip ns) processedAst
+                   loadedEnv = evalTricu env namespacedAst
+               return loadedEnv
+
+      if | Nothing <- result -> do
+             outputStrLn "Import cancelled."
+             loop env decode
+         | Just loadedEnv <- result ->
+             loop (Map.delete "!result" loadedEnv) decode
+
     interruptHandler :: Env -> Bool -> Interrupt -> InputT IO ()
     interruptHandler env decode _ = do
       outputStrLn "Interrupted with CTRL+C\n\
@@ -64,17 +100,17 @@ repl env = runInputT defaultSettings (withInterrupt (loop env True))
           newEnv = evalTricu env asts
       case Map.lookup "!result" newEnv of
         Just r -> do
-          putStrLn $ "tricu > " ++ 
-            if decode 
+          putStrLn $ "tricu > " ++
+            if decode
               then decodeResult r
               else show r
         Nothing -> pure ()
       return newEnv
-    
+
     errorHandler :: Env -> SomeException -> IO (Env)
     errorHandler env e = do
       putStrLn $ "Error: " ++ show e
       return env
-    
+
     strip :: String -> String
     strip = dropWhileEnd isSpace . dropWhile isSpace