Release 0.6.0

Adds support for several special characters in identifiers. Adds a demo
for converting values to source code and another for checking equality.
Updates the existing demo and tests to reflect new names for functions
returning booleans.

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

@@ -0,0 +1,86 @@
+name: Test, Build, and Release
+
+on: 
+  push:
+    tags:
+      - '*'
+
+jobs:
+  test:
+    container:
+      image: docker.matri.cx/nix-runner:v0.1.0
+      credentials:
+        username: ${{ secrets.REGISTRY_USERNAME }}
+        password: ${{ secrets.REGISTRY_PASSWORD }}
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Set up cache for Cabal
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cache/cabal
+            ~/.config/cabal
+            ~/.local/state/cabal
+          key: cabal-${{ hashFiles('tricu.cabal') }}
+          restore-keys: |
+            cabal-
+
+      - name: Set up cache for Nix
+        uses: actions/cache@v4
+        with:
+          path: |
+            /nix/store
+            /nix/var/nix/cache
+          key: nix-${{ hashFiles('flake.lock') }}
+          restore-keys: |
+            nix-
+
+      - name: Initialize Cabal and update package list
+        run: |
+          nix develop --command cabal update
+
+      - name: Run test suite
+        run: |
+          nix develop --command cabal test
+
+  build:
+    needs: test
+    container:
+      image: docker.matri.cx/nix-runner:v0.1.0
+      credentials:
+        username: ${{ secrets.REGISTRY_USERNAME }}
+        password: ${{ secrets.REGISTRY_PASSWORD }}
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Set up cache for Nix
+        uses: actions/cache@v4
+        with:
+          path: |
+            /nix/store
+            /nix/var/nix/cache
+          key: nix-${{ hashFiles('flake.lock') }}
+          restore-keys: |
+            nix-
+  
+      - name: Build binary
+        run: |
+          nix build
+          ls -alh ./result/bin/tricu
+  
+      - name: Setup go for release actoin
+        uses: actions/setup-go@v5
+        with:
+          go-version: '>=1.20.1'
+  
+      - name: Release binary
+        uses: https://gitea.com/actions/release-action@main
+        with:
+          files: |-
+            ./result/bin/tricu
+          api_key: '${{ secrets.RELEASE_TOKEN }}'

.gitignore

@@ -1,14 +1,11 @@
-bin/
-data/Purr.sqlite
-data/encryptionKey
-/result
-/config.dhall
-/Dockerfile
-/docker-stack.yml
-.stack-work/
 *.swp
-dist*
+*.txt
 *~
 .env
+.stack-work/
+/Dockerfile
+/config.dhall
+/result
 WD
-*.hs.txt
+bin/
+dist*

README.md

@@ -2,7 +2,7 @@
 
 ## Introduction
 
-tricu (pronounced like "tree-shoe" in English) is a purely functional interpreted language implemented in Haskell. [I'm](https://eversole.co) developing tricu to further research the possibilities offered by the various forms of [Tree Calculi](https://github.com/barry-jay-personal/typed_tree_calculus/blob/main/typed_program_analysis.pdf).
+tricu (pronounced "tree-shoe") is a purely functional interpreted language implemented in Haskell. [I'm](https://eversole.co) developing tricu to further research the possibilities offered by the various forms of [Tree Calculi](https://github.com/barry-jay-personal/typed_tree_calculus/blob/main/typed_program_analysis.pdf).
 
 tricu offers minimal syntax sugar yet manages to provide a complete, intuitive, and familiar programming environment. There is great power in simplicity. tricu offers:
 
@@ -19,42 +19,62 @@ tricu is the word for "tree" in Lojban: `(x1) is a tree of species/cultivar (x2)
 ## What does it look like?
 
 ```
--- Anything after `--` on a single line is a comment
+tricu < -- Anything after `--` on a single line is a comment
--- We can define functions or "variables" as Tree Calculus values
+tricu < id = (\a : a) -- Lambda abstraction is eliminated to tree calculus terms
-false = t 
+tricu < head (map (\i : lconcat i " world!") [("Hello, ")])
-_ = t
+tricu > "Hello,  world!"
-true = t t
+tricu < id (head (map (\i : lconcat i " world!") [("Hello, ")]))
--- We can define functions as lambda expressions that are eliminated to Tree
+tricu > "Hello,  world!"
--- Calculus terms.
-id = (\a : a) -- `id` evaluates to the TC form of: t (t (t t)) t
-triage = (\a b c : t (t a b) c)
--- Intensionality! We can inspect program structure, not just inputs/outputs:
-test = triage "Leaf" (\_ : "Stem") (\_ _ : "Fork")
 
--- REPL
+tricu < -- Intensionality! We can inspect the structure of a function.
--- `tricu <` is the input prompt
+tricu < triage = (\a b c : t (t a b) c)
--- `tricu >` is the Tree Calculus form output. Most are elided below.
+tricu < test = triage "Leaf" (\z : "Stem") (\a b : "Fork")
--- `READ -:` is an attempt to interpret the TC output as strings/numbers.
-tricu < test t
-tricu > Fork (Fork Leaf (Fork ...) ... ) 
-READ -: "Leaf"
 tricu < test (t t)
-READ -: "Stem"
+tricu > "Stem"
-tricu < test (t t t)
+tricu < -- We can even write a function to convert a term back to source code
-READ -: "Fork"
+tricu < toSource not?
-tricu < map (\i : listConcat i " is super cool!") [("Tree Calculus") ("Intensionality") ("tricu")]
+tricu > "(t (t (t t) (t t t)) (t t (t t t)))"
-READ -: ["Tree Calculus is super cool!", "Intensionality is super cool!", "tricu is super cool!"]
 ```
 
-## Installation
+## Installation and Use
 
 You can easily build and/or run this project using [Nix](https://nixos.org/download/).
 
-- Run REPL immediately: 
+- Quick Start (REPL): 
   - `nix run git+https://git.eversole.co/James/tricu`
-- Build REPL executable in `./result/bin`: 
+- Build executable in `./result/bin`: 
   - `nix build git+https://git.eversole.co/James/tricu`
 
+`./result/bin/tricu --help`
+
+```
+tricu Evaluator and REPL
+
+tricu [COMMAND] ... [OPTIONS]
+  tricu: Exploring Tree Calculus
+
+Common flags:
+  -? --help       Display help message
+  -V --version    Print version information
+
+tricu [repl] [OPTIONS]
+  Start interactive REPL
+
+tricu eval [OPTIONS]
+  Evaluate tricu and return the result of the final expression.
+
+  -f --file=FILE  Input file path(s) for evaluation.
+                    Defaults to stdin.
+  -t --form=FORM  Optional output form: (tree|fsl|ast|ternary|ascii).
+                    Defaults to tricu-compatible `t` tree form.
+
+tricu decode [OPTIONS]
+  Decode a Tree Calculus value into a string representation.
+
+  -f --file=FILE  Optional input file path to attempt decoding.
+                    Defaults to stdin.
+```
+
 ## Acknowledgements 
 
 Tree Calculus was discovered by [Barry Jay](https://github.com/barry-jay-personal/blog). 

demos/equality.tri

@@ -0,0 +1,24 @@
+false = t
+true  = t t
+
+triage = (\a b c : t (t a b) c)
+
+matchBool = (\ot of : triage
+  of
+  (\_ : ot)
+  (\_ _ : ot)
+)
+
+not_TC?     = t (t (t t) (t t t)) (t t (t t t))
+not_Lambda? = matchBool false true
+
+areEqual? = equal not_TC not_Lambda
+
+true_TC?  = not_TC false
+false_TC? = not_TC true
+
+true_Lambda?  = not_Lambda false
+false_Lambda? = not_Lambda true
+
+areTrueEqual?  = equal true_TC  true_Lambda
+areFalseEqual? = equal false_TC false_Lambda

demos/levelOrderTraversal.tri

@@ -0,0 +1,65 @@
+-- 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 notation of empty nodes. Empty nodes can be represented 
+-- with an empty list, `[]`, which is equivalent to a single node `t`. 
+--
+-- Example tree inputs:
+-- [("1") [("2") [("4") t t] t] [("3") [("5") t t] [("6") t t]]]]
+-- Graph:
+--       1
+--      / \
+--     2   3
+--    /   /  \
+--   4   5    6
+--
+
+label = (\node : head node)
+
+left  = (\node : if (emptyList node) 
+  [] 
+  (if (emptyList (tail node)) 
+    [] 
+    (head (tail node))))
+
+right = (\node : if (emptyList node) 
+  [] 
+  (if (emptyList (tail node)) 
+    [] 
+    (if (emptyList (tail (tail node))) 
+      [] 
+      (head (tail (tail node))))))
+
+processLevel = y (\self queue : if (emptyList queue) 
+  [] 
+  (pair (map label queue) (self (filter 
+    (\node : not (emptyList node)) 
+      (lconcat (map left queue) (map right queue))))))
+
+levelOrderTraversal_ = (\a : processLevel (t a t))
+
+toLineString = y (\self levels : if (emptyList levels) 
+  "" 
+  (lconcat 
+    (lconcat (map (\x : lconcat x " ") (head levels)) "") 
+    (if (emptyList (tail levels)) "" (lconcat (t (t 10 t) t) (self (tail levels))))))
+
+levelOrderToString = (\s : toLineString (levelOrderTraversal_ s))
+
+flatten = foldl (\acc x : lconcat acc x) ""
+
+levelOrderTraversal = (\s : lconcat (t 10 t) (flatten (levelOrderToString s)))
+
+exampleOne = levelOrderTraversal [("1") 
+                                 [("2") [("4") t t] t] 
+                                 [("3") [("5") t t] [("6") t t]]]
+
+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/toSource.tri

@@ -0,0 +1,46 @@
+-- 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.
+
+-- Triage takes four arguments: the first three represent behaviors for each 
+-- structural case in Tree Calculus (Leaf, Stem, and Fork).
+-- The fourth argument is the value whose structure is inspected. By evaluating 
+-- the Tree Calculus term, `triage` enables branching logic based on the term's 
+-- shape, making it possible to perform structure-specific operations such as
+-- reconstructing the terms' source code representation.
+triage = (\a b c : t (t a b) c)
+
+-- Base case of a single Leaf
+sourceLeaf = t (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.
+
+-- 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.
+
+-- Wrapper around triage 
+toSource_ = y (\self arg :
+  triage
+    sourceLeaf        -- Triage `a` case, Leaf
+    (sourceStem self) -- Triage `b` case, Stem
+    (sourceFork self) -- Triage `c` case, Fork
+    arg)              -- The term to be inspected
+
+-- 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)))"

lib/base.tri

@@ -0,0 +1,96 @@
+false = t
+_     = t
+true  = 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)
+iD    = b (b iC) iC
+iE    = b (b iD) iC
+yi    = (\i : b m (c b (i m)))
+y     = yi iC
+yC    = yi iD
+yD    = yi iE
+id    = (\a : a)
+pair  = t
+if    = (\cond then else : t (t else (t t then)) t cond)
+
+triage = (\a b c : t (t a b) c)
+test   = triage "Leaf" (\_ : "Stem") (\_ _ : "Fork")
+
+matchBool = (\ot of : triage 
+  of 
+  (\_ : ot) 
+  (\_ _ : ot)
+)
+
+matchList = (\oe oc : triage 
+  oe 
+  _ 
+  oc
+)
+
+matchPair = (\op : triage 
+  _ 
+  _ 
+  op
+)
+
+not? = matchBool false true
+and? = matchBool id (\_ : false)
+emptyList? = matchList true (\_ _ : false)
+
+head = matchList t (\head _ : head)
+tail = matchList t (\_ tail : tail)
+
+lconcat = y (\self : matchList 
+  (\k : k) 
+  (\h r k : pair h (self r k)))
+
+lAnd = (triage 
+  (\_     : false) 
+  (\_ x   : x) 
+  (\_ _ x : x)
+)
+
+lOr = (triage 
+  (\x     : x) 
+  (\_ _   : true) 
+  (\_ _ _ : true)
+)
+
+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) 
+      (\bx by : lAnd (self ax bx) (self ay by))))
+
+filter_ = y (\self : matchList 
+  (\_ : t) 
+  (\head tail f : matchBool (t head) i (f head) (self tail f)))
+filter  = (\f l : filter_ l f)
+
+foldl_ = y (\self f l x : matchList (\acc : acc) (\head tail acc : self f tail (f acc head)) l x)
+foldl  = (\f x l : foldl_ f l x)
+
+foldr_ = y (\self x f l : matchList x (\head tail : f (self x f tail) head) l)
+foldr  = (\f x l : foldr_ x f l)

shell.nix

@@ -1,8 +0,0 @@
-{ pkgs ? import <nixpkgs> {} }:
-let x = pkgs.haskellPackages.ghcWithPackages (hpkgs: with hpkgs; [
-		megaparsec
-  ]);
-in
-pkgs.mkShell {
-  buildInputs = [ x ];
-}

src/Eval.hs

@@ -3,119 +3,90 @@ module Eval where
 import Parser
 import Research
 
-import Data.Map (Map)
+import Data.Map  (Map)
-import Data.List (foldl')
 
 import qualified Data.Map as Map
 import qualified Data.Set as Set
 
-evalSingle :: Map String T -> TricuAST -> Map String T
+evalSingle :: Env -> TricuAST -> Env
-evalSingle env term = case term of
+evalSingle env term
-  SFunc name [] body ->
+  | SFunc name [] body <- term =
-    let lineNoLambda = eliminateLambda body
+      let res = evalAST env body
-        result = evalAST env lineNoLambda
+      in Map.insert "__result" res (Map.insert name res env)
-    in Map.insert name result env
+  | SApp func arg <- term =
-  SLambda _ body ->
+      let res = apply (evalAST env func) (evalAST env arg)
-    let result = evalAST env body
+      in Map.insert "__result" res env
-    in Map.insert "__result" result env
+  | SVar name <- term =
-  SApp func arg ->
+      case Map.lookup name env of
-    let result = apply (evalAST env $ eliminateLambda func) (evalAST env $ eliminateLambda arg)
+        Just v  -> Map.insert "__result" v env
-    in Map.insert "__result" result env
+        Nothing -> errorWithoutStackTrace $ "Variable " ++ name ++ " not defined"
-  SVar name ->
+  | otherwise =
-    case Map.lookup name env of
+      Map.insert "__result" (evalAST env term) env
-      Just value -> Map.insert "__result" value env
-      Nothing -> error $ "Variable " ++ name ++ " not defined"
-  _ ->
-    let result = evalAST env term
-    in Map.insert "__result" result env
 
-evalTricu :: Map String T -> [TricuAST] -> Map String T
+evalTricu :: Env -> [TricuAST] -> Env
-evalTricu env [] = env
+evalTricu env []     = env
-evalTricu env [lastLine] =
+evalTricu env [x]    =
-    let lastLineNoLambda = eliminateLambda lastLine
+  let updatedEnv = evalSingle env x
-        updatedEnv = evalSingle env lastLineNoLambda
+  in Map.insert "__result" (result updatedEnv) updatedEnv
-    in Map.insert "__result" (result updatedEnv) updatedEnv
+evalTricu env (x:xs) =
-evalTricu env (line:rest) =
+  evalTricu (evalSingle env x) xs
-    let lineNoLambda = eliminateLambda line
-        updatedEnv = evalSingle env lineNoLambda
-    in evalTricu updatedEnv rest
 
-evalAST :: Map String T -> TricuAST -> T
+evalAST :: Env -> TricuAST -> T
-evalAST env term = case term of
+evalAST env term
-    SVar name -> case Map.lookup name env of
+  | SLambda _ _ <- term = evalAST env (elimLambda term)
-        Just value -> value
+  | SVar   name <- term = evalVar name
-        Nothing -> error $ "Variable " ++ name ++ " not defined"
+  | TLeaf       <- term = Leaf
-    TLeaf -> Leaf
+  | TStem  t    <- term = Stem (evalAST env t)
-    TStem t -> Stem (evalAST env t)
+  | TFork  t u  <- term = Fork (evalAST env t) (evalAST env u)
-    TFork t1 t2 -> Fork (evalAST env t1) (evalAST env t2)
+  | SApp   t u  <- term = apply (evalAST env t) (evalAST env u)
-    SApp t1 t2 -> apply (evalAST env t1) (evalAST env t2)
+  | SStr   s    <- term = ofString s
-    SStr str -> ofString str
+  | SInt   n    <- term = ofNumber n
-    SInt num -> ofNumber num
+  | SList  xs   <- term = ofList (map (evalAST env) xs)
-    SList elems -> ofList (map (evalAST Map.empty) elems)
+  | SEmpty      <- term = Leaf
-    SEmpty -> Leaf
+  | otherwise           = errorWithoutStackTrace "Unexpected AST term"
-    SFunc name args body ->
+    where
-        error $ "Unexpected function definition " ++ name
+      evalVar name = Map.findWithDefault
-        ++ " in evalAST; define via evalSingle."
+        (errorWithoutStackTrace $ "Variable " ++ name ++ " not defined")
-    SLambda {} -> error "Internal error: SLambda found in evalAST after elimination."
+        name env
-
-eliminateLambda :: TricuAST -> TricuAST
-eliminateLambda (SLambda (v:vs) body)
-  | null vs = lambdaToT v (eliminateLambda body)
-  | otherwise = eliminateLambda (SLambda [v] (SLambda vs body))
-eliminateLambda (SApp f arg) = SApp (eliminateLambda f) (eliminateLambda arg)
-eliminateLambda (TStem t) = TStem (eliminateLambda t)
-eliminateLambda (TFork l r) = TFork (eliminateLambda l) (eliminateLambda r)
-eliminateLambda (SList xs) = SList (map eliminateLambda xs)
-eliminateLambda other = other
 
 -- https://github.com/barry-jay-personal/typed_tree_calculus/blob/main/typed_program_analysis.pdf
 -- Chapter 4: Lambda-Abstraction
-lambdaToT :: String -> TricuAST -> TricuAST
+elimLambda :: TricuAST -> TricuAST
-lambdaToT x (SVar y)
+elimLambda = go
-  | x == y = tI
+  where
-lambdaToT x (SVar y)
+    go (SLambda (v:vs) body)
-  | x /= y = SApp tK (SVar y)
+      | null vs              = toSKI v (elimLambda body)
-lambdaToT x t
+      | otherwise            = elimLambda (SLambda [v] (SLambda vs body))
-  | not (isFree x t) = SApp tK t
+    go (SApp f g)            = SApp (elimLambda f) (elimLambda g)
-lambdaToT x (SApp n u)
+    go x                     = x
-  | not (isFree x (SApp n u)) = SApp tK (SApp (eliminateLambda n) (eliminateLambda u))
-lambdaToT x (SApp n u) = SApp (SApp tS (lambdaToT x (eliminateLambda n))) (lambdaToT x (eliminateLambda u))
-lambdaToT x body
-  | not (isFree x body) = SApp tK body
-  | otherwise = SApp (SApp tS (lambdaToT x body)) TLeaf
 
-freeVars :: TricuAST -> Set.Set String
+    toSKI x (SVar y)
-freeVars (SVar v) = Set.singleton v
+      | x == y           = _I
-freeVars (SInt _) = Set.empty
+      | otherwise        = SApp _K (SVar y)
-freeVars (SStr _) = Set.empty
+    toSKI x t@(SApp n u)
-freeVars (SList xs) = foldMap freeVars xs
+      | not (isFree x t) = SApp _K t
-freeVars (SApp f arg) = freeVars f <> freeVars arg
+      | otherwise        = SApp (SApp _S (toSKI x n)) (toSKI x u)
-freeVars TLeaf = Set.empty
+    toSKI x t
-freeVars (SFunc _ _ b) = freeVars b
+      | not (isFree x t) = SApp _K t
-freeVars (TStem t) = freeVars t
+      | otherwise        = SApp (SApp _S (toSKI x t)) TLeaf
-freeVars (TFork l r) = freeVars l <> freeVars r
-freeVars (SLambda vs b) = foldr Set.delete (freeVars b) vs
 
-isFree :: String -> TricuAST -> Bool
+    _S = parseSingle "t (t (t t t)) t"
-isFree x = Set.member x . freeVars
+    _K = parseSingle "t t"
+    _I = parseSingle "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
 
-toAST :: T -> TricuAST
+result :: Env -> T
-toAST Leaf = TLeaf
-toAST (Stem a) = TStem (toAST a)
-toAST (Fork a b) = TFork (toAST a) (toAST b)
-
--- We need the SKI operators in an unevaluated TricuAST tree form so that we
--- can keep the evaluation functions straightforward
-tI :: TricuAST
-tI = SApp (SApp TLeaf (SApp TLeaf (SApp TLeaf TLeaf))) TLeaf
-
-tK :: TricuAST
-tK = SApp TLeaf TLeaf
-
-tS :: TricuAST
-tS = SApp (SApp TLeaf (SApp TLeaf (SApp (SApp TLeaf TLeaf) TLeaf))) TLeaf
-
-result :: Map String T -> T
 result r = case Map.lookup "__result" r of
-    Just a -> a
+  Just a -> a
-    Nothing -> error "No __result field found in provided environment"
+  Nothing -> errorWithoutStackTrace "No __result field found in provided environment"

src/FileEval.hs

@@ -0,0 +1,30 @@
+module FileEval where
+
+import Eval
+import Parser
+import Research
+
+import System.IO
+
+import qualified Data.Map as Map
+
+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"
+
+evaluateFile :: FilePath -> IO Env
+evaluateFile filePath = do
+  contents <- readFile filePath
+  let asts = parseTricu contents
+  pure $ evalTricu Map.empty asts
+
+evaluateFileWithContext :: Env -> FilePath -> IO Env
+evaluateFileWithContext env filePath = do
+  contents <- readFile filePath
+  let asts = parseTricu contents
+  pure $ evalTricu env asts

src/Lexer.hs

@@ -1,38 +1,28 @@
 module Lexer where
 
 import Research
+
+import Control.Monad               (void)
+import Data.Void
 import Text.Megaparsec
 import Text.Megaparsec.Char hiding (space)
 import Text.Megaparsec.Char.Lexer
 
-import Control.Monad (void)
-import Data.Void
-
 import qualified Data.Set as Set
 
 type Lexer = Parsec Void String
 
-data LToken
-  = LKeywordT
-  | LIdentifier String
-  | LIntegerLiteral Int
-  | LStringLiteral String
-  | LAssign
-  | LColon
-  | LBackslash
-  | LOpenParen
-  | LCloseParen
-  | LOpenBracket
-  | LCloseBracket
-  | LNewline
-  deriving (Show, Eq, Ord)
-
 keywordT :: Lexer LToken
 keywordT = string "t" *> notFollowedBy alphaNumChar *> pure LKeywordT
 
 identifier :: Lexer LToken
 identifier = do
-  name <- some (letterChar <|> char '_' <|> char '-')
+  first <- letterChar <|> char '_'
+  rest  <- many $ letterChar 
+              <|> digitChar 
+              <|> 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"
     else return (LIdentifier name)
@@ -46,11 +36,8 @@ stringLiteral :: Lexer LToken
 stringLiteral = do
   char '"'
   content <- many (noneOf ['"'])
-  if null content
+  char '"' --"
-    then fail "Empty string literals are not allowed"
+  return (LStringLiteral content)
-    else do
-      char '"' --"
-      return (LStringLiteral content)
 
 assign :: Lexer LToken
 assign = char '=' *> pure LAssign
@@ -77,7 +64,10 @@ lnewline :: Lexer LToken
 lnewline = char '\n' *> pure LNewline
 
 sc :: Lexer ()
-sc = space space1 (skipLineComment "--") (skipBlockComment "|-" "-|")
+sc = space
+  (void $ takeWhile1P (Just "space") (\c -> c == ' ' || c == '\t'))
+  (skipLineComment "--")
+  (skipBlockComment "|-" "-|")
 
 tricuLexer :: Lexer [LToken]
 tricuLexer = do
@@ -91,7 +81,8 @@ tricuLexer = do
   pure tokens
     where
       tricuLexer' = 
-        [ try identifier
+        [ try lnewline
+        , try identifier
         , try keywordT
         , try integerLiteral
         , try stringLiteral
@@ -104,8 +95,7 @@ tricuLexer = do
         , closeBracket
         ]
 
-
 lexTricu :: String -> [LToken]
 lexTricu input = case runParser tricuLexer "" input of
-  Left err -> error $ "Lexical error:\n" ++ errorBundlePretty err
+  Left err -> errorWithoutStackTrace $ "Lexical error:\n" ++ errorBundlePretty err
   Right tokens -> tokens

src/Library.hs

@@ -1,46 +0,0 @@
-module Library where
-
-import Eval
-import Parser
-import Research
-
-import qualified Data.Map as Map
-
-library :: Map.Map String T
-library = evalTricu Map.empty $ parseTricu $ unlines 
-  [ "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)"
-  , "iD = b (b iC) iC"
-  , "iE = b (b iD) iC"
-  , "yi = (\\i : b m (c b (i m)))"
-  , "y = yi iC"
-  , "yC = yi iD"
-  , "yD = yi iE"
-  , "id = (\\a : a)"
-  , "triage = (\\a b c : t (t a b) c)"
-  , "pair = t"
-  , "matchBool = (\\ot of : triage of (\\_ : ot) (\\_ _ : ot))"
-  , "matchList = (\\oe oc : triage oe _ oc)"
-  , "matchPair = (\\op : triage _ _ op)"
-  , "not = matchBool false true"
-  , "and = matchBool id (\\z : false)"
-  , "if = (\\cond then else : t (t else (t t then)) t cond)"
-  , "test = triage \"Leaf\" (\\z : \"Stem\") (\\a b : \"Fork\")"
-  , "emptyList = matchList true (\\y z : false)"
-  , "head = matchList t (\\hd tl : hd)"
-  , "tail = matchList t (\\hd tl : tl)"
-  , "listConcat = y (\\self : matchList (\\k : k) (\\h r k : pair h (self r k)))"
-  , "lAnd = triage (\\x : false) (\\_ x : x) (\\_ _ x : x)"
-  , "lOr = triage (\\x : x) (\\_ _ : true) (\\_ _ x : true)"
-  , "hmap = y (\\self : matchList (\\f : t) (\\hd tl f : pair (f hd) (self tl f)))"
-  , "map = (\\f l : hmap l f)"
-  , "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))))" 
-  ]

src/Main.hs

@@ -1,22 +1,87 @@
 module Main where
 
-import Eval     (evalTricu, result)
+import Eval                   (evalTricu, result)
-import Library  (library)
+import FileEval
-import Parser   (parseTricu)
+import Parser                 (parseTricu)
-import REPL     (repl)
+import REPL
-import Research (T)
+import Research
 
-import Text.Megaparsec (runParser)
+import Control.Monad          (foldM)
+import Control.Monad.IO.Class (liftIO)
+import Text.Megaparsec        (runParser)
+import System.Console.CmdArgs
 
 import qualified Data.Map as Map
 
+data TricuArgs
+  = Repl
+  | Evaluate { file :: [FilePath], form :: EvaluatedForm }
+  | Decode { file :: [FilePath] }
+  deriving (Show, Data, Typeable)
+
+replMode :: TricuArgs
+replMode = Repl
+  &= help "Start interactive REPL"
+  &= auto
+  &= name "repl"
+
+evaluateMode :: TricuArgs
+evaluateMode = Evaluate
+  { file = def &= help "Input file path(s) for evaluation.\n \
+      \ Defaults to stdin."
+      &= name "f" &= typ "FILE"
+    , form = TreeCalculus &= typ "FORM"
+      &= help "Optional output form: (tree|fsl|ast|ternary|ascii).\n \
+      \ Defaults to tricu-compatible `t` tree form."
+      &= name "t"
+  }
+  &= help "Evaluate tricu and return the result of the final expression."
+  &= explicit
+  &= name "eval"
+
+decodeMode :: TricuArgs
+decodeMode = Decode
+  { file = def
+    &= help "Optional input file path to attempt decoding.\n \
+    \ Defaults to stdin."
+    &= name "f" &= typ "FILE"
+  }
+  &= help "Decode a Tree Calculus value into a string representation."
+  &= explicit
+  &= name "decode"
+
 main :: IO ()
 main = do
-  putStrLn "Welcome to the tricu Interpreter"
+  args <- cmdArgs $ modes [replMode, evaluateMode, decodeMode]
-  putStrLn "You can exit at any time by typing and entering: "
+    &= help "tricu: Exploring Tree Calculus"
-  putStrLn ":_exit"
+    &= program "tricu"
-  repl library
+    &= summary "tricu Evaluator and REPL"
+  case args of
+    Repl -> 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
+    Evaluate { file = filePaths, form = form } -> do
+      result <- case filePaths of
+        [] -> do
+          t <- getContents
+          pure $ runTricu t
+        (filePath:restFilePaths) -> do
+            initialEnv <- evaluateFile filePath
+            finalEnv <- foldM evaluateFileWithContext initialEnv restFilePaths
+            pure $ result finalEnv
+      let fRes = formatResult form result
+      putStr fRes
+    Decode { file = filePaths } -> do
+      value <- case filePaths of
+        [] -> getContents
+        (filePath:_) -> readFile filePath
+      library <- liftIO $ evaluateFile "./lib/base.tri"
+      putStrLn $ decodeResult $ result $ evalTricu library $ parseTricu value
 
 runTricu :: String -> T
-runTricu s = result (evalTricu Map.empty $ parseTricu s)
+runTricu input =
-runTricuEnv env s = result (evalTricu env $ parseTricu s)
+  let asts     = parseTricu input
+      finalEnv = evalTricu Map.empty asts
+   in result finalEnv

src/Parser.hs

@@ -1,262 +1,304 @@
 module Parser where
 
 import Lexer
-import Research hiding (toList)
+import Research
 
+import Control.Monad (void)
+import Control.Monad.State
 import Data.List.NonEmpty (toList)
 import Data.Void (Void)
 import Text.Megaparsec
-import Text.Megaparsec.Char
+import Text.Megaparsec.Error (ParseErrorBundle, errorBundlePretty)
-import Text.Megaparsec.Error (errorBundlePretty, ParseErrorBundle)
-
 import qualified Data.Set as Set
 
-type Parser = Parsec Void [LToken]
+data PState = PState
+  { parenDepth  :: Int
+  , bracketDepth :: Int
+  } deriving (Show)
 
-data TricuAST
+type ParserM = StateT PState (Parsec Void [LToken])
-  = SVar String
+
-  | SInt Int
+satisfyM :: (LToken -> Bool) -> ParserM LToken
-  | SStr String
+satisfyM f = do
-  | SList [TricuAST]
+  token <- lift (satisfy f)
-  | SFunc String [String] TricuAST
+  modify' (updateDepth token)
-  | SApp TricuAST TricuAST
+  return token
-  | TLeaf
+
-  | TStem TricuAST
+updateDepth :: LToken -> PState -> PState
-  | TFork TricuAST TricuAST
+updateDepth LOpenParen    st = st { parenDepth   = parenDepth st   + 1 }
-  | SLambda [String] TricuAST
+updateDepth LOpenBracket  st = st { bracketDepth = bracketDepth st + 1 }
-  | SEmpty
+updateDepth LCloseParen   st = st { parenDepth   = parenDepth st   - 1 }
-  deriving (Show, Eq, Ord)
+updateDepth LCloseBracket st = st { bracketDepth = bracketDepth st - 1 }
+updateDepth _ st = st
+
+topLevelNewline :: ParserM ()
+topLevelNewline = do
+  st <- get
+  if parenDepth st == 0 && bracketDepth st == 0
+    then void (satisfyM (== LNewline))
+    else fail "Top-level exit in nested context (paren or bracket)"
+
+parseProgram :: [LToken] -> Either (ParseErrorBundle [LToken] Void) [TricuAST]
+parseProgram tokens =
+  runParser (evalStateT (parseProgramM <* finalizeDepth <* eof) (PState 0 0)) "" tokens
+
+parseSingleExpr :: [LToken] -> Either (ParseErrorBundle [LToken] Void) TricuAST
+parseSingleExpr tokens =
+  runParser (evalStateT (scnParserM *> parseExpressionM <* finalizeDepth <* eof) (PState 0 0)) "" tokens
+
+finalizeDepth :: ParserM ()
+finalizeDepth = do
+  st <- get
+  case (parenDepth st, bracketDepth st) of
+    (0, 0) -> pure ()
+    (p, b) -> fail $ "Unmatched tokens: " ++ show (p, b)
 
 parseTricu :: String -> [TricuAST]
-parseTricu input
+parseTricu input =
-  | null tokens = []
+  case lexTricu input of
-  | otherwise = map parseSingle tokens
+    [] -> []
-  where
+    toks ->
-    tokens = case lexTricu input of
+      case parseProgram toks of
-      [] -> []
+        Left err   -> errorWithoutStackTrace (handleParseError err)
-      tokens -> lines input
+        Right asts -> asts
 
 parseSingle :: String -> TricuAST
-parseSingle input = case lexTricu input of
+parseSingle input =
-  [] -> SEmpty
+  case lexTricu input of
-  tokens -> case runParser parseExpression "" tokens of
+    [] -> SEmpty
-    Left err -> error $ handleParseError err
+    toks ->
-    Right ast -> ast
+      case parseSingleExpr toks of
+        Left err -> errorWithoutStackTrace (handleParseError err)
+        Right ast -> ast
 
-parseExpression :: Parser TricuAST
+parseProgramM :: ParserM [TricuAST]
-parseExpression = choice
+parseProgramM = do
-  [ try parseFunction
+  skipMany topLevelNewline
-  , try parseLambda
+  exprs <- sepEndBy parseOneExpression (some topLevelNewline)
-  , try parseLambdaExpression
+  skipMany topLevelNewline
-  , try parseListLiteral
+  return exprs
-  , try parseApplication
+
-  , try parseTreeTerm
+parseOneExpression :: ParserM TricuAST
-  , parseLiteral
+parseOneExpression = scnParserM *> parseExpressionM
+
+scnParserM :: ParserM ()
+scnParserM = skipMany $ do
+  t  <- lookAhead anySingle
+  st <- get
+  if | (parenDepth st > 0 || bracketDepth st > 0) && case t of
+         LNewline -> True
+         _        -> False -> void $ satisfyM $ \case
+           LNewline -> True
+           _        -> False
+     | otherwise -> fail "In nested context or no space token" <|> empty
+
+
+eofM :: ParserM ()
+eofM = lift eof
+
+parseExpressionM :: ParserM TricuAST
+parseExpressionM = choice
+  [ try parseFunctionM
+  , try parseLambdaM
+  , try parseLambdaExpressionM
+  , try parseListLiteralM
+  , try parseApplicationM
+  , try parseTreeTermM
+  , parseLiteralM
   ]
 
-scnParser :: Parser ()
+parseFunctionM :: ParserM TricuAST
-scnParser = skipMany (satisfy isNewline)
+parseFunctionM = do
+  LIdentifier name <- satisfyM $ \case
+    LIdentifier _ -> True
+    _             -> False
+  args <- many $ satisfyM $ \case
+    LIdentifier _ -> True
+    _             -> False
+  _    <- satisfyM (== LAssign)
+  scnParserM
+  body <- parseExpressionM
+  pure (SFunc name (map getIdentifier args) body)
 
-parseFunction :: Parser TricuAST
+parseLambdaM :: ParserM TricuAST
-parseFunction = do
+parseLambdaM =
-  LIdentifier name <- satisfy isIdentifier
+  between (satisfyM (== LOpenParen)) (satisfyM (== LCloseParen)) $ do
-  args <- many (satisfy isIdentifier)
+    _     <- satisfyM (== LBackslash)
-  satisfy (== LAssign)
+    param <- satisfyM $ \case
-  body <- parseExpression
+      LIdentifier _ -> True
-  return (SFunc name (map getIdentifier args) body)
+      _             -> False
+    rest  <- many $ satisfyM $ \case
+      LIdentifier _ -> True
+      _             -> False
+    _     <- satisfyM (== LColon)
+    scnParserM
+    body <- parseLambdaExpressionM
+    let nested = foldr (\v acc -> SLambda [getIdentifier v] acc) body rest
+    pure (SLambda [getIdentifier param] nested)
 
-parseAtomicBase :: Parser TricuAST
+parseLambdaExpressionM :: ParserM TricuAST
-parseAtomicBase = choice
+parseLambdaExpressionM = choice
-    [ try parseVarWithoutAssignment
+  [ try parseLambdaApplicationM
-    , parseTreeLeaf
+  , parseAtomicLambdaM
-    , parseGrouped
-    ]
-parseVarWithoutAssignment :: Parser TricuAST
-parseVarWithoutAssignment = do
-    LIdentifier name <- satisfy isIdentifier
-    if (name == "t" || name == "__result")
-    then fail $ "Reserved keyword: " ++ name ++ " cannot be assigned."
-    else notFollowedBy (satisfy (== LAssign)) *> return (SVar name)
-
-parseLambda :: Parser TricuAST
-parseLambda = between (satisfy (== LOpenParen)) (satisfy (== LCloseParen)) $ do
-  satisfy (== LBackslash)
-  param    <- satisfy isIdentifier
-  rest     <- many (satisfy isIdentifier)
-  satisfy (== LColon)
-  body     <- parseLambdaExpression
-  let nestedLambda = foldr (\v acc -> SLambda [v] acc) body (map getIdentifier rest)
-  return (SLambda [getIdentifier param] nestedLambda)
-
-parseLambdaExpression :: Parser TricuAST
-parseLambdaExpression = choice
-  [ try parseLambdaApplication
-  , parseAtomicLambda
   ]
 
-parseAtomicLambda :: Parser TricuAST
+parseAtomicLambdaM :: ParserM TricuAST
-parseAtomicLambda = choice
+parseAtomicLambdaM = choice
-  [ parseVar
+  [ parseVarM
-  , parseTreeLeaf
+  , parseTreeLeafM
-  , parseLiteral
+  , parseLiteralM
-  , parseListLiteral
+  , parseListLiteralM
-  , try parseLambda
+  , try parseLambdaM
-  , between (satisfy (== LOpenParen)) (satisfy (== LCloseParen)) parseLambdaExpression
+  , between (satisfyM (== LOpenParen)) (satisfyM (== LCloseParen)) parseLambdaExpressionM
   ]
 
-parseApplication :: Parser TricuAST
+parseApplicationM :: ParserM TricuAST
-parseApplication = do
+parseApplicationM = do
-  func <- parseAtomicBase
+  func <- parseAtomicBaseM
-  args <- many parseAtomic
+  scnParserM
-  return $ foldl (\acc arg -> SApp acc arg) func args
+  args <- many $ do
+    scnParserM
+    arg <- parseAtomicM
+    return arg
+  return $ foldl SApp func args
 
-parseLambdaApplication :: Parser TricuAST
+parseLambdaApplicationM :: ParserM TricuAST
-parseLambdaApplication = do
+parseLambdaApplicationM = do
-  func <- parseAtomicLambda
+  func <- parseAtomicLambdaM
-  args <- many parseAtomicLambda
+  scnParserM
-  return $ foldl (\acc arg -> SApp acc arg) func args
+  args <- many $ do
+    arg <- parseAtomicLambdaM
+    scnParserM
+    pure arg
+  pure $ foldl SApp func args
 
-isTreeTerm :: TricuAST -> Bool
+parseAtomicBaseM :: ParserM TricuAST
-isTreeTerm TLeaf = True
+parseAtomicBaseM = choice
-isTreeTerm (TStem _) = True
+  [ parseTreeLeafM
-isTreeTerm (TFork _ _) = True
+  , parseGroupedM
-isTreeTerm _ = False
+  ]
 
-parseTreeLeaf :: Parser TricuAST
+parseTreeLeafM :: ParserM TricuAST
-parseTreeLeaf = satisfy isKeywordT *> notFollowedBy (satisfy (== LAssign)) *> pure TLeaf
+parseTreeLeafM = do
+  _ <- satisfyM $ \case
+    LKeywordT -> True
+    _         -> False
+  notFollowedBy $ lift $ satisfy (== LAssign)
+  pure TLeaf
+
+parseTreeTermM :: ParserM TricuAST
+parseTreeTermM = do
+  base <- parseTreeLeafOrParenthesizedM
+  rest <- many parseTreeLeafOrParenthesizedM
+  pure (foldl combine base rest)
+  where
+    combine acc next
+      | TLeaf     <- acc = TStem next
+      | TStem t   <- acc = TFork t next
+      | TFork _ _ <- acc = TFork acc next
+
+parseTreeLeafOrParenthesizedM :: ParserM TricuAST
+parseTreeLeafOrParenthesizedM = choice
+  [ between (satisfyM (== LOpenParen)) (satisfyM (== LCloseParen)) parseTreeTermM
+  , parseTreeLeafM
+  ]
+
+parseAtomicM :: ParserM TricuAST
+parseAtomicM = choice
+  [ parseVarM
+  , parseTreeLeafM
+  , parseListLiteralM
+  , parseGroupedM
+  , parseLiteralM
+  ]
+
+parseGroupedM :: ParserM TricuAST
+parseGroupedM = between (satisfyM (== LOpenParen)) (satisfyM (== LCloseParen)) $
+  scnParserM *> parseExpressionM <* scnParserM
+
+parseLiteralM :: ParserM TricuAST
+parseLiteralM = choice
+  [ parseIntLiteralM
+  , parseStrLiteralM
+  ]
+
+parseListLiteralM :: ParserM TricuAST
+parseListLiteralM = do
+  _        <- satisfyM (== LOpenBracket)
+  elements <- many $ do
+    scnParserM
+    parseListItemM
+  scnParserM
+  _        <- satisfyM (== LCloseBracket)
+  pure (SList elements)
+
+parseListItemM :: ParserM TricuAST
+parseListItemM = choice
+  [ parseGroupedItemM
+  , parseListLiteralM
+  , parseSingleItemM
+  ]
+
+parseGroupedItemM :: ParserM TricuAST
+parseGroupedItemM = do
+  _     <- satisfyM (== LOpenParen)
+  inner <- parseExpressionM
+  _     <- satisfyM (== LCloseParen)
+  pure inner
+
+parseSingleItemM :: ParserM TricuAST
+parseSingleItemM = do
+  token <- satisfyM $ \case
+    LIdentifier _ -> True
+    LKeywordT     -> True
+    _             -> False
+  case token of
+    LIdentifier name -> pure (SVar name)
+    LKeywordT        -> pure TLeaf
+    _                -> fail "Unexpected token in list item"
+
+parseVarM :: ParserM TricuAST
+parseVarM = do
+  LIdentifier name <- satisfyM $ \case
+    LIdentifier _ -> True
+    _             -> False
+  if name == "t" || name == "__result"
+    then fail ("Reserved keyword: " ++ name ++ " cannot be assigned.")
+    else pure (SVar name)
+
+parseIntLiteralM :: ParserM TricuAST
+parseIntLiteralM = do
+  LIntegerLiteral value <- satisfyM $ \case
+    LIntegerLiteral _ -> True
+    _                 -> False
+  pure (SInt value)
+
+parseStrLiteralM :: ParserM TricuAST
+parseStrLiteralM = do
+  LStringLiteral value <- satisfyM $ \case 
+    LStringLiteral _ -> True
+    _ -> False
+  pure (SStr value)
 
 getIdentifier :: LToken -> String
 getIdentifier (LIdentifier name) = name
-getIdentifier _ = error "Expected identifier"
+getIdentifier _                  = errorWithoutStackTrace "Expected identifier"
 
-parseTreeTerm :: Parser TricuAST
-parseTreeTerm = do
-  base <- parseTreeLeafOrParenthesized
-  rest <- many parseTreeLeafOrParenthesized
-  pure $ foldl combine base rest
-  where
-    combine acc next = case acc of
-      TLeaf -> TStem next
-      TStem t -> TFork t next
-      TFork _ _ -> TFork acc next
-
-parseTreeLeafOrParenthesized :: Parser TricuAST
-parseTreeLeafOrParenthesized = choice
-  [ between (satisfy (== LOpenParen)) (satisfy (== LCloseParen)) parseTreeTerm
-  , parseTreeLeaf
-  ]
-
-foldTree :: [TricuAST] -> TricuAST
-foldTree [] = TLeaf
-foldTree [x] = x
-foldTree (x:y:rest) = TFork x (foldTree (y:rest))
-
-parseAtomic :: Parser TricuAST
-parseAtomic = choice
-  [ parseVar
-  , parseTreeLeaf
-  , parseListLiteral
-  , parseGrouped
-  , parseLiteral
-  ]
-
-parseGrouped :: Parser TricuAST
-parseGrouped = between (satisfy (== LOpenParen)) (satisfy (== LCloseParen)) parseExpression
-
-parseLiteral :: Parser TricuAST
-parseLiteral = choice
-  [ parseIntLiteral
-  , parseStrLiteral
-  ]
-
-parens :: Parser TricuAST -> Parser TricuAST
-parens p = do
-  satisfy (== LOpenParen)
-  result <- p
-  satisfy (== LCloseParen)
-  return result
-
-parseListLiteral :: Parser TricuAST
-parseListLiteral = do
-  satisfy (== LOpenBracket)
-  elements <- many parseListItem
-  satisfy (== LCloseBracket)
-  return (SList elements)
-
-parseListItem :: Parser TricuAST
-parseListItem = choice
-  [ parseGroupedItem
-  , parseListLiteral
-  , parseSingleItem
-  ]
-
-parseGroupedItem :: Parser TricuAST
-parseGroupedItem = do
-  satisfy (== LOpenParen)
-  inner <- parseExpression
-  satisfy (== LCloseParen)
-  return inner
-
-parseSingleItem :: Parser TricuAST
-parseSingleItem = do
-  token <- satisfy isListItem
-  case token of
-    LIdentifier name -> return (SVar name)
-    LKeywordT -> return TLeaf
-    _ -> fail "Unexpected token in list item"
-
-isListItem :: LToken -> Bool
-isListItem (LIdentifier _) = True
-isListItem LKeywordT = True
-isListItem _ = False
-
-parseVar :: Parser TricuAST
-parseVar = do
-  LIdentifier name <- satisfy isIdentifier
-  if (name == "t" || name == "__result")
-    then fail $ "Reserved keyword: " ++ name ++ " cannot be assigned."
-    else return (SVar name)
-
-parseIntLiteral :: Parser TricuAST
-parseIntLiteral = do
-  LIntegerLiteral value <- satisfy isIntegerLiteral
-  return (SInt value)
-
-parseStrLiteral :: Parser TricuAST
-parseStrLiteral = do
-  LStringLiteral value <- satisfy isStringLiteral
-  return (SStr value)
-
--- Boolean Helpers
-isKeywordT (LKeywordT) = True
-isKeywordT _ = False
-isIdentifier (LIdentifier _) = True
-isIdentifier _ = False
-isIntegerLiteral (LIntegerLiteral _) = True
-isIntegerLiteral _ = False
-isStringLiteral (LStringLiteral _) = True
-isStringLiteral _ = False
-isLiteral (LIntegerLiteral _) = True
-isLiteral (LStringLiteral _) = True
-isLiteral _ = False
-isNewline (LNewline) = True
-isNewline _ = False
-
--- Error Handling
 handleParseError :: ParseErrorBundle [LToken] Void -> String
 handleParseError bundle =
   let errors = bundleErrors bundle
-      errorList = toList errors
+      formattedErrors = map formatError (Data.List.NonEmpty.toList errors)
-      formattedErrors = map showError errorList
   in unlines ("Parse error(s) encountered:" : formattedErrors)
 
-showError :: ParseError [LToken] Void -> String
+formatError :: ParseError [LToken] Void -> String
-showError (TrivialError offset (Just (Tokens tokenStream)) expected) =
+formatError (TrivialError offset unexpected expected) =
-  "Parse error at offset " ++ show offset ++ ": unexpected token "
+  let unexpectedMsg = case unexpected of
-  ++ show tokenStream ++ ", expected one of " ++ show (Set.toList expected)
+        Just x  -> "unexpected token " ++ show x
-showError (FancyError offset fancy) =
+        Nothing -> "unexpected end of input"
-  "Parse error at offset " ++ show offset ++ ":\n " ++ unlines (map show (Set.toList fancy))
+      expectedMsg = if null expected
-showError (TrivialError offset Nothing expected) =
+        then ""
-  "Parse error at offset " ++ show offset ++ ": expected one of "
+        else "expected " ++ show (Set.toList expected)
-  ++ show (Set.toList expected)
+  in "Parse error at offset " ++ show offset ++ ": " ++ unexpectedMsg ++
-
+     if null expectedMsg then "" else " " ++ expectedMsg
+formatError (FancyError offset _) =
+  "Parse error at offset " ++ show offset ++ ": unexpected FancyError"

src/REPL.hs

@@ -1,54 +1,68 @@
 module REPL where
 
 import Eval
+import FileEval
 import Lexer
 import Parser
 import Research
 
 import Control.Exception         (SomeException, catch)
 import Control.Monad.IO.Class    (liftIO)
-import Data.List                 (intercalate)
+import Data.Char                 (isSpace)
+import Data.List                 (dropWhile, dropWhileEnd, intercalate)
 import System.Console.Haskeline
 
 import qualified Data.Map as Map
 
-repl :: Map.Map String T -> IO ()
+repl :: Env -> IO ()
 repl env = runInputT defaultSettings (loop env)
   where
-    loop :: Map.Map String T -> InputT IO ()
+    loop :: Env -> InputT IO ()
     loop env = do
       minput <- getInputLine "tricu < "
-      case minput of
+      if
-        Nothing -> outputStrLn "Goodbye!"
+        | Nothing <- minput                     -> outputStrLn "Exiting tricu"
-        Just ":_exit" -> outputStrLn "Goodbye!"
+        | Just s  <- minput, strip s == "!exit" -> outputStrLn "Exiting tricu"
-        Just "" -> do
+        | Just s  <- minput, strip s == ""      -> do
           outputStrLn ""
           loop env
-        Just input -> do
+        | Just s  <- minput, strip s == "!load" -> do
-          newEnv <- liftIO $ (processInput env input `catch` errorHandler env)
+          path <- getInputLine "File path to load < "
-          loop newEnv
+          if
+            | Nothing <- path -> do
+              outputStrLn "No input received; stopping import."
+              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)
+        | Just s <- minput -> do
+          if
+            | take 2 s == "--" -> loop env
+            | otherwise -> do
+              newEnv <- liftIO $ processInput env s `catch` errorHandler env
+              loop newEnv
 
-    processInput :: Map.Map String T -> String -> IO (Map.Map String T)
+    processInput :: Env -> String -> IO Env
     processInput env input = do
-      let clearEnv = Map.delete "__result" env
+      let asts   = parseTricu input
-          newEnv = evalSingle clearEnv (parseSingle input)
+          newEnv = evalTricu env asts
-      case Map.lookup "__result" newEnv of
+      if
-        Just r -> do
+        | Just r <- Map.lookup "__result" newEnv -> do
-          putStrLn $ "tricu > " ++ show r
+          putStrLn $ "tricu > " ++ decodeResult r
-          putStrLn $ "READ -: \"" ++ decodeResult r ++ "\""
+        | otherwise -> return ()
-        Nothing -> return ()
       return newEnv
-
+    
-    errorHandler :: Map.Map String T -> SomeException -> IO (Map.Map String T)
+    errorHandler :: Env -> SomeException -> IO (Env)
     errorHandler env e = do
       putStrLn $ "Error: " ++ show e
       return env
+    
+    strip :: String -> String
+    strip = dropWhileEnd isSpace . dropWhile isSpace
 
 decodeResult :: T -> String
-decodeResult tc = case toNumber tc of
+decodeResult tc
-  Right num -> show num
+  | Right num  <- toNumber tc = show num
-  Left _ -> case toString tc of
+  | Right str  <- toString tc = "\"" ++ str ++ "\""
-    Right str -> str
+  | Right list <- toList tc   = "[" ++ intercalate ", " (map decodeResult list) ++ "]"
-    Left _ -> case toList tc of
+  | otherwise                 = formatResult TreeCalculus tc
-      Right list -> "[" ++ intercalate ", " (map decodeResult list) ++ "]"
-      Left _ -> ""

src/Research.hs

@@ -1,14 +1,57 @@
 module Research where
 
 import Control.Monad.State
-import Data.List (intercalate)
+import Data.List                 (intercalate)
-import Data.Map (Map)
+import Data.Map                  (Map)
+import Data.Text                 (Text, replace)
+import System.Console.CmdArgs    (Data, Typeable)
 
-import qualified Data.Map as Map
+import qualified Data.Map        as Map
+import qualified Data.Text as T
 
+-- Tree Calculus Types
 data T = Leaf | Stem T | Fork T T
   deriving (Show, Eq, Ord)
 
+-- Abstract Syntax Tree for tricu
+data TricuAST
+  = SVar String
+  | SInt Int
+  | SStr String
+  | SList [TricuAST]
+  | SFunc String [String] TricuAST
+  | SApp TricuAST TricuAST
+  | TLeaf
+  | TStem TricuAST
+  | TFork TricuAST TricuAST
+  | SLambda [String] TricuAST
+  | SEmpty
+  deriving (Show, Eq, Ord)
+
+-- Lexer Tokens
+data LToken
+  = LKeywordT
+  | LIdentifier String
+  | LIntegerLiteral Int
+  | LStringLiteral String
+  | LAssign
+  | LColon
+  | LBackslash
+  | LOpenParen
+  | LCloseParen
+  | LOpenBracket
+  | LCloseBracket
+  | LNewline
+  deriving (Show, Eq, Ord)
+
+-- Output formats
+data EvaluatedForm = TreeCalculus | FSL | AST | Ternary | Ascii
+  deriving (Show, Data, Typeable)
+
+-- Environment containing previously evaluated TC terms
+type Env = Map.Map String T 
+
+-- Tree Calculus Reduction
 apply :: T -> T -> T
 apply Leaf b                            = Stem b
 apply (Stem a) b                        = Fork a b
@@ -18,29 +61,6 @@ apply (Fork (Fork a1 a2) a3) Leaf       = a1
 apply (Fork (Fork a1 a2) a3) (Stem u)   = apply a2 u
 apply (Fork (Fork a1 a2) a3) (Fork u v) = apply (apply a3 u) v
 
-reduce :: T -> T
-reduce expr =
-  let next = step expr
-  in if next == expr then expr else reduce next
-
-step :: T -> T
-step (Fork left right) = reduce (apply (reduce left) (reduce right))
-step (Stem inner) = Stem (reduce inner)
-step t = t
-
--- SKI Combinators
-_S :: T
-_S = Fork (Stem (Fork Leaf Leaf)) Leaf
-
-_K :: T
-_K = Stem Leaf
-
--- Identity
--- We use the "point-free" style which drops a redundant node
--- Full I form (SKK): Fork (Stem (Stem Leaf)) (Stem Leaf)
-_I :: T
-_I = Fork (Stem (Stem Leaf)) Leaf 
-
 -- Booleans
 _false :: T
 _false = Leaf
@@ -88,7 +108,31 @@ toList (Fork x rest) = case toList rest of
   Left err -> Left err
 toList _ = Left "Invalid Tree Calculus list"
 
--- Utility
+-- Outputs
+formatResult :: EvaluatedForm -> T -> String
+formatResult TreeCalculus = toSimpleT . show
+formatResult FSL          = show
+formatResult AST          = show . toAST
+formatResult Ternary      = toTernaryString
+formatResult Ascii        = toAscii
+
+toSimpleT :: String -> String
+toSimpleT s = T.unpack 
+  $ replace "Fork" "t"
+  $ replace "Stem" "t"
+  $ replace "Leaf" "t"
+  $ (T.pack s)
+
+toTernaryString :: T -> String
+toTernaryString Leaf = "0"
+toTernaryString (Stem t) = "1" ++ toTernaryString t
+toTernaryString (Fork t1 t2) = "2" ++ toTernaryString t1 ++ toTernaryString t2
+
+toAST :: T -> TricuAST
+toAST Leaf = TLeaf
+toAST (Stem a) = TStem (toAST a)
+toAST (Fork a b) = TFork (toAST a) (toAST b)
+
 toAscii :: T -> String
 toAscii tree = go tree "" True
   where
@@ -103,41 +147,4 @@ toAscii tree = go tree "" True
         ++ go left (prefix ++ (if isLast then "    " else "|   ")) False
         ++ go right (prefix ++ (if isLast then "    " else "|   ")) True
 
-rules :: IO ()
+-- Utility
-rules = putStr $ header
-              ++ (unlines $ tcRules)
-              ++ (unlines $ haskellRules)
-              ++ footer
-  where
-    tcRules :: [String]
-    tcRules =
-      [ "|                                                                               |"
-      , "|                  ┌--------- | Tree Calculus | ---------┐                      |"
-      , "|                  | 1.  t  t      a b       -> a        |                      |"
-      , "|                  | 2.  t (t a)   b c       -> a c (b c)|                      |"
-      , "|                  | 3a. t (t a b) c t       -> a        |                      |"
-      , "|                  | 3b. t (t a b) c (t u)   -> b u      |                      |"
-      , "|                  | 3c. t (t a b) c (t u v) -> c u v    |                      |"
-      , "|                  └-------------------------------------┘                      |"
-      , "|                                                                               |"
-      ]
-    haskellRules :: [String]
-    haskellRules =
-      [ "| ┌------------------------------ | Haskell | --------------------------------┐ |"
-      , "| |                                                                           | |"
-      , "| | data T = Leaf | Stem T | Fork TT                                          | |"
-      , "| |                                                                           | |"
-      , "| | apply :: T -> T -> T                                                      | |"
-      , "| | apply Leaf b                            = Stem b                          | |"
-      , "| | apply (Stem a) b                        = Fork a b                        | |"
-      , "| | apply (Fork Leaf a) _                   = a                               | |"
-      , "| | apply (Fork (Stem a1) a2) b             = apply (apply a1 b) (apply a2 b) | |"
-      , "| | apply (Fork (Fork a1 a2) a3) Leaf       = a1                              | |"
-      , "| | apply (Fork (Fork a1 a2) a3) (Stem u)   = apply a2 u                      | |"
-      , "| | apply (Fork (Fork a1 a2) a3) (Fork u v) = apply (apply a3 u) v            | |"
-      , "| └---------------------------------------------------------------------------┘ |"
-      ]
-    header :: String
-    header = "┌-------------------- | Rules for evaluating Tree Calculus | -------------------┐\n"
-    footer :: String
-    footer = "└-------------------- | Rules for evaluating Tree Calculus | -------------------┘\n"

test/Spec.hs

@@ -1,12 +1,14 @@
 module Main where
 
 import Eval
+import FileEval
 import Lexer
-import Library
 import Parser
 import REPL
 import Research
+
 import Control.Exception (evaluate, try, SomeException)
+import Control.Monad.IO.Class (liftIO)
 import Test.Tasty
 import Test.Tasty.HUnit
 import Test.Tasty.QuickCheck
@@ -28,7 +30,7 @@ tests = testGroup "Tricu Tests"
   , evaluationTests
   , lambdaEvalTests
   , libraryTests
-  , propertyTests
+  , fileEvaluationTests
   ]
 
 lexerTests :: TestTree
@@ -50,7 +52,7 @@ lexerTests = testGroup "Lexer Tests"
           expect = Right [LKeywordT, LStringLiteral "string", LIntegerLiteral 42]
       runParser tricuLexer "" input @?= expect
   , testCase "Lex invalid token" $ do
-      let input = "$invalid"
+      let input = "&invalid"
       case runParser tricuLexer "" input of
         Left _ -> return ()
         Right _ -> assertFailure "Expected lexer to fail on invalid token"
@@ -69,9 +71,9 @@ lexerTests = testGroup "Lexer Tests"
 parserTests :: TestTree
 parserTests = testGroup "Parser Tests"
   [ testCase "Error when assigning a value to T" $ do
-      let input = lexTricu "t = x"
+      let tokens = lexTricu "t = x" 
-      case (runParser parseExpression "" input) of
+      case parseSingleExpr tokens of
-        Left _ -> return ()
+        Left  _ -> return ()
         Right _ -> assertFailure "Expected failure when trying to assign the value of T"
   , testCase "Parse function definitions" $ do
       let input = "x = (\\a b c : a)"
@@ -147,10 +149,6 @@ parserTests = testGroup "Parser Tests"
       let input = "(t) -- (t) -- (t)"
           expect = [TLeaf]
       parseTricu input @?= expect
-  , testCase "Comments with no terms" $ do
-      let input = unlines ["-- (t)", "(t t)"]
-          expect = [SEmpty,SApp TLeaf TLeaf]
-      parseTricu input @?= expect 
   ]
 
 evaluationTests :: TestTree
@@ -213,7 +211,7 @@ evaluationTests = testGroup "Evaluation Tests"
       let input = "x = t t\nx = t\nx"
           env = evalTricu Map.empty (parseTricu input)
       (result env) @?= Leaf
-    , testCase "Apply identity to Boolean Not" $ do
+  , testCase "Apply identity to Boolean Not" $ do
       let not = "(t (t (t t) (t t t)) t)"
       let input = "x = (\\a : a)\nx " ++ not
           env = evalTricu Map.empty (parseTricu input)
@@ -284,101 +282,130 @@ lambdaEvalTests = testGroup "Lambda Evaluation Tests"
 libraryTests :: TestTree
 libraryTests = testGroup "Library Tests"
   [ testCase "K combinator 1" $ do
+      library <- evaluateFile "./lib/base.tri"
       let input = "k (t) (t t)"
           env = evalTricu library (parseTricu input)
       result env @?= Leaf
   , testCase "K combinator 2" $ do
+      library <- evaluateFile "./lib/base.tri"
       let input = "k (t t) (t)"
           env = evalTricu library (parseTricu input)
       result env @?= Stem Leaf
   , testCase "K combinator 3" $ do
+      library <- evaluateFile "./lib/base.tri"
       let input = "k (t t t) (t)"
           env = evalTricu library (parseTricu input)
       result env @?= Fork Leaf Leaf
   , testCase "S combinator" $ do
+      library <- evaluateFile "./lib/base.tri"
       let input = "s (t) (t) (t)"
           env = evalTricu library (parseTricu input)
       result env @?= Fork Leaf (Stem Leaf)
   , testCase "SKK == I (fully expanded)" $ do
+      library <- evaluateFile "./lib/base.tri"
       let input = "s k k"
           env = evalTricu library (parseTricu input)
       result env @?= Fork (Stem (Stem Leaf)) (Stem Leaf)
   , testCase "I combinator" $ do
-      let input = "i not"
+      library <- evaluateFile "./lib/base.tri"
+      let input = "i not?"
           env = evalTricu library (parseTricu input)
       result env @?= Fork (Fork (Stem Leaf) (Fork Leaf Leaf)) (Fork Leaf (Fork Leaf Leaf))
   , testCase "Triage test Leaf" $ do
+      library <- evaluateFile "./lib/base.tri"
       let input = "test t"
           env = decodeResult $ result $ evalTricu library (parseTricu input)
-      env @?= "Leaf"
+      env @?= "\"Leaf\""
   , testCase "Triage test (Stem Leaf)" $ do
+      library <- evaluateFile "./lib/base.tri"
       let input = "test (t t)"
           env = decodeResult $ result $ evalTricu library (parseTricu input)
-      env @?= "Stem"
+      env @?= "\"Stem\""
   , testCase "Triage test (Fork Leaf Leaf)" $ do
+      library <- evaluateFile "./lib/base.tri"
       let input = "test (t t t)"
           env = decodeResult $ result $ evalTricu library (parseTricu input)
-      env @?= "Fork"
+      env @?= "\"Fork\""
   , testCase "Boolean NOT: true" $ do
-      let input = "not true"
+      library <- evaluateFile "./lib/base.tri"
+      let input = "not? true"
           env = result $ evalTricu library (parseTricu input)
       env @?= Leaf
   , testCase "Boolean NOT: false" $ do
-      let input = "not false"
+      library <- evaluateFile "./lib/base.tri"
+      let input = "not? false"
           env = result $ evalTricu library (parseTricu input)
       env @?= Stem Leaf
   , testCase "Boolean AND TF" $ do
-      let input = "and (t t) (t)"
+      library <- evaluateFile "./lib/base.tri"
+      let input = "and? (t t) (t)"
           env = evalTricu library (parseTricu input)
       result env @?= Leaf
   , testCase "Boolean AND FT" $ do
-      let input = "and (t) (t t)"
+      library <- evaluateFile "./lib/base.tri"
+      let input = "and? (t) (t t)"
           env = evalTricu library (parseTricu input)
       result env @?= Leaf
   , testCase "Boolean AND FF" $ do
-      let input = "and (t) (t)"
+      library <- evaluateFile "./lib/base.tri"
+      let input = "and? (t) (t)"
           env = evalTricu library (parseTricu input)
       result env @?= Leaf
   , testCase "Boolean AND TT" $ do
-      let input = "and (t t) (t t)"
+      library <- evaluateFile "./lib/base.tri"
+      let input = "and? (t t) (t t)"
           env = evalTricu library (parseTricu input)
       result env @?= Stem Leaf
   , testCase "List head" $ do
+      library <- evaluateFile "./lib/base.tri"
       let input = "head [(t) (t t) (t t t)]"
           env = evalTricu library (parseTricu input)
       result env @?= Leaf
   , testCase "List tail" $ do
+      library <- evaluateFile "./lib/base.tri"
       let input = "head (tail (tail [(t) (t t) (t t t)]))"
           env = evalTricu library (parseTricu input)
       result env @?= Fork Leaf Leaf
   , testCase "List map" $ do
+      library <- evaluateFile "./lib/base.tri"
       let input = "head (tail (map (\\a : (t t t)) [(t) (t) (t)]))"
           env = evalTricu library (parseTricu input)
       result env @?= Fork Leaf Leaf
   , testCase "Empty list check" $ do
-      let input = "emptyList []"
+      library <- evaluateFile "./lib/base.tri"
+      let input = "emptyList? []"
           env = evalTricu library (parseTricu input)
       result env @?= Stem Leaf
   , testCase "Non-empty list check" $ do
-      let input = "not (emptyList [(1) (2) (3)])"
+      library <- evaluateFile "./lib/base.tri"
+      let input = "not? (emptyList? [(1) (2) (3)])"
           env = evalTricu library (parseTricu input)
       result env @?= Stem Leaf
   , testCase "Concatenate strings" $ do
-      let input = "listConcat \"Hello, \" \"world!\""
+      library <- evaluateFile "./lib/base.tri"
+      let input = "lconcat \"Hello, \" \"world!\""
           env = decodeResult $ result $ evalTricu library (parseTricu input)
-      env @?= "Hello, world!"
+      env @?= "\"Hello, world!\""
   , testCase "Verifying Equality" $ do
-      let input = "equal (t t t) (t t t)"
+      library <- evaluateFile "./lib/base.tri"
+      let input = "equal? (t t t) (t t t)"
           env = evalTricu library (parseTricu input)
       result env @?= Stem Leaf
   ]
 
-propertyTests :: TestTree
+fileEvaluationTests :: TestTree
-propertyTests = testGroup "Property Tests"
+fileEvaluationTests = testGroup "Evaluation tests"
-  [ testProperty "Lexing and parsing round-trip" $ \input ->
+  [ testCase "Forks" $ do
-      case runParser tricuLexer "" input of
+      res <- liftIO $ evaluateFileResult "./test/fork.tri"
-        Left _ -> property True
+      res @?= Fork Leaf Leaf
-        Right tokens -> case runParser parseExpression "" tokens of
+  , testCase "File ends with comment" $ do
-          Left _ -> property True
+      res <- liftIO $ evaluateFileResult "./test/comments-1.tri"
-          Right ast -> parseSingle input === ast
+      res @?= Fork (Stem Leaf) Leaf
+  , testCase "Mapping and Equality" $ do
+      res <- liftIO $ evaluateFileResult "./test/map.tri"
+      res @?= Stem Leaf
+  , testCase "Eval and decoding string" $ do
+      library <- liftIO $ evaluateFile "./lib/base.tri"
+      res <- liftIO $ evaluateFileWithContext library "./test/string.tri"
+      decodeResult (result res) @?= "\"String test!\""
   ]

test/ascii.tri

@@ -0,0 +1 @@
+t (t (t (t (t t) (t t t)) t) t t) t

test/assignment.tri

@@ -0,0 +1 @@
+x = t (t t) t

test/comments-1.tri

@@ -0,0 +1,9 @@
+-- This is a tricu comment!
+-- t (t t) (t (t t t))
+-- t (t t t) (t t)
+-- x = (\a : a)
+t (t t) t -- Fork (Stem Leaf) Leaf
+-- t t
+-- x
+-- x = (\a : a)
+-- t

test/fork.tri

@@ -0,0 +1 @@
+t t t 

test/map.tri

@@ -0,0 +1,24 @@
+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!")]

test/string.tri

@@ -0,0 +1 @@
+head (map (\i : lconcat "String " i) [("test!")])

tricu.cabal

@@ -1,7 +1,7 @@
 cabal-version: 1.12
 
 name:           tricu
-version:        0.4.0
+version:        0.7.0
 description:    A micro-language for exploring Tree Calculus
 author:         James Eversole
 maintainer:     james@eversole.co
@@ -17,25 +17,23 @@ executable tricu
   hs-source-dirs:
       src
   default-extensions:
-      ConstraintKinds
+      DeriveDataTypeable
-      DataKinds
+      LambdaCase
-      DeriveGeneric
+      MultiWayIf
-      FlexibleContexts
-      FlexibleInstances
-      GeneralizedNewtypeDeriving
       OverloadedStrings
-      ScopedTypeVariables
   ghc-options: -threaded -rtsopts -with-rtsopts=-N -optl-pthread -fPIC
   build-depends:
     base >=4.7
+    , cmdargs
     , containers
     , haskeline
     , megaparsec
     , mtl
+    , text
   other-modules:
     Eval
+    FileEval
     Lexer
-    Library
     Parser
     REPL
     Research
@@ -45,8 +43,14 @@ test-suite tricu-tests
   type:                exitcode-stdio-1.0
   main-is:             Spec.hs
   hs-source-dirs:      test, src
+  default-extensions:
+      DeriveDataTypeable
+      LambdaCase
+      MultiWayIf
+      OverloadedStrings
   build-depends:       
     base
+    , cmdargs
     , containers
     , haskeline
     , megaparsec
@@ -54,11 +58,12 @@ test-suite tricu-tests
     , tasty
     , tasty-hunit
     , tasty-quickcheck
+    , text
   default-language:    Haskell2010
   other-modules:
     Eval
+    FileEval
     Lexer
-    Library
     Parser
     REPL
     Research