# Modules

Basic implementation of a module system including tests.

.gitea/workflows/test-and-build.yml

@@ -54,16 +54,12 @@ jobs:
           cp -L ./result/bin/tricu ./tricu
           chmod 755 ./tricu
           nix develop --command upx ./tricu
-  
-      - name: Setup go for release action
-        uses: actions/setup-go@v5
-        with:
-          go-version: '>=1.20.1'
-  
+
       - name: Release binary
-        uses: https://gitea.com/actions/release-action@main
+        uses: akkuman/gitea-release-action@v1
         with:
           files: |-
             ./tricu
-          api_key: '${{ secrets.RELEASE_TOKEN }}'
-          pre_release: true
+          token: '${{ secrets.RELEASE_TOKEN }}'
+          body: '${{ gitea.event.head_commit.message }}'
+          prerelease: true

README.md

@@ -10,12 +10,13 @@ tricu is the word for "tree" in Lojban: `(x1) is a tree of species/cultivar (x2)
 
 - Tree Calculus operator: `t`
 - Assignments: `x = t t`
+- Immutabile definitions
 - Lambda abstraction syntax: `id = (\a : a)`
 - List, Number, and String literals: `[(2) ("Hello")]` 
 - Function application: `not (not false)`
 - Higher order/first-class functions: `map (\a : lconcat a "!") [("Hello")]`
 - Intensionality blurs the distinction between functions and data (see REPL examples)
-- Immutability
+- Simple module system for code organization
 
 ## REPL examples
 
@@ -71,7 +72,7 @@ tricu eval [OPTIONS]
 
   -f --file=FILE  Input file path(s) for evaluation.
                     Defaults to stdin.
-  -t --form=FORM  Optional output form: (tree|fsl|ast|ternary|ascii).
+  -t --form=FORM  Optional output form: (tree|fsl|ast|ternary|ascii|decode).
                     Defaults to tricu-compatible `t` tree form.
 
 tricu decode [OPTIONS]

demos/equality.tri

@@ -1,3 +1,9 @@
+!module Equality
+
+!import "lib/base.tri" Lib
+
+main = lambdaEqualsTC
+
 -- We represent `false` with a Leaf and `true` with a Stem Leaf
 demo_false = t
 demo_true  = t t
@@ -22,7 +28,7 @@ not_Lambda? = demo_matchBool demo_false demo_true
 -- to different tree representations even if they share extensional behavior.
 
 -- Let's see if these are the same:
-lambdaEqualsTC = equal? not_TC? not_Lambda?
+lambdaEqualsTC = Lib.equal? not_TC? not_Lambda?
 
 -- Here are some checks to verify their extensional behavior is the same:
 true_TC?  = not_TC? demo_false
@@ -31,5 +37,5 @@ false_TC? = not_TC? demo_true
 true_Lambda?  = not_Lambda? demo_false
 false_Lambda? = not_Lambda? demo_true
 
-bothTrueEqual?  = equal? true_TC?  true_Lambda?
-bothFalseEqual? = equal? false_TC? false_Lambda?
+bothTrueEqual?  = Lib.equal? true_TC?  true_Lambda?
+bothFalseEqual? = Lib.equal? false_TC? false_Lambda?

demos/levelOrderTraversal.tri

@@ -1,11 +1,14 @@
+!module LOT
+
+!import "lib/base.tri" Lib
+
+main = exampleTwo
 -- Level Order Traversal of a labelled binary tree
 -- Objective: Print each "level" of the tree on a separate line
 --
--- NOTICE: This demo relies on tricu base library functions
--- 
--- We model labelled binary trees as sublists where values act as labels. We
--- require explicit not?ation of empty nodes. Empty nodes can be represented 
--- with an empty list, `[]`, which is equivalent to a single node `t`. 
+-- We model labelled binary trees as nested lists where values act as labels. We
+-- require explicit notation of empty nodes. Empty nodes can be represented
+-- with an empty list, `[]`, which evaluates to a single node `t`.
 --
 -- Example tree inputs:
 -- [("1") [("2") [("4") t t] t] [("3") [("5") t t] [("6") t t]]]]
@@ -15,43 +18,42 @@
 --     2   3
 --    /   /  \
 --   4   5    6
---
 
-label = \node : head node
+label = \node : Lib.head node
 
-left = (\node : if (emptyList? node)
+left = (\node : Lib.if (Lib.emptyList? node)
   [] 
-  (if (emptyList? (tail node)) 
+  (Lib.if (Lib.emptyList? (Lib.tail node)) 
     [] 
-    (head (tail node))))
+    (Lib.head (Lib.tail node))))
 
-right = (\node : if (emptyList? node) 
+right = (\node : Lib.if (Lib.emptyList? node) 
   [] 
-  (if (emptyList? (tail node)) 
+  (Lib.if (Lib.emptyList? (Lib.tail node)) 
     [] 
-    (if (emptyList? (tail (tail node))) 
+    (Lib.if (Lib.emptyList? (Lib.tail (Lib.tail node))) 
       [] 
-      (head (tail (tail node))))))
+      (Lib.head (Lib.tail (Lib.tail node))))))
 
-processLevel = y (\self queue : if (emptyList? queue) 
+processLevel = Lib.y (\self queue : Lib.if (Lib.emptyList? queue) 
   [] 
-  (pair (map label queue) (self (filter 
-    (\node : not? (emptyList? node)) 
-      (lconcat (map left queue) (map right queue))))))
+  (Lib.pair (Lib.map label queue) (self (Lib.filter 
+    (\node : Lib.not? (Lib.emptyList? node)) 
+      (Lib.lconcat (Lib.map left queue) (Lib.map right queue))))))
 
 levelOrderTraversal_ = \a : processLevel (t a t)
 
-toLineString = y (\self levels : if (emptyList? levels) 
+toLineString = Lib.y (\self levels : Lib.if (Lib.emptyList? levels) 
   "" 
-  (lconcat 
-    (lconcat (map (\x : lconcat x " ") (head levels)) "") 
-    (if (emptyList? (tail levels)) "" (lconcat (t (t 10 t) t) (self (tail levels))))))
+  (Lib.lconcat 
+    (Lib.lconcat (Lib.map (\x : Lib.lconcat x " ") (Lib.head levels)) "") 
+    (Lib.if (Lib.emptyList? (Lib.tail levels)) "" (Lib.lconcat (t (t 10 t) t) (self (Lib.tail levels))))))
 
 levelOrderToString = \s : toLineString (levelOrderTraversal_ s)
 
-flatten = foldl (\acc x : lconcat acc x) ""
+flatten = Lib.foldl (\acc x : Lib.lconcat acc x) ""
 
-levelOrderTraversal = \s : lconcat (t 10 t) (flatten (levelOrderToString s))
+levelOrderTraversal = \s : Lib.lconcat (t 10 t) (flatten (levelOrderToString s))
 
 exampleOne = levelOrderTraversal [("1") 
                                  [("2") [("4") t t] t] 
@@ -61,5 +63,3 @@ exampleTwo = levelOrderTraversal [("1")
                                  [("2") [("4") [("8") t t] [("9") t t]] 
                                         [("6") [("10") t t] [("12") t t]]] 
                                  [("3") [("5") [("11") t t] t] [("7") t t]]]
-
-exampleTwo

demos/size.tri

@@ -1,21 +1,25 @@
+!module Size
+
+!import "lib/base.tri" Lib
+
+main = size size
+
 compose = \f g x : f (g x)
 
-succ = y (\self : 
-  triage 
-    1 
-    t 
-    (triage 
-      (t (t t)) 
-      (\_ tail : t t (self tail)) 
+succ = Lib.y (\self :
+  Lib.triage
+    1
+    t
+    (Lib.triage
+      (t (t t))
+      (\_ Lib.tail : t t (self Lib.tail))
       t))
 
-size = (\x : 
-  (y (\self x : 
-    compose succ 
-      (triage 
-        (\x : x) 
-        self 
-        (\x y : compose (self x) (self y)) 
+size = (\x :
+  (Lib.y (\self x :
+    compose succ
+      (Lib.triage
+        (\x : x)
+        self
+        (\x y : compose (self x) (self y))
         x)) x 0))
-
-size size

demos/toSource.tri

@@ -1,3 +1,8 @@
+!module ToSource
+
+!import "lib/base.tri" Lib
+
+main = toSource Lib.not?
 -- Thanks to intensionality, we can inspect the structure of a given value
 -- even if it's a function. This includes lambdas which are eliminated to
 -- Tree Calculus (TC) terms during evaluation.
@@ -11,29 +16,29 @@
 -- triage = (\leaf stem fork : t (t leaf stem) fork)
 
 -- Base case of a single Leaf
-sourceLeaf = t (head "t")
+sourceLeaf = t (Lib.head "t")
 
 -- Stem case
 sourceStem = (\convert : (\a rest :
-  t (head "(")                       -- Start with a left parenthesis "(".
-    (t (head "t")                    -- Add a "t"
-      (t (head " ")                  -- Add a space.
-        (convert a                   -- Recursively convert the argument.
-          (t (head ")") rest))))))   -- Close with ")" and append the rest.
+  t (Lib.head "(")                       -- Start with a left parenthesis "(".
+    (t (Lib.head "t")                    -- Add a "t"
+      (t (Lib.head " ")                  -- Add a space.
+        (convert a                       -- Recursively convert the argument.
+          (t (Lib.head ")") rest))))))   -- Close with ")" and append the rest.
 
 -- Fork case
 sourceFork = (\convert : (\a b rest :
-  t (head "(")                           -- Start with a left parenthesis "(".
-    (t (head "t")                        -- Add a "t"
-      (t (head " ")                      -- Add a space.
-        (convert a                       -- Recursively convert the first arg.
-          (t (head " ")                  -- Add another space.
-            (convert b                   -- Recursively convert the second arg.
-              (t (head ")") rest)))))))) -- Close with ")" and append the rest.
+  t (Lib.head "(")                           -- Start with a left parenthesis "(".
+    (t (Lib.head "t")                        -- Add a "t"
+      (t (Lib.head " ")                      -- Add a space.
+        (convert a                           -- Recursively convert the first arg.
+          (t (Lib.head " ")                  -- Add another space.
+            (convert b                       -- Recursively convert the second arg.
+              (t (Lib.head ")") rest)))))))) -- Close with ")" and append the rest.
 
 -- Wrapper around triage 
-toSource_ = y (\self arg :
-  triage
+toSource_ = Lib.y (\self arg :
+  Lib.triage
     sourceLeaf        -- `triage` "a" case, Leaf
     (sourceStem self) -- `triage` "b" case, Stem
     (sourceFork self) -- `triage` "c" case, Fork
@@ -42,5 +47,5 @@ toSource_ = y (\self arg :
 -- toSource takes a single TC term and returns a String
 toSource = \v : toSource_ v ""
 
-exampleOne = toSource true -- OUT: "(t t)"
-exampleTwo = toSource not? -- OUT: "(t (t (t t) (t t t)) (t t (t t t)))"
+exampleOne = toSource Lib.true -- OUT: "(t t)"
+exampleTwo = toSource Lib.not? -- OUT: "(t (t (t t) (t t t)) (t t (t t t)))"

lib/base.tri

@@ -18,9 +18,9 @@ y = ((\mut wait fun : wait mut (\x : fun (wait mut x)))
 triage = \leaf stem fork : t (t leaf stem) fork
 test   = triage "Leaf" (\_ : "Stem") (\_ _ : "Fork")
 
-matchBool = (\ot of : triage 
-  of 
-  (\_ : ot) 
+matchBool = (\ot of : triage
+  of
+  (\_ : ot)
   (\_ _ : ot)
 )
 
@@ -35,44 +35,44 @@ emptyList? = matchList true (\_ _ : false)
 head = matchList t (\head _ : head)
 tail = matchList t (\_ tail : tail)
 
-lconcat = y (\self : matchList 
-  (\k : k) 
+lconcat = y (\self : matchList
+  (\k : k)
   (\h r k : pair h (self r k)))
 
-lAnd = (triage 
-  (\_     : false) 
-  (\_ x   : x) 
+lAnd = (triage
+  (\_     : false)
+  (\_ x   : x)
   (\_ _ x : x))
 
-lOr = (triage 
-  (\x     : x) 
-  (\_ _   : true) 
+lOr = (triage
+  (\x     : x)
+  (\_ _   : true)
   (\_ _ _ : true))
 
-map_ = y (\self : 
-  matchList 
-    (\_ : t) 
+map_ = y (\self :
+  matchList
+    (\_ : t)
     (\head tail f : pair (f head) (self tail f)))
 map = \f l : map_ l f
 
-equal? = y (\self : triage 
-  (triage 
-    true 
-    (\_   : false) 
-    (\_ _ : false)) 
-  (\ax : 
-    triage 
-      false 
-      (self ax) 
-      (\_ _ : false)) 
-  (\ax ay : 
-    triage 
-      false 
-      (\_ : false) 
+equal? = y (\self : triage
+  (triage
+    true
+    (\_   : false)
+    (\_ _ : false))
+  (\ax :
+    triage
+      false
+      (self ax)
+      (\_ _ : false))
+  (\ax ay :
+    triage
+      false
+      (\_ : false)
       (\bx by : lAnd (self ax bx) (self ay by))))
 
-filter_ = y (\self : matchList 
-  (\_ : t) 
+filter_ = y (\self : matchList
+  (\_ : t)
   (\head tail f : matchBool (t head) i (f head) (self tail f)))
 filter  = \f l : filter_ l f
 

src/Eval.hs

@@ -3,38 +3,43 @@ module Eval where
 import Parser
 import Research
 
+import Data.List (partition, (\\))
 import Data.Map  (Map)
-
 import qualified Data.Map as Map
 import qualified Data.Set as Set
 
 evalSingle :: Env -> TricuAST -> Env
 evalSingle env term
-  | SFunc name [] body <- term =
+  | SDef name [] body <- term =
       if
-        | Map.member name env -> 
-            errorWithoutStackTrace $ 
+        | Map.member name env ->
+            errorWithoutStackTrace $
               "Error: Identifier '" ++ name ++ "' is already defined."
-        | otherwise -> 
+        | otherwise ->
             let res = evalAST env body
-            in Map.insert "__result" res (Map.insert name res env)
+            in Map.insert "!result" res (Map.insert name res env)
   | SApp func arg <- term =
       let res = apply (evalAST env func) (evalAST env arg)
-      in Map.insert "__result" res env
+      in Map.insert "!result" res env
   | SVar name <- term =
       case Map.lookup name env of
-        Just v  -> Map.insert "__result" v env
-        Nothing -> errorWithoutStackTrace $ "Variable `" ++ name ++ "` not defined"
+        Just v  ->
+          Map.insert "!result" v env
+        Nothing ->
+          errorWithoutStackTrace $ "Variable `" ++ name ++ "` not defined\n\
+          \This error should never occur here. Please report this as an issue."
   | otherwise =
-      Map.insert "__result" (evalAST env term) env
+      Map.insert "!result" (evalAST env term) env
 
 evalTricu :: Env -> [TricuAST] -> Env
-evalTricu env []     = env
-evalTricu env [x]    =
-  let updatedEnv = evalSingle env x
-  in Map.insert "__result" (result updatedEnv) updatedEnv
-evalTricu env (x:xs) =
-  evalTricu (evalSingle env x) xs
+evalTricu env x = go env (reorderDefs env x)
+  where
+    go env []     = env
+    go env [x]    =
+      let updatedEnv = evalSingle env x
+      in Map.insert "!result" (result updatedEnv) updatedEnv
+    go env (x:xs) =
+      evalTricu (evalSingle env x) xs
 
 evalAST :: Env -> TricuAST -> T
 evalAST env term
@@ -61,13 +66,13 @@ elimLambda = go
     go (SLambda [v] (SApp f (SVar x)))
       | v == x && not (isFree v f) = elimLambda f
     -- Triage optimization
-    go (SLambda [a] (SLambda [b] (SLambda [c] body))) 
+    go (SLambda [a] (SLambda [b] (SLambda [c] body)))
       | body == triageBody         = _TRIAGE
       where
         triageBody =
           (SApp (SApp TLeaf (SApp (SApp TLeaf (SVar a)) (SVar b))) (SVar c))
     -- Composition optimization
-    go (SLambda [f] (SLambda [g] (SLambda [x] body))) 
+    go (SLambda [f] (SLambda [g] (SLambda [x] body)))
       | body == composeBody        = _COMPOSE
       where
         composeBody = SApp (SVar f) (SApp (SVar g) (SVar x))
@@ -93,20 +98,94 @@ elimLambda = go
     _I       = parseSingle "t (t (t t)) t"
     _TRIAGE  = parseSingle "t (t (t t (t (t (t t t))))) t"
     _COMPOSE = parseSingle "t (t (t t (t (t (t t t)) t))) (t t)"
-    
-    isFree x = Set.member x . freeVars
-    freeVars (SVar    v    ) = Set.singleton v
-    freeVars (SInt    _    ) = Set.empty
-    freeVars (SStr    _    ) = Set.empty
-    freeVars (SList   s    ) = foldMap freeVars s
-    freeVars (SApp    f a  ) = freeVars f <> freeVars a
-    freeVars (TLeaf        ) = Set.empty
-    freeVars (SFunc   _ _ b) = freeVars b
-    freeVars (TStem   t    ) = freeVars t
-    freeVars (TFork   l r  ) = freeVars l <> freeVars r
-    freeVars (SLambda v b  ) = foldr Set.delete (freeVars b) v
+
+isFree :: String -> TricuAST -> Bool
+isFree x = Set.member x . freeVars
+
+freeVars :: TricuAST -> Set.Set String
+freeVars (SVar    v    ) = Set.singleton v
+freeVars (SInt    _    ) = Set.empty
+freeVars (SStr    _    ) = Set.empty
+freeVars (SList   s    ) = foldMap freeVars s
+freeVars (SApp    f a  ) = freeVars f <> freeVars a
+freeVars (TLeaf        ) = Set.empty
+freeVars (SDef   _ _ b)  = freeVars b
+freeVars (TStem   t    ) = freeVars t
+freeVars (TFork   l r  ) = freeVars l <> freeVars r
+freeVars (SLambda v b  ) = foldr Set.delete (freeVars b) v
+freeVars _               = Set.empty
+
+reorderDefs :: Env -> [TricuAST] -> [TricuAST]
+reorderDefs env defs
+  | not (null missingDeps) =
+      errorWithoutStackTrace $
+        "Missing dependencies detected: " ++ show missingDeps
+  | otherwise = orderedDefs ++ others
+  where
+    (defsOnly, others) = partition isDef defs
+    defNames = [ name | SDef name _ _ <- defsOnly ]
+
+    defsWithFreeVars = [(def, freeVars body) | def@(SDef _ _ body) <- defsOnly]
+
+    graph = buildDepGraph defsOnly
+    sortedDefs = sortDeps graph
+    defMap = Map.fromList [(name, def) | def@(SDef name _ _) <- defsOnly]
+    orderedDefs = map (\name -> defMap Map.! name) sortedDefs
+
+    freeVarsDefs = foldMap snd defsWithFreeVars
+    freeVarsOthers = foldMap freeVars others
+    allFreeVars = freeVarsDefs <> freeVarsOthers
+    validNames = Set.fromList defNames `Set.union` Set.fromList (Map.keys env)
+    missingDeps = Set.toList (allFreeVars `Set.difference` validNames)
+
+    isDef (SDef _ _ _) = True
+    isDef _            = False
+
+buildDepGraph :: [TricuAST] -> Map.Map String (Set.Set String)
+buildDepGraph topDefs
+  | not (null duplicateNames) =
+      errorWithoutStackTrace $
+        "Duplicate definitions detected: " ++ show duplicateNames
+  | otherwise =
+      Map.fromList
+        [ (name, depends topDefs (SDef name [] body))
+        | SDef name _ body <- topDefs]
+  where
+    names = [name | SDef name _ _ <- topDefs]
+    duplicateNames =
+      [ name | (name, count) <- Map.toList (countOccurrences names) , count > 1]
+    countOccurrences = foldr (\x -> Map.insertWith (+) x 1) Map.empty
+
+sortDeps :: Map.Map String (Set.Set String) -> [String]
+sortDeps graph = go [] Set.empty (Map.keys graph)
+  where
+    go sorted sortedSet [] = sorted
+    go sorted sortedSet remaining =
+      let ready = [ name | name <- remaining
+                        , let deps = Map.findWithDefault Set.empty name graph
+                        , Set.isSubsetOf deps sortedSet ]
+          notReady = remaining \\ ready
+      in if null ready
+         then errorWithoutStackTrace
+          "ERROR: Cyclic dependency detected and prohibited.\n\
+          \RESOLVE: Use nested lambdas."
+         else go (sorted ++ ready)
+                 (Set.union sortedSet (Set.fromList ready))
+                 notReady
+
+depends :: [TricuAST] -> TricuAST -> Set.Set String
+depends topDefs (SDef _ _ body) =
+  Set.intersection
+    (Set.fromList [n | SDef n _ _ <- topDefs])
+    (freeVars body)
+depends _ _ = Set.empty
 
 result :: Env -> T
-result r = case Map.lookup "__result" r of
+result r = case Map.lookup "!result" r of
   Just a -> a
-  Nothing -> errorWithoutStackTrace "No __result field found in provided environment"
+  Nothing -> errorWithoutStackTrace "No !result field found in provided env"
+
+mainResult :: Env -> T
+mainResult r = case Map.lookup "main" r of
+  Just  a -> a
+  Nothing -> errorWithoutStackTrace "No valid definition for `main` found."

src/FileEval.hs

@@ -1,30 +1,150 @@
 module FileEval where
 
 import Eval
+import Lexer
 import Parser
 import Research
 
+import Data.List       (partition)
+import Control.Monad   (foldM)
 import System.IO
 
 import qualified Data.Map as Map
+import qualified Data.Set as Set
 
 evaluateFileResult :: FilePath -> IO T
 evaluateFileResult filePath = do
   contents <- readFile filePath
-  let asts = parseTricu contents
-  let finalEnv = evalTricu Map.empty asts
-  case Map.lookup "__result" finalEnv of
-    Just finalResult -> return finalResult
-    Nothing -> errorWithoutStackTrace "No expressions to evaluate found"
+  let tokens = lexTricu contents
+  let moduleName = case parseProgram tokens of
+        Right ((SModule name) : _) -> name
+        _                          -> ""
+  case parseProgram tokens of
+    Left err -> errorWithoutStackTrace (handleParseError err)
+    Right _ -> do
+      ast <- preprocessFile filePath
+      let finalEnv = mainAlias moduleName $ evalTricu Map.empty ast
+      case Map.lookup "main" finalEnv of
+        Just finalResult -> return finalResult
+        Nothing -> errorWithoutStackTrace "No `main` function detected"
 
 evaluateFile :: FilePath -> IO Env
 evaluateFile filePath = do
   contents <- readFile filePath
-  let asts = parseTricu contents
-  pure $ evalTricu Map.empty asts
+  let tokens = lexTricu contents
+  let moduleName = case parseProgram tokens of
+        Right ((SModule name) : _) -> name
+        _                          -> ""
+  case parseProgram tokens of
+    Left err -> errorWithoutStackTrace (handleParseError err)
+    Right _ -> do
+      ast <- preprocessFile filePath
+      pure $ mainAlias moduleName $ evalTricu Map.empty ast
 
 evaluateFileWithContext :: Env -> FilePath -> IO Env
 evaluateFileWithContext env filePath = do
   contents <- readFile filePath
-  let asts = parseTricu contents
-  pure $ evalTricu env asts
+  let tokens = lexTricu contents
+  let moduleName = case parseProgram tokens of
+        Right ((SModule name) : _) -> name
+        _                          -> ""
+  case parseProgram tokens of
+    Left err -> errorWithoutStackTrace (handleParseError err)
+    Right _ -> do
+      ast <- preprocessFile filePath
+      pure $ mainAlias moduleName $ evalTricu env ast
+
+mainAlias :: String -> Env -> Env
+mainAlias "" env = env
+mainAlias moduleName env =
+  case Map.lookup (moduleName ++ ".main") env of
+    Just value -> Map.insert "main" value env
+    Nothing    -> env
+
+preprocessFile :: FilePath -> IO [TricuAST]
+preprocessFile filePath = preprocessFile' Set.empty filePath
+
+preprocessFile' :: Set.Set FilePath -> FilePath -> IO [TricuAST]
+preprocessFile' inProgress filePath
+  | filePath `Set.member` inProgress = 
+      errorWithoutStackTrace $ "Encountered cyclic import: " ++ filePath
+  | otherwise = do
+      contents <- readFile filePath
+      let tokens = lexTricu contents
+      case parseProgram tokens of
+        Left err -> errorWithoutStackTrace (handleParseError err)
+        Right asts -> do
+          let (moduleName, restAST) = extractModule asts
+          let (imports, nonImports) = partition isImport restAST
+          let newInProgress = Set.insert filePath inProgress
+          importedASTs <- concat <$> mapM (processImport newInProgress) imports
+          let namespacedAST = namespaceDefinitions moduleName nonImports
+          pure $ importedASTs ++ namespacedAST
+  where
+    extractModule :: [TricuAST] -> (String, [TricuAST])
+    extractModule ((SModule name) : xs) = (name, xs)
+    extractModule xs                    = ("", xs)
+
+    isImport :: TricuAST -> Bool
+    isImport (SImport _ _) = True
+    isImport _             = False
+
+    processImport :: Set.Set FilePath -> TricuAST -> IO [TricuAST]
+    processImport inProgress (SImport filePath moduleName) = do
+      importedAST <- preprocessFile' inProgress filePath
+      pure $ namespaceDefinitions moduleName importedAST
+    processImport _ _ = error "Unexpected non-import in processImport"
+
+namespaceDefinitions :: String -> [TricuAST] -> [TricuAST]
+namespaceDefinitions moduleName = map (namespaceDefinition moduleName)
+
+namespaceDefinition :: String -> TricuAST -> TricuAST
+namespaceDefinition "" def = def
+namespaceDefinition moduleName (SDef name args body)
+  | isPrefixed name = SDef name args (namespaceBody moduleName body)
+  | otherwise = SDef (namespaceVariable moduleName name) 
+                        args (namespaceBody moduleName body)
+namespaceDefinition moduleName other =
+  namespaceBody moduleName other
+
+namespaceBody :: String -> TricuAST -> TricuAST
+namespaceBody moduleName (SVar name)
+  | isPrefixed name = SVar name
+  | otherwise = SVar (namespaceVariable moduleName name)
+namespaceBody moduleName (SApp func arg) =
+  SApp (namespaceBody moduleName func) (namespaceBody moduleName arg)
+namespaceBody moduleName (SLambda args body) =
+  SLambda args (namespaceBodyScoped moduleName args body)
+namespaceBody moduleName (SList items) =
+  SList (map (namespaceBody moduleName) items)
+namespaceBody moduleName (TFork left right) =
+  TFork (namespaceBody moduleName left) (namespaceBody moduleName right)
+namespaceBody moduleName (TStem subtree) =
+  TStem (namespaceBody moduleName subtree)
+namespaceBody moduleName (SDef name args body)
+  | isPrefixed name = SDef name args (namespaceBody moduleName body)
+  | otherwise = SDef (namespaceVariable moduleName name) 
+                        args (namespaceBody moduleName body)
+namespaceBody _ other = other
+
+namespaceBodyScoped :: String -> [String] -> TricuAST -> TricuAST
+namespaceBodyScoped moduleName args body = case body of
+  SVar name ->
+    if name `elem` args
+      then SVar name
+      else namespaceBody moduleName (SVar name)
+  SApp func arg -> SApp (namespaceBodyScoped moduleName args func) (namespaceBodyScoped moduleName args arg)
+  SLambda innerArgs innerBody -> SLambda innerArgs (namespaceBodyScoped moduleName (args ++ innerArgs) innerBody)
+  SList items -> SList (map (namespaceBodyScoped moduleName args) items)
+  TFork left right -> TFork (namespaceBodyScoped moduleName args left) (namespaceBodyScoped moduleName args right)
+  TStem subtree -> TStem (namespaceBodyScoped moduleName args subtree)
+  SDef name innerArgs innerBody ->
+    SDef (namespaceVariable moduleName name) innerArgs (namespaceBodyScoped moduleName (args ++ innerArgs) innerBody)
+  other -> other
+
+isPrefixed :: String -> Bool
+isPrefixed name = '.' `elem` name
+
+namespaceVariable :: String -> String -> String
+namespaceVariable "" name = name
+namespaceVariable moduleName name = moduleName ++ "." ++ name

src/Lexer.hs

@@ -20,11 +20,11 @@ identifier = do
   first <- letterChar <|> char '_'
   rest  <- many $ letterChar 
               <|> digitChar 
-              <|> char '_' <|> char '-' <|> char '?' <|> char '!'
+              <|> char '_' <|> char '-' <|> char '?' <|> char '.'
               <|> char '$' <|> char '#' <|> char '@' <|> char '%'
   let name = first : rest
-  if (name == "t" || name == "__result")
-    then fail "Keywords (`t`, `__result`) cannot be used as an identifier"
+  if (name == "t" || name == "!result")
+    then fail "Keywords (`t`, `!result`) cannot be used as an identifier"
     else return (LIdentifier name)
 
 integerLiteral :: Lexer LToken
@@ -39,6 +39,22 @@ stringLiteral = do
   char '"' --"
   return (LStringLiteral content)
 
+lModule :: Lexer LToken
+lModule = do
+  _ <- string "!module"
+  space1
+  LIdentifier moduleName <- identifier
+  return (LModule moduleName)
+
+lImport :: Lexer LToken
+lImport = do
+  _ <- string "!import"
+  space1
+  LStringLiteral path <- stringLiteral
+  space1
+  LIdentifier name <- identifier
+  return (LImport path name)
+
 assign :: Lexer LToken
 assign = char '=' *> pure LAssign
 
@@ -72,28 +88,36 @@ sc = space
 tricuLexer :: Lexer [LToken]
 tricuLexer = do
   sc
+  header <- many $ do
+    tok <- choice
+      [ try lModule
+      , try lImport
+      , lnewline
+      ]
+    sc
+    pure tok
   tokens <- many $ do
     tok <- choice tricuLexer'
     sc
     pure tok
   sc
   eof
-  pure tokens
-    where
-      tricuLexer' = 
-        [ try lnewline
-        , try identifier
-        , try keywordT
-        , try integerLiteral
-        , try stringLiteral
-        , assign
-        , colon
-        , backslash
-        , openParen
-        , closeParen
-        , openBracket
-        , closeBracket
-        ]
+  pure (header ++ tokens)
+  where
+    tricuLexer' =
+      [ try lnewline
+      , try identifier
+      , try keywordT
+      , try integerLiteral
+      , try stringLiteral
+      , assign
+      , colon
+      , backslash
+      , openParen
+      , closeParen
+      , openBracket
+      , closeBracket
+      ]
 
 lexTricu :: String -> [LToken]
 lexTricu input = case runParser tricuLexer "" input of

src/Main.hs

@@ -1,6 +1,6 @@
 module Main where
 
-import Eval                   (evalTricu, result)
+import Eval                   (evalTricu, mainResult, result)
 import FileEval
 import Parser                 (parseTricu)
 import REPL
@@ -16,7 +16,7 @@ import qualified Data.Map as Map
 data TricuArgs
   = Repl
   | Evaluate { file :: [FilePath], form :: EvaluatedForm }
-  | Decode { file :: [FilePath] }
+  | TDecode { file :: [FilePath] }
   deriving (Show, Data, Typeable)
 
 replMode :: TricuArgs
@@ -31,7 +31,7 @@ evaluateMode = Evaluate
       \ Defaults to stdin."
       &= name "f" &= typ "FILE"
     , form = TreeCalculus &= typ "FORM"
-      &= help "Optional output form: (tree|fsl|ast|ternary|ascii).\n \
+      &= help "Optional output form: (tree|fsl|ast|ternary|ascii|decode).\n \
       \ Defaults to tricu-compatible `t` tree form."
       &= name "t"
   }
@@ -40,7 +40,7 @@ evaluateMode = Evaluate
   &= name "eval"
 
 decodeMode :: TricuArgs
-decodeMode = Decode
+decodeMode = TDecode
   { file = def
     &= help "Optional input file path to attempt decoding.\n \
     \ Defaults to stdin."
@@ -61,7 +61,7 @@ main = do
       putStrLn "Welcome to the tricu REPL"
       putStrLn "You can exit with `CTRL+D` or the `:_exit` command.`"
       library <- liftIO $ evaluateFile "./lib/base.tri"
-      repl $ Map.delete "__result" library
+      repl $ Map.delete "!result" library
     Evaluate { file = filePaths, form = form } -> do
       result <- case filePaths of
         [] -> do
@@ -70,10 +70,10 @@ main = do
         (filePath:restFilePaths) -> do
             initialEnv <- evaluateFile filePath
             finalEnv <- foldM evaluateFileWithContext initialEnv restFilePaths
-            pure $ result finalEnv
+            pure $ mainResult finalEnv
       let fRes = formatResult form result
       putStr fRes
-    Decode { file = filePaths } -> do
+    TDecode { file = filePaths } -> do
       value <- case filePaths of
         [] -> getContents
         (filePath:_) -> readFile filePath

src/Parser.hs

@@ -74,9 +74,33 @@ parseSingle input =
 parseProgramM :: ParserM [TricuAST]
 parseProgramM = do
   skipMany topLevelNewline
+  moduleNode <- optional parseModuleM
+  skipMany topLevelNewline
+  importNodes <- many (do
+    node <- parseImportM
+    skipMany topLevelNewline
+    return node)
+  skipMany topLevelNewline
   exprs <- sepEndBy parseOneExpression (some topLevelNewline)
   skipMany topLevelNewline
-  return exprs
+  return (maybe [] (: []) moduleNode ++ importNodes ++ exprs)
+
+
+parseModuleM :: ParserM TricuAST
+parseModuleM = do
+  LModule moduleName <- satisfyM isModule
+  pure (SModule moduleName)
+  where
+    isModule (LModule _) = True
+    isModule _           = False
+
+parseImportM :: ParserM TricuAST
+parseImportM = do
+  LImport filePath moduleName <- satisfyM isImport
+  pure (SImport filePath moduleName)
+  where
+    isImport (LImport _ _) = True
+    isImport _             = False
 
 parseOneExpression :: ParserM TricuAST
 parseOneExpression = scnParserM *> parseExpressionM
@@ -112,7 +136,7 @@ parseFunctionM = do
   _    <- satisfyM (== LAssign)
   scnParserM
   body <- parseExpressionM
-  pure (SFunc name (map getIdentifier args) body)
+  pure (SDef name (map getIdentifier args) body)
 
 parseLambdaM :: ParserM TricuAST
 parseLambdaM = do
@@ -244,7 +268,7 @@ parseVarM :: ParserM TricuAST
 parseVarM = do
   satisfyM (\case LIdentifier _ -> True; _ -> False) >>= \case
     LIdentifier name
-      | name == "t" || name == "__result" ->
+      | name == "t" || name == "!result" ->
         fail ("Reserved keyword: " ++ name ++ " cannot be assigned.")
       | otherwise                         ->
          pure (SVar name)

src/REPL.hs

@@ -26,7 +26,7 @@ repl env = runInputT defaultSettings (loop env)
         | Just s  <- minput, strip s == ""      -> do
           outputStrLn ""
           loop env
-        | Just s  <- minput, strip s == "!load" -> do
+        | Just s  <- minput, strip s == "!import" -> do
           path <- getInputLine "File path to load < "
           if
             | Nothing <- path -> do
@@ -34,7 +34,7 @@ repl env = runInputT defaultSettings (loop env)
               loop env
             | Just p  <- path -> do
               loadedEnv <- liftIO $ evaluateFileWithContext env (strip p) `catch` \e -> errorHandler env e
-              loop $ Map.delete "__result" (Map.union loadedEnv env)
+              loop $ Map.delete "!result" (Map.union loadedEnv env)
         | Just s <- minput -> do
           if
             | take 2 s == "--" -> loop env
@@ -47,7 +47,7 @@ repl env = runInputT defaultSettings (loop env)
       let asts   = parseTricu input
           newEnv = evalTricu env asts
       if
-        | Just r <- Map.lookup "__result" newEnv -> do
+        | Just r <- Map.lookup "!result" newEnv -> do
           putStrLn $ "tricu > " ++ decodeResult r
         | otherwise -> return ()
       return newEnv
@@ -59,10 +59,3 @@ repl env = runInputT defaultSettings (loop env)
     
     strip :: String -> String
     strip = dropWhileEnd isSpace . dropWhile isSpace
-
-decodeResult :: T -> String
-decodeResult tc
-  | Right num  <- toNumber tc = show num
-  | Right str  <- toString tc = "\"" ++ str ++ "\""
-  | Right list <- toList tc   = "[" ++ intercalate ", " (map decodeResult list) ++ "]"
-  | otherwise                 = formatResult TreeCalculus tc

src/Research.hs

@@ -19,13 +19,15 @@ data TricuAST
   | SInt Int
   | SStr String
   | SList [TricuAST]
-  | SFunc String [String] TricuAST
+  | SDef String [String] TricuAST
   | SApp TricuAST TricuAST
   | TLeaf
   | TStem TricuAST
   | TFork TricuAST TricuAST
   | SLambda [String] TricuAST
   | SEmpty
+  | SModule String
+  | SImport String String
   deriving (Show, Eq, Ord)
 
 -- Lexer Tokens
@@ -42,10 +44,12 @@ data LToken
   | LOpenBracket
   | LCloseBracket
   | LNewline
+  | LModule String
+  | LImport String String
   deriving (Show, Eq, Ord)
 
 -- Output formats
-data EvaluatedForm = TreeCalculus | FSL | AST | Ternary | Ascii
+data EvaluatedForm = TreeCalculus | FSL | AST | Ternary | Ascii | Decode
   deriving (Show, Data, Typeable)
 
 -- Environment containing previously evaluated TC terms
@@ -115,6 +119,7 @@ formatResult FSL          = show
 formatResult AST          = show . toAST
 formatResult Ternary      = toTernaryString
 formatResult Ascii        = toAscii
+formatResult Decode       = decodeResult
 
 toSimpleT :: String -> String
 toSimpleT s = T.unpack 
@@ -147,4 +152,9 @@ toAscii tree = go tree "" True
         ++ go left (prefix ++ (if isLast then "    " else "|   ")) False
         ++ go right (prefix ++ (if isLast then "    " else "|   ")) True
 
--- Utility
+decodeResult :: T -> String
+decodeResult tc
+  | Right num  <- toNumber tc = show num
+  | Right str  <- toString tc = "\"" ++ str ++ "\""
+  | Right list <- toList tc   = "[" ++ intercalate ", " (map decodeResult list) ++ "]"
+  | otherwise                 = formatResult TreeCalculus tc

test/Spec.hs

@@ -7,12 +7,13 @@ import Parser
 import REPL
 import Research
 
-import Control.Exception (evaluate, try, SomeException)
+import Control.Exception      (evaluate, try, SomeException)
 import Control.Monad.IO.Class (liftIO)
+import Data.List              (isInfixOf)
 import Test.Tasty
 import Test.Tasty.HUnit
 import Test.Tasty.QuickCheck
-import Text.Megaparsec (runParser)
+import Text.Megaparsec        (runParser)
 
 import qualified Data.Map as Map
 import qualified Data.Set as Set
@@ -31,6 +32,7 @@ tests = testGroup "Tricu Tests"
   , lambdas
   , baseLibrary
   , fileEval
+  , modules
   , demos
   ]
 
@@ -70,9 +72,9 @@ lexer = testGroup "Lexer Tests"
         Right i -> i @?= expect
 
   , testCase "Error when using invalid characters in identifiers" $ do
-        case (runParser tricuLexer "" "__result = 5") of
+        case (runParser tricuLexer "" "!result = 5") of
           Left _ -> return ()
-          Right _ -> assertFailure "Expected failure when trying to assign the value of __result"
+          Right _ -> assertFailure "Expected failure when trying to assign the value of !result"
   ]
 
 parser :: TestTree
@@ -85,7 +87,7 @@ parser = testGroup "Parser Tests"
 
   , testCase "Parse function definitions" $ do
       let input = "x = (\\a b c : a)"
-          expect = SFunc "x" [] (SLambda ["a"] (SLambda ["b"] (SLambda ["c"] (SVar "a"))))
+          expect = SDef "x" [] (SLambda ["a"] (SLambda ["b"] (SLambda ["c"] (SVar "a"))))
       parseSingle input @?= expect
 
   , testCase "Parse nested Tree Calculus terms" $ do
@@ -105,7 +107,7 @@ parser = testGroup "Parser Tests"
 
   , testCase "Parse function with applications" $ do
       let input  = "f = (\\x : t x)"
-          expect = SFunc "f" [] (SLambda ["x"] (SApp TLeaf (SVar "x")))
+          expect = SDef "f" [] (SLambda ["x"] (SApp TLeaf (SVar "x")))
       parseSingle input @?= expect
 
   , testCase "Parse nested lists" $ do
@@ -147,7 +149,7 @@ parser = testGroup "Parser Tests"
 
   , testCase "Parse nested parentheses in function body" $ do
       let input  = "f = (\\x : t (t (t t)))"
-          expect = SFunc "f" [] (SLambda ["x"] (SApp TLeaf (SApp TLeaf (SApp TLeaf TLeaf))))
+          expect = SDef "f" [] (SLambda ["x"] (SApp TLeaf (SApp TLeaf (SApp TLeaf TLeaf))))
       parseSingle input @?= expect
 
   , testCase "Parse lambda abstractions" $ do
@@ -157,12 +159,12 @@ parser = testGroup "Parser Tests"
 
   , testCase "Parse multiple arguments to lambda abstractions" $ do
       let input  = "x = (\\a b : a)"
-          expect = SFunc "x" [] (SLambda ["a"] (SLambda ["b"] (SVar "a")))
+          expect = SDef "x" [] (SLambda ["a"] (SLambda ["b"] (SVar "a")))
       parseSingle input @?= expect
 
   , testCase "Grouping T terms with parentheses in function application" $ do
       let input  = "x = (\\a : a)\nx (t)"
-          expect = [SFunc "x" [] (SLambda ["a"] (SVar "a")),SApp (SVar "x") TLeaf]
+          expect = [SDef "x" [] (SLambda ["a"] (SVar "a")),SApp (SVar "x") TLeaf]
       parseTricu input @?= expect
 
   , testCase "Comments 1" $ do
@@ -488,8 +490,9 @@ fileEval = testGroup "File evaluation tests"
       res @?= Fork (Stem Leaf) Leaf
 
   , testCase "Mapping and Equality" $ do
-      res <- liftIO $ evaluateFileResult "./test/map.tri"
-      res @?= Stem Leaf
+      library <- liftIO $ evaluateFile "./lib/base.tri"
+      fEnv    <- liftIO $ evaluateFileWithContext library "./test/map.tri"
+      (mainResult fEnv) @?= Stem Leaf
 
   , testCase "Eval and decoding string" $ do
       library <- liftIO $ evaluateFile "./lib/base.tri"
@@ -497,22 +500,54 @@ fileEval = testGroup "File evaluation tests"
       decodeResult (result res) @?= "\"String test!\""
   ]
 
+modules :: TestTree
+modules = testGroup "Test modules"
+  [ testCase "Detect cyclic dependencies" $ do
+      result <- try (liftIO $ evaluateFileResult "./test/cycle-1.tri") :: IO (Either SomeException T)
+      case result of
+        Left e -> do
+          let errorMsg = show e
+          if "Encountered cyclic import" `isInfixOf` errorMsg
+            then return ()
+            else assertFailure $ "Unexpected error: " ++ errorMsg
+        Right _ -> assertFailure "Expected cyclic dependencies"
+  , testCase "Module imports and namespacing" $ do
+      res <- liftIO $ evaluateFileResult "./test/namespace-A.tri"
+      res @?= Leaf
+  , testCase "Multiple imports" $ do
+      res <- liftIO $ evaluateFileResult "./test/vars-A.tri"
+      res @?= Leaf
+  , testCase "Error on unresolved variable" $ do
+      result <- try (liftIO $ evaluateFileResult "./test/unresolved-A.tri") :: IO (Either SomeException T)
+      case result of
+        Left e -> do
+          let errorMsg = show e
+          if "undefinedVar" `isInfixOf` errorMsg
+            then return ()
+            else assertFailure $ "Unexpected error: " ++ errorMsg
+        Right _ -> assertFailure "Expected unresolved variable error"
+  , testCase "Multi-level imports" $ do
+      res <- liftIO $ evaluateFileResult "./test/multi-level-A.tri"
+      res @?= Leaf
+  , testCase "Lambda expression namespaces" $ do
+      res <- liftIO $ evaluateFileResult "./test/lambda-A.tri"
+      res @?= Leaf
+  ]
+
+
+-- All of our demo tests are also module tests
 demos :: TestTree
 demos = testGroup "Test provided demo functionality"
   [ testCase "Structural equality demo" $ do
-      library <- liftIO $ evaluateFile "./lib/base.tri"
-      res     <- liftIO $ evaluateFileWithContext library "./demos/equality.tri"
-      decodeResult (result res) @?= "t t"
+      res     <- liftIO $ evaluateFileResult "./demos/equality.tri"
+      decodeResult res @?= "t t"
   , testCase "Convert values back to source code demo" $ do
-      library <- liftIO $ evaluateFile "./lib/base.tri"
-      res     <- liftIO $ evaluateFileWithContext library "./demos/toSource.tri"
-      decodeResult (result res) @?= "\"(t (t (t t) (t t t)) (t t (t t t)))\""
+      res     <- liftIO $ evaluateFileResult "./demos/toSource.tri"
+      decodeResult res @?= "\"(t (t (t t) (t t t)) (t t (t t t)))\""
   , testCase "Determining the size of functions" $ do
-      library <- liftIO $ evaluateFile "./lib/base.tri"
-      res     <- liftIO $ evaluateFileWithContext library "./demos/size.tri"
-      decodeResult (result res) @?= "454"
+      res     <- liftIO $ evaluateFileResult "./demos/size.tri"
+      decodeResult res @?= "454"
   , testCase "Level Order Traversal demo" $ do
-      library <- liftIO $ evaluateFile "./lib/base.tri"
-      res     <- liftIO $ evaluateFileWithContext library "./demos/levelOrderTraversal.tri"
-      decodeResult (result res) @?= "\"\n1 \n2 3 \n4 5 6 7 \n8 11 10 9 12 \""
+      res     <- liftIO $ evaluateFileResult "./demos/levelOrderTraversal.tri"
+      decodeResult res @?= "\"\n1 \n2 3 \n4 5 6 7 \n8 11 10 9 12 \""
   ]

test/comments-1.tri

@@ -2,7 +2,7 @@
 -- t (t t) (t (t t t))
 -- t (t t t) (t t)
 -- x = (\a : a)
-t (t t) t -- Fork (Stem Leaf) Leaf
+main = t (t t) t -- Fork (Stem Leaf) Leaf
 -- t t
 -- x
 -- x = (\a : a)

test/cycle-1.tri

@@ -0,0 +1,5 @@
+!module Cycle
+
+!import "test/cycle-2.tri" Cycle2
+
+cycle1 = t Cycle2.cycle2

test/cycle-2.tri

@@ -0,0 +1,5 @@
+!module Cycle2
+
+!import "test/cycle-1.tri" Cycle1
+
+cycle2 = t Cycle1.cycle1

test/fork.tri

@@ -1 +1 @@
-t t t 
+main = t t t 

test/lambda-A.tri

@@ -0,0 +1,2 @@
+!module A
+main = (\x : x) t

test/map.tri

@@ -1,24 +1,2 @@
-false = t
-true = t t
-_ = t
-k = t t
-i = t (t k) t
-s = t (t (k t)) t
-m = s i i
-b = s (k s) k
-c = s (s (k s) (s (k k) s)) (k k)
-iC = (\a b c : s a (k c) b)
-yi = (\i : b m (c b (i m)))
-y = yi iC
-triage = (\a b c : t (t a b) c)
-pair = t
-matchList = (\oe oc : triage oe _ oc)
-lconcat = y (\self : matchList (\k : k) (\h r k : pair h (self r k)))
-hmap = y (\self : matchList (\f : t) (\hd tl f : pair (f hd) (self tl f)))
-map = (\f l : hmap l f)
-lAnd = triage (\x : false) (\_ x : x) (\_ _ x : x)
-lOr = triage (\x : x) (\_ _ : true) (\_ _ x : true)
-equal = y (\self : triage (triage true (\z : false) (\y z : false)) (\ax : triage false (self ax) (\y z : false)) (\ax ay : triage false (\z : false) (\bx by : lAnd (self ax bx) (self ay by))))
-
 x = map (\i : lconcat "Successfully concatenated " i) [("two strings!")]
-equal x [("Successfully concatenated two strings!")]
+main = equal? x [("Successfully concatenated two strings!")]

test/modules-1.tri

@@ -0,0 +1,5 @@
+!module Test
+
+!import "lib/base.tri" Lib
+
+main = Lib.not? t

test/modules-2.tri

@@ -0,0 +1 @@
+n = t t t

test/multi-level-A.tri

@@ -0,0 +1,3 @@
+!module A
+!import "./test/multi-level-B.tri" B
+main = B.main

test/multi-level-B.tri

@@ -0,0 +1,3 @@
+!module B
+!import "./test/multi-level-C.tri" C
+main = C.val

test/multi-level-C.tri

@@ -0,0 +1,2 @@
+!module C
+val = t

test/namespace-A.tri

@@ -0,0 +1,3 @@
+!module A
+!import "./test/namespace-B.tri" B
+main = B.x

test/namespace-B.tri

@@ -0,0 +1,2 @@
+!module B
+x = t

test/size.tri

@@ -0,0 +1,21 @@
+compose = \f g x : f (g x)
+
+succ = y (\self :
+  triage
+    1
+    t
+    (triage
+      (t (t t))
+      (\_ tail : t t (self tail))
+      t))
+
+size = (\x :
+  (y (\self x :
+    compose succ
+      (triage
+        (\x : x)
+        self
+        (\x y : compose (self x) (self y))
+        x)) x 0))
+
+size size

test/undefined.tri

@@ -0,0 +1 @@
+namedTerm = undefinedForTesting

test/unresolved-A.tri

@@ -0,0 +1,2 @@
+!module A
+main = undefinedVar

test/vars-A.tri

@@ -0,0 +1,7 @@
+!module A
+
+!import "./test/vars-B.tri" B
+
+!import "./test/vars-C.tri" C
+
+main = B.y (C.z)

test/vars-B.tri

@@ -0,0 +1,2 @@
+!module B
+y = \x : x

test/vars-C.tri

@@ -0,0 +1,2 @@
+!module C
+z = t

tricu.cabal

@@ -1,7 +1,7 @@
 cabal-version: 1.12
 
 name:           tricu
-version:        0.9.0
+version:        0.12.0
 description:    A micro-language for exploring Tree Calculus
 author:         James Eversole
 maintainer:     james@eversole.co