"size" function nodes down from 454 to 321

README.md

@@ -2,37 +2,31 @@
 
 ## Introduction
 
-tricu (pronounced "tree-shoe") is a purely functional interpreted language implemented in Haskell. It is fundamentally based on the application of [Tree Calculus](https://github.com/barry-jay-personal/typed_tree_calculus/blob/main/typed_program_analysis.pdf) terms, but minimal syntax sugar is included to provide a useful programming tool. 
+tricu (pronounced "tree-shoe") is a purely functional interpreted language implemented in Haskell. It is fundamentally based on the application of [Tree Calculus](https://github.com/barry-jay-personal/typed_tree_calculus/blob/main/typed_program_analysis.pdf) terms, but minimal syntax sugar is included.
 
-*tricu is under active development and you should expect breaking changes with every commit.*
+*This experiment has concluded. tricu will see no further development or bugfixes.*
 
 tricu is the word for "tree" in Lojban: `(x1) is a tree of species/cultivar (x2)`.
 
-## Features
+## Acknowledgements 
 
-- Tree Calculus operator: `t`
+Tree Calculus was discovered by [Barry Jay](https://github.com/barry-jay-personal/blog). 
-- Assignments: `x = t t`
+
-- Immutable definitions
+[treecalcul.us](https://treecalcul.us) is an excellent website with an intuitive Tree Calculus code playground created by [Johannes Bader](https://johannes-bader.com/) that introduced me to Tree Calculus.
-- 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 : append a "!") [("Hello")]`
-- Intensionality blurs the distinction between functions and data (see REPL examples)
-- Simple module system for code organization
 
 ## REPL examples
 
 ```
 tricu < -- Anything after `--` on a single line is a comment
-tricu < id = (\a : a) -- Lambda abstraction is eliminated to tree calculus terms
+tricu < id = (a : a) -- Lambda abstraction is eliminated to tree calculus terms
-tricu < head (map (\i : append i " world!") [("Hello, ")])
+tricu < head (map (i : append i " world!") [("Hello, ")])
 tricu > "Hello,  world!"
-tricu < id (head (map (\i : append i " world!") [("Hello, ")]))
+tricu < id (head (map (i : append i " world!") [("Hello, ")]))
 tricu > "Hello,  world!"
 
 tricu < -- Intensionality! We can inspect the structure of a function or data.
-tricu < triage = (\a b c : t (t a b) c)
+tricu < triage = (a b c : t (t a b) c)
-tricu < test = triage "Leaf" (\z : "Stem") (\a b : "Fork")
+tricu < test = triage "Leaf" (z : "Stem") (a b : "Fork")
 tricu < test (t t)
 tricu > "Stem"
 tricu < -- We can even convert a term back to source code (/demos/toSource.tri)
@@ -55,9 +49,7 @@ tricu < !version      -- Print tricu version
 
 ## Installation and Use
 
-[Releases are available for Linux.](https://git.eversole.co/James/tricu/releases)
+You can easily build and run this project using [Nix](https://nixos.org/download/).
-
-Or you can easily build and run this project using [Nix](https://nixos.org/download/).
 
 - Quick Start (REPL): 
   - `nix run git+https://git.eversole.co/James/tricu`
@@ -93,15 +85,3 @@ tricu decode [OPTIONS]
   -f --file=FILE  Optional input file path to attempt decoding.
                     Defaults to stdin.
 ```
-
-## Collaborating
-
-I am happy to accept issue reports, pull requests, or questions about tricu [via email](mailto:james@eversole.co).
-
-If you want to collaborate but don't want to email back-and-forth, please reach out via email once to let me know and I will provision a git.eversole.co account for you.
-
-## Acknowledgements 
-
-Tree Calculus was discovered by [Barry Jay](https://github.com/barry-jay-personal/blog). 
-
-[treecalcul.us](https://treecalcul.us) is an excellent website with an intuitive Tree Calculus code playground created by [Johannes Bader](https://johannes-bader.com/) that introduced me to Tree Calculus.

demos/equality.tri

@@ -11,20 +11,17 @@ demo_true  = t t
 not_TC?     = t (t (t t) (t t t)) (t t (t t t))
 
 -- /demos/toSource.tri contains an explanation of `triage`
-demo_triage = \a b c : t (t a b) c
+demo_triage = a b c : t (t a b) c
-demo_matchBool = (\ot of : demo_triage
+demo_matchBool = a b : demo_triage b (_ : a) (_ _ : a)
-  of
+
-  (\_ : ot)
-  (\_ _ : ot)
-)
 -- Lambda representation of the Boolean `not` function
 not_Lambda? = demo_matchBool demo_false demo_true
 
--- Since tricu eliminates Lambda terms to SKI combinators, the tree form of many
+-- As tricu eliminates Lambda terms to SKI combinators, the tree form of many
 -- functions defined via Lambda terms are larger than the most efficient TC
--- representation. Between different languages that evaluate to tree calculus 
+-- representation possible. Between different languages that evaluate to tree
--- terms, the exact implementation of Lambda elimination may differ and lead 
+-- calculus terms, the exact implementation of Lambda elimination may differ
--- to different tree representations even if they share extensional behavior.
+-- and lead to different trees even if they share extensional behavior.
 
 -- Let's see if these are the same:
 lambdaEqualsTC = equal? not_TC? not_Lambda?

demos/levelOrderTraversal.tri

@@ -18,15 +18,15 @@ main = exampleTwo
 --    /   /  \
 --   4   5    6
 
-label = \node : head node
+label = node : head node
 
-left = (\node : if (emptyList? node)
+left = node : (if (emptyList? node)
   []
   (if (emptyList? (tail node))
     []
     (head (tail node))))
 
-right = (\node : if (emptyList? node) 
+right = node : (if (emptyList? node)
   []
   (if (emptyList? (tail node))
     []
@@ -34,25 +34,25 @@ right = (\node : if (emptyList? node)
       []
       (head (tail (tail node))))))
 
-processLevel = y (\self queue : if (emptyList? queue) 
+processLevel = y (self queue : if (emptyList? queue)
   []
   (pair (map label queue) (self (filter
-    (\node : not? (emptyList? node)) 
+    (node : not? (emptyList? node))
       (append (map left queue) (map right queue))))))
 
-levelOrderTraversal_ = \a : processLevel (t a t)
+levelOrderTraversal_ = a : processLevel (t a t)
 
-toLineString = y (\self levels : if (emptyList? levels) 
+toLineString = y (self levels : if (emptyList? levels)
   ""
   (append
-    (append (map (\x : append x " ") (head levels)) "") 
+    (append (map (x : append x " ") (head levels)) "")
     (if (emptyList? (tail levels)) "" (append (t (t 10 t) t) (self (tail levels))))))
 
-levelOrderToString = \s : toLineString (levelOrderTraversal_ s)
+levelOrderToString = s : toLineString (levelOrderTraversal_ s)
 
-flatten = foldl (\acc x : append acc x) ""
+flatten = foldl (acc x : append acc x) ""
 
-levelOrderTraversal = \s : append (t 10 t) (flatten (levelOrderToString s))
+levelOrderTraversal = s : append (t 10 t) (flatten (levelOrderToString s))
 
 exampleOne = levelOrderTraversal [("1")
                                  [("2") [("4") t t] t]

demos/patternMatching.tri

@@ -0,0 +1,37 @@
+!import "../lib/patterns.tri" !Local
+
+-- We can do conditional pattern matching by providing a list of lists, where
+-- each sublist contains a boolean expression and a function to return if said
+-- boolean expression evaluates to true.
+
+value = 42
+main  = match value [[(equal? "Hello") (_ : ", world!")] [(equal? 42) (_ : "The answer.")]]
+
+-- < main
+-- > "The answer."
+
+matchExample = (x : match x
+  [[(equal? 1)  (_ : "one")]
+   [(equal? 2)  (_ : "two")]
+   [(equal? 3)  (_ : "three")]
+   [(equal? 4)  (_ : "four")]
+   [(equal? 5)  (_ : "five")]
+   [(equal? 6)  (_ : "six")]
+   [(equal? 7)  (_ : "seven")]
+   [(equal? 8)  (_ : "eight")]
+   [(equal? 9)  (_ : "nine")]
+   [(equal? 10) (_ : "ten")]
+   [ otherwise  (_ : "I ran out of fingers!")]])
+
+-- < matchExample 3
+-- > "three"
+-- < matchExample 5
+-- > "five"
+-- < matchExample 9
+-- > "nine"
+-- < matchExample 11
+-- > "I ran out of fingers!"
+-- < matchExample "three"
+-- > "I ran out of fingers!"
+-- < matchExample [("hello") ("world")]
+-- > "I ran out of fingers!"

demos/size.tri

@@ -3,11 +3,9 @@
 
 main = size size
 
-size = (\x :
+size = x : y (self x : compose succ (triage
-  (y (\self x :
+  id
-    compose succ
-      (triage
-        (\x : x)
   self
-        (\x y : compose (self x) (self y))
+  (x y : compose (self x) (self y))
-        x)) x 0))
+  x)
+) x 0

demos/toSource.tri

@@ -18,25 +18,25 @@ main = toSource not?
 sourceLeaf = t (head "t")
 
 -- Stem case
-sourceStem = (\convert : (\a rest :
+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 (head ")") rest)))))   -- Close with ")" and append the rest.
 
 -- Fork case
-sourceFork = (\convert : (\a b rest :
+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 (head ")") rest))))))) -- Close with ")" and append the rest.
 
 -- Wrapper around triage 
-toSource_ = y (\self arg :
+toSource_ = y (self arg :
   triage
     sourceLeaf        -- `triage` "a" case, Leaf
     (sourceStem self) -- `triage` "b" case, Stem
@@ -44,7 +44,7 @@ toSource_ = y (\self arg :
     arg)              -- The term to be inspected
 
 -- toSource takes a single TC term and returns a String
-toSource = \v : toSource_ v ""
+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)))"

flake.lock

@@ -18,55 +18,25 @@
         "type": "github"
       }
     },
-    "nh2pkgs": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1718490232,
-        "narHash": "sha256-0Fh3aJZuTJVmiiKY/5SyvHlfhZ3HeZTDUQnd+Fx6/Qo=",
-        "type": "tarball",
-        "url": "https://github.com/nh2/nixpkgs/archive/ede5282c487a1fd2de64303ba59adad6726f1225.tar.gz"
-      },
-      "original": {
-        "type": "tarball",
-        "url": "https://github.com/nh2/nixpkgs/archive/ede5282c487a1fd2de64303ba59adad6726f1225.tar.gz"
-      }
-    },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1738797219,
+        "lastModified": 1734566935,
-        "narHash": "sha256-KRwX9Z1XavpgeSDVM/THdFd6uH8rNm/6R+7kIbGa+2s=",
+        "narHash": "sha256-cnBItmSwoH132tH3D4jxmMLVmk8G5VJ6q/SC3kszv9E=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "1da52dd49a127ad74486b135898da2cef8c62665",
+        "rev": "087408a407440892c1b00d80360fd64639b8091d",
         "type": "github"
       },
       "original": {
-        "id": "nixpkgs",
+        "owner": "NixOS",
-        "type": "indirect"
+        "repo": "nixpkgs",
+        "type": "github"
       }
     },
     "root": {
       "inputs": {
         "flake-utils": "flake-utils",
-        "nh2pkgs": "nh2pkgs",
+        "nixpkgs": "nixpkgs"
-        "nixpkgs": "nixpkgs",
-        "static-haskell-nix": "static-haskell-nix"
-      }
-    },
-    "static-haskell-nix": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1718492291,
-        "narHash": "sha256-XbBHPJk3ln+uLW+Dsio7vJNYnsHhmqenbI7cLsP8kHg=",
-        "owner": "nh2",
-        "repo": "static-haskell-nix",
-        "rev": "481e7d73ca624278ef0f840a0a2ba09e3a583217",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nh2",
-        "repo": "static-haskell-nix",
-        "type": "github"
       }
     },
     "systems": {

flake.nix

@@ -2,56 +2,46 @@
   description = "tricu";
 
   inputs = {
-    nh2pkgs = {
+    nixpkgs.url = "github:NixOS/nixpkgs";
-      url = "https://github.com/nh2/nixpkgs/archive/ede5282c487a1fd2de64303ba59adad6726f1225.tar.gz";
-      type = "tarball";
-      flake = false;
-    };
-    static-haskell-nix = {
-      url = "github:nh2/static-haskell-nix";
-      flake = false;
-    };
     flake-utils.url = "github:numtide/flake-utils";
   };
 
-  outputs = { self, flake-utils, nh2pkgs, nixpkgs, static-haskell-nix }:
+  outputs = { self, nixpkgs, flake-utils }:
     flake-utils.lib.eachDefaultSystem (system:
       let
-        compiler = "ghc948";
+        pkgs              = nixpkgs.legacyPackages.${system};
         packageName       = "tricu";
+        containerPackageName = "${packageName}-container";
 
-        overlay = self: super: {
+        customGHC = pkgs.haskellPackages.ghcWithPackages (hpkgs: with hpkgs; [
-          haskell = super.haskell // {
+          megaparsec
-            packages = super.haskell.packages // {
+        ]);
-              ${compiler} = super.haskell.packages.${compiler}.override {
-                overrides = final: prev: {
-                  ${packageName} = prev.callCabal2nix packageName ./. {};
-                };
-              };
-            };
-          };
-        };
 
-        overlays = [overlay];
+        haskellPackages = pkgs.haskellPackages;
 
-        pkgs = import nh2pkgs { inherit overlays system; };
+        enableSharedExecutables = false;
-
+        enableSharedLibraries = false;
-        survey = import "${static-haskell-nix}/survey" { inherit compiler pkgs; };
-
-        tricuStatic = survey.haskellPackages.${packageName};
 
+        tricu = pkgs.haskell.lib.justStaticExecutables self.packages.${system}.default;
       in {
-        packages.default = tricuStatic;
+
+        packages.${packageName} =
+          haskellPackages.callCabal2nix packageName self rec {};
+
+        packages.default = self.packages.${system}.${packageName};
+        defaultPackage = self.packages.${system}.default;
 
         devShells.default = pkgs.mkShell {
-          buildInputs = with survey; [
+          buildInputs = with pkgs; [
             haskellPackages.cabal-install
             haskellPackages.ghc-events
             haskellPackages.ghcid
-          ] ++ [pkgs.upx];
+            customGHC
+            upx
+          ];
           inputsFrom = builtins.attrValues self.packages.${system};
         };
         devShell = self.devShells.${system}.default;
+
       });
 }
-

lib/base.tri

@@ -1,74 +1,74 @@
 false = t
 _     = t
 true  = t t
-id    = \a : a
+id    = a : a
-const = \a b : a
+const = a b : a
 pair  = t
-if    = \cond then else : t (t else (t t then)) t cond
+if    = cond then else : t (t else (t t then)) t cond
 
-y = ((\mut wait fun : wait mut (\x : fun (wait mut x)))
+y = ((mut wait fun : wait mut (x : fun (wait mut x)))
-     (\x : x x)
+     (x : x x)
-     (\a0 a1 a2 : t (t a0) (t t a2) a1))
+     (a0 a1 a2 : t (t a0) (t t a2) a1))
 
-compose = \f g x : f (g x)
+compose = f g x : f (g x)
 
-triage = \leaf stem fork : t (t leaf stem) fork
+triage = leaf stem fork : t (t leaf stem) fork
-test   = triage "Leaf" (\_ : "Stem") (\_ _ : "Fork")
+test   = triage "Leaf" (_ : "Stem") (_ _ : "Fork")
 
-matchBool = (\ot of : triage
+matchBool = (ot of : triage
   of
-  (\_ : ot)
+  (_ : ot)
-  (\_ _ : ot)
+  (_ _ : ot)
 )
 
 lAnd = (triage
-  (\_     : false)
+  (_     : false)
-  (\_ x   : x)
+  (_ x   : x)
-  (\_ _ x : x))
+  (_ _ x : x))
 
 lOr = (triage
-  (\x     : x)
+  (x     : x)
-  (\_ _   : true)
+  (_ _   : true)
-  (\_ _ _ : true))
+  (_ _ _ : true))
 
-matchPair = \a : triage _ _ a
+matchPair = a : triage _ _ a
 
 not? = matchBool false true
-and? = matchBool id (\_ : false)
+and? = matchBool id (_ : false)
 
-or? = (\x z : 
+or? = (x z : 
   matchBool 
     (matchBool true true z)
     (matchBool true false z)
     x)
 
-xor? = (\x z : 
+xor? = (x z : 
   matchBool 
     (matchBool false true z)
     (matchBool true false z)
     x)
 
-equal? = y (\self : triage
+equal? = y (self : triage
   (triage
     true
-    (\_   : false)
+    (_   : false)
-    (\_ _ : false))
+    (_ _ : false))
-  (\ax :
+  (ax :
     triage
       false
       (self ax)
-      (\_ _ : false))
+      (_ _ : false))
-  (\ax ay :
+  (ax ay :
     triage
       false
-      (\_ : false)
+      (_ : false)
-      (\bx by : lAnd (self ax bx) (self ay by))))
+      (bx by : lAnd (self ax bx) (self ay by))))
 
-succ = y (\self :
+succ = y (self :
   triage
     1
     t
     (triage
       (t (t t))
-      (\_ tail : t t (self tail))
+      (_ tail : t t (self tail))
       t))

lib/list.tri

@@ -1,68 +1,70 @@
 !import "base.tri" !Local
 
-matchList = \a b : triage a _ b
+_ = t
 
-emptyList? = matchList true (\_ _ : false)
+matchList = a b : triage a _ b
-head = matchList t (\head _ : head)
-tail = matchList t (\_ tail : tail)
 
-append = y (\self : matchList
+emptyList? = matchList true (_ _ : false)
-  (\k : k)
+head = matchList t (head _ : head)
-  (\h r k : pair h (self r k)))
+tail = matchList t (_ tail : tail)
 
-lExist? = y (\self x : matchList
+append = y (self : matchList
+  (k : k)
+  (h r k : pair h (self r k)))
+
+lExist? = y (self x : matchList
   false
-  (\h z : or? (equal? x h) (self x z)))
+  (h z : or? (equal? x h) (self x z)))
 
-map_ = y (\self :
+map_ = y (self :
   matchList
-    (\_ : t)
+    (_ : t)
-    (\head tail f : pair (f head) (self tail f)))
+    (head tail f : pair (f head) (self tail f)))
-map = \f l : map_ l f
+map = f l : map_ l f
 
-filter_ = y (\self : matchList
+filter_ = y (self : matchList
-  (\_ : t)
+  (_ : t)
-  (\head tail f : matchBool (t head) id (f head) (self tail f)))
+  (head tail f : matchBool (t head) id (f head) (self tail f)))
-filter  = \f l : filter_ l 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_ = 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
+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_ = y (self x f l : matchList x (head tail : f (self x f tail) head) l)
-foldr  = \f x l : foldr_ x f l
+foldr  = f x l : foldr_ x f l
 
-length = y (\self : matchList
+length = y (self : matchList
   0
-  (\_ tail : succ (self tail)))
+  (_ tail : succ (self tail)))
 
-reverse = y (\self : matchList
+reverse = y (self : matchList
   t
-  (\head tail : append (self tail) (pair head t)))
+  (head tail : append (self tail) (pair head t)))
 
-snoc = y (\self x : matchList
+snoc = y (self x : matchList
   (pair x t)
-  (\h z : pair h (self x z)))
+  (h z : pair h (self x z)))
 
-count = y (\self x : matchList
+count = y (self x : matchList
   0
-  (\h z : matchBool
+  (h z : matchBool
     (succ (self x z))
     (self x z)
     (equal? x h)))
 
-last = y (\self : matchList
+last = y (self : matchList
   t
-  (\hd tl : matchBool
+  (hd tl : matchBool
     hd
     (self tl)
     (emptyList? tl)))
 
-all? = y (\self pred : matchList
+all? = y (self pred : matchList
   true
-  (\h z : and? (pred h) (self pred z)))
+  (h z : and? (pred h) (self pred z)))
 
-any? = y (\self pred : matchList
+any? = y (self pred : matchList
   false
-  (\h z : or? (pred h) (self pred z)))
+  (h z : or? (pred h) (self pred z)))
 
-intersect = \xs ys : filter (\x : lExist? x ys) xs
+intersect = xs ys : filter (x : lExist? x ys) xs

lib/patterns.tri

@@ -1,36 +1,24 @@
-!import "list.tri" !Local
+!import "base.tri" !Local
+!import "list.tri" List
 
-match_ = y (\self value patterns :
+match_ = y (self value patterns :
   triage
     t
-    (\_ : t)
+    (_ : t)
-    (\pattern rest :
+    (pattern rest :
       triage
         t
-        (\_ : t)
+        (_ : t)
-        (\test result :
+        (test result :
           if (test value)
              (result value)
              (self value rest))
         pattern)
     patterns)
 
-match = (\value patterns :
+match = (value patterns :
-  match_ value (map (\sublist :
+  match_ value (List.map (sublist :
-    pair (head sublist) (head (tail sublist)))
+    pair (List.head sublist) (List.head (List.tail sublist)))
     patterns))
 
 otherwise = const (t t)
-
-matchExample = (\x : match x
-  [[(equal? 1)  (\_ : "one")]
-  [(equal? 2)  (\_ : "two")]
-  [(equal? 3)  (\_ : "three")]
-  [(equal? 4)  (\_ : "four")]
-  [(equal? 5)  (\_ : "five")]
-  [(equal? 6)  (\_ : "six")]
-  [(equal? 7)  (\_ : "seven")]
-  [(equal? 8)  (\_ : "eight")]
-  [(equal? 9)  (\_ : "nine")]
-  [(equal? 10) (\_ : "ten")]
-  [ otherwise  (\_ : "I ran out of fingers!")]])

src/Eval.hs

@@ -3,11 +3,30 @@ module Eval where
 import Parser
 import Research
 
-import Data.List (partition, (\\))
+import           Data.List   (partition, (\\), elemIndex)
 import           Data.Map    (Map)
+import           Data.Set    (Set)
+
+import qualified Data.Foldable as F
 import qualified Data.Map as Map
 import qualified Data.Set as Set
 
+data DB
+  = BVar Int          -- bound (0 = nearest binder)
+  | BFree String      -- free/global
+  | BLam DB
+  | BApp DB DB
+  | BLeaf
+  | BStem DB
+  | BFork DB DB
+  | BStr String
+  | BInt Integer
+  | BList [DB]
+  | BEmpty
+  deriving (Eq, Show)
+
+type Uses = [Bool]
+
 evalSingle :: Env -> TricuAST -> Env
 evalSingle env term
   | SDef name [] body <- term
@@ -62,59 +81,75 @@ evalAST env term
 elimLambda :: TricuAST -> TricuAST
 elimLambda = go
   where
-    -- η-reduction
+    go term
-    go (SLambda [v] (SApp f (SVar x)))
+      | etaReduction term   = go (etaReduceResult term)
-      | v == x && not (isFree v f) = elimLambda f
+      | triagePattern term  = _TRI
-    -- Triage optimization
+      | composePattern term = _B
-    go (SLambda [a] (SLambda [b] (SLambda [c] body)))
+      | lambdaList term     = go (lambdaListResult term)
-      | body == triageBody         = _TRIAGE
+      | nestedLambda term   = nestedLambdaResult term
+      | application term    = applicationResult term
+      | otherwise           = term
+
+    -- patterns (now DB-indexed where it matters)
+    etaReduction (SLambda [v] (SApp f (SVar x))) = v == x && not (usesBinder v f)
+    etaReduction _ = False
+
+    -- triage: \a b c -> TLeaf (TLeaf a b) c  (checked in DB with a↦2, b↦1, c↦0)
+    triagePattern (SLambda [a] (SLambda [b] (SLambda [c] body))) =
+      toDB [c,b,a] body == triageBodyDB
+    triagePattern _ = False
+
+    -- compose: \f g x -> f (g x)  (checked in DB with f↦2, g↦1, x↦0)
+    composePattern (SLambda [f] (SLambda [g] (SLambda [x] body))) =
+      toDB [x,g,f] body == composeBodyDB
+    composePattern _ = False
+
+    lambdaList (SLambda [_] (SList _)) = True
+    lambdaList _ = False
+
+    nestedLambda (SLambda (_:_) _) = True
+    nestedLambda _ = False
+
+    application (SApp _ _) = True
+    application _ = False
+
+    -- rewrites
+    etaReduceResult (SLambda [_] (SApp f _)) = f
+
+    lambdaListResult (SLambda [v] (SList xs)) =
+      SLambda [v] (foldr wrapTLeaf TLeaf xs)
       where
-        triageBody =
+        wrapTLeaf m r = SApp (SApp TLeaf m) r
-          SApp (SApp TLeaf (SApp (SApp TLeaf (SVar a)) (SVar b))) (SVar c)
-    -- Composition optimization
-    go (SLambda [f] (SLambda [g] (SLambda [x] body)))
-      | body == SApp (SVar f) (SApp (SVar g) (SVar x)) = _B
-    -- General elimination
-    go (SLambda [v] (SList xs))
-      = elimLambda (SLambda [v] (foldr wrapTLeaf TLeaf xs))
-        where wrapTLeaf m r = SApp (SApp TLeaf m) r
-    go (SLambda (v:vs) body)
-      | null vs                    = toSKI v (elimLambda body)
-      | otherwise                  = elimLambda (SLambda [v] (SLambda vs body))
-    go (SApp f g)                  = SApp (elimLambda f) (elimLambda g)
-    go x                           = x
 
-    toSKI x (SVar y)
+    -- The key change: use DB bracket abstraction for the final parameter.
-      | x == y           = _I
+    nestedLambdaResult (SLambda (v:vs) body)
-      | otherwise        = SApp _K (SVar y)
+      | null vs   =
-    toSKI x t@(SApp n u)
+          let body' = go body
-      | not (isFree x t) = SApp _K t
+              db    = toDB [v] body'
-      | otherwise        = SApp (SApp _S (toSKI x n)) (toSKI x u)
+          in toSKIKiselyov db 
-    toSKI x t
+      | otherwise = go (SLambda [v] (SLambda vs body))
-      | not (isFree x t) = SApp _K t
-      | otherwise        = errorWithoutStackTrace "Unhandled toSKI conversion"
 
-    _S       = parseSingle "t (t (t t t)) t"
+    applicationResult (SApp f g) = SApp (go f) (go g)
-    _K       = parseSingle "t t"
+
-    _I       = parseSingle "t (t (t t)) t"
+-- combinators and special forms (unchanged)
-    _B       = parseSingle "t (t (t t (t (t (t t t)) t))) (t t)"
+_S   = parseSingle "t (t (t t t)) t"
-    _TRIAGE  = parseSingle "t (t (t t (t (t (t t t))))) t"
+_K   = parseSingle "t t"
+_I   = parseSingle "t (t (t t)) t"
+_R   = parseSingle "(t (t (t t (t (t (t (t (t (t (t t (t (t (t t t)) t))) (t (t (t t (t t))) (t (t (t t t)) t)))) (t t (t t))))))) (t t))"
+_C   = parseSingle "(t (t (t (t (t t (t (t (t t t)) t))) (t (t (t t (t t))) (t (t (t t t)) t)))) (t t (t t)))"
+_B   = parseSingle "t (t (t t (t (t (t t t)) t))) (t t)"
+_T   = SApp _C _I
+_TRI = parseSingle "t (t (t t (t (t (t t t))))) t"
+
+-- pattern bodies (kept for reference; checks are now DB-based)
+triageBody a b c   = SApp (SApp TLeaf (SApp (SApp TLeaf (SVar a)) (SVar b))) (SVar c)
+composeBody f g x  = SApp (SVar f) (SApp (SVar g) (SVar x))
 
 isFree :: String -> TricuAST -> Bool
-isFree x = Set.member x . freeVars
+isFree x t = Set.member x (freeVars t)
 
-freeVars :: TricuAST -> Set.Set String
+freeVars :: TricuAST -> Set String
-freeVars (SVar    v    ) = Set.singleton v
+freeVars = freeDBNames . toDB []
-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
@@ -131,7 +166,7 @@ reorderDefs env defs
     graph = buildDepGraph defsOnly
     sortedDefs = sortDeps graph
     defMap = Map.fromList [(name, def) | def@(SDef name _ _) <- defsOnly]
-    orderedDefs = map (\name -> defMap Map.! name) sortedDefs
+    orderedDefs = map (defMap Map.!) sortedDefs
 
     freeVarsDefs = foldMap snd defsWithFreeVars
     freeVarsOthers = foldMap freeVars others
@@ -139,7 +174,7 @@ reorderDefs env defs
     validNames = Set.fromList defNames `Set.union` Set.fromList (Map.keys env)
     missingDeps = Set.toList (allFreeVars `Set.difference` validNames)
 
-    isDef (SDef _ _ _) = True
+    isDef SDef {} = True
     isDef _       = False
 
 buildDepGraph :: [TricuAST] -> Map.Map String (Set.Set String)
@@ -195,3 +230,284 @@ mainResult :: Env -> T
 mainResult r = case Map.lookup "main" r of
   Just  a -> a
   Nothing -> errorWithoutStackTrace "No valid definition for `main` found."
+
+-- Convert named TricuAST to De Bruijn form
+toDB :: [String] -> TricuAST -> DB
+toDB env = \case
+  SVar v       -> maybe (BFree v) BVar (elemIndex v env)
+  SLambda vs b ->
+    let env' = reverse vs ++ env
+        body = toDB env' b
+    in foldr (\_ acc -> BLam acc) body vs
+  SApp f a     -> BApp (toDB env f) (toDB env a)
+  TLeaf        -> BLeaf
+  TStem t      -> BStem (toDB env t)
+  TFork l r    -> BFork (toDB env l) (toDB env r)
+  SStr s       -> BStr s
+  SInt n       -> BInt n
+  SList xs     -> BList (map (toDB env) xs)
+  SEmpty       -> BEmpty
+  SDef{}       -> error "toDB: unexpected SDef at this stage"
+  SImport _ _  -> BEmpty
+
+-- Does a term depend on the current binder (level 0)?
+dependsOnLevel :: Int -> DB -> Bool
+dependsOnLevel lvl = \case
+  BVar k      -> k == lvl
+  BLam t      -> dependsOnLevel (lvl + 1) t
+  BApp f a    -> dependsOnLevel lvl f || dependsOnLevel lvl a
+  BStem t     -> dependsOnLevel lvl t
+  BFork l r   -> dependsOnLevel lvl l || dependsOnLevel lvl r
+  BList xs    -> any (dependsOnLevel lvl) xs
+  _           -> False
+
+-- Collect free *global* names (i.e., unbound)
+freeDBNames :: DB -> Set String
+freeDBNames = \case
+  BFree s   -> Set.singleton s
+  BVar _    -> mempty
+  BLam t    -> freeDBNames t
+  BApp f a  -> freeDBNames f <> freeDBNames a
+  BLeaf     -> mempty
+  BStem t   -> freeDBNames t
+  BFork l r -> freeDBNames l <> freeDBNames r
+  BStr _    -> mempty
+  BInt _    -> mempty
+  BList xs  -> foldMap freeDBNames xs
+  BEmpty    -> mempty
+
+-- Helper: “is the binder named v used in body?”
+usesBinder :: String -> TricuAST -> Bool
+usesBinder v body = dependsOnLevel 0 (toDB [v] body)
+
+-- Expected DB bodies for the named special patterns (under env [a,b,c] -> indices 2,1,0)
+triageBodyDB :: DB
+triageBodyDB =
+  BApp (BApp BLeaf (BApp (BApp BLeaf (BVar 2)) (BVar 1))) (BVar 0)
+
+composeBodyDB :: DB
+composeBodyDB =
+  BApp (BVar 2) (BApp (BVar 1) (BVar 0))
+
+-- Convert DB -> TricuAST for subterms that contain NO binders (no BLam, no BVar)
+fromDBClosed :: DB -> TricuAST
+fromDBClosed = \case
+  BFree s   -> SVar s
+  BApp f a  -> SApp (fromDBClosed f) (fromDBClosed a)
+  BLeaf     -> TLeaf
+  BStem t   -> TStem (fromDBClosed t)
+  BFork l r -> TFork (fromDBClosed l) (fromDBClosed r)
+  BStr s    -> SStr s
+  BInt n    -> SInt n
+  BList xs  -> SList (map fromDBClosed xs)
+  BEmpty    -> SEmpty
+  -- Anything bound would be a logic error if we call this correctly.
+  BLam _    -> error "fromDBClosed: unexpected BLam"
+  BVar _    -> error "fromDBClosed: unexpected bound variable"
+
+-- DB-native bracket abstraction over the innermost binder (level 0).
+-- This mirrors your old toSKI, but is purely index-driven.
+toSKIDB :: DB -> TricuAST
+toSKIDB t
+  | not (dependsOnLevel 0 t) = SApp _K (fromDBClosed t)
+toSKIDB (BVar 0)             = _I
+toSKIDB (BApp n u)           = SApp (SApp _S (toSKIDB n)) (toSKIDB u)
+toSKIDB (BList xs) =
+  let anyUses = any (dependsOnLevel 0) xs
+  in if not anyUses
+        then SApp _K (SList (map fromDBClosed xs))
+        else SList (map toSKIDB xs)
+toSKIDB other =
+  errorWithoutStackTrace $ "Unhandled toSKI(DB) conversion: " ++ show other
+
+app2 :: TricuAST -> TricuAST -> TricuAST
+app2 f x = SApp f x
+
+app3 :: TricuAST -> TricuAST -> TricuAST -> TricuAST
+app3 f x y = SApp (SApp f x) y
+
+-- Core converter that *does not* perform the λ-step; it just returns (Γ, d).
+-- Supported shapes: variables, applications, closed literals (Leaf/Int/Str/Empty),
+-- closed lists. For anything where the binder occurs under structural nodes
+-- (Stem/Fork/List-with-use), we deliberately bail so the caller can fall back.
+kisConv :: DB -> Either String (Uses, TricuAST)
+kisConv = \case
+  BVar 0     -> Right ([True], _I)
+  BVar n | n > 0 -> do
+    (g,d) <- kisConv (BVar (n - 1))
+    Right (False:g, d)
+  BApp e1 e2 -> do
+    (g1,d1) <- kisConv e1
+    (g2,d2) <- kisConv e2
+    let g = zipWithDefault False (||) g1 g2   -- <— propagate Γ outside (#)
+        d = kisHash (g1,d1) (g2,d2)           -- <— (#) yields only the term
+    Right (g, d)
+  -- Treat closed constants as free 'combinator leaves' (no binder use).
+  BLeaf      -> Right ([], TLeaf)
+  BStr s     -> Right ([], SStr s)
+  BInt n     -> Right ([], SInt n)
+  BEmpty     -> Right ([], SEmpty)
+  -- Closed list: allowed. If binder is used anywhere, we punt to fallback.
+  BList xs
+    | any (dependsOnLevel 0) xs -> Left "List with binder use: fallback"
+    | otherwise                 -> Right ([], SList (map fromDBClosed xs))
+  -- For structural nodes, only allow if *closed* wrt the binder.
+  BStem t
+    | dependsOnLevel 0 t -> Left "Stem with binder use: fallback"
+    | otherwise          -> Right ([], TStem (fromDBClosed t))
+  BFork l r
+    | dependsOnLevel 0 l || dependsOnLevel 0 r -> Left "Fork with binder use: fallback"
+    | otherwise                                -> Right ([], TFork (fromDBClosed l) (fromDBClosed r))
+  -- We shouldn’t see BLam under elim; treat as unsupported so we fallback.
+  BLam _      -> Left "Nested lambda under body: fallback"
+  BFree s     -> Right ([], SVar s)
+
+-- Application combiner with K-optimization (lazy weakening).
+-- Mirrors Lynn’s 'optK' rules: choose among S, B, C, R based on leading flags.
+-- η-aware (#) with K-optimization (adapted from TS kiselyov_eta)
+kisHash :: (Uses, TricuAST) -> (Uses, TricuAST) -> TricuAST
+kisHash (g1, d1) (g2, d2) =
+  case g1 of
+    [] -> case g2 of
+      []            -> SApp d1 d2
+      True:gs2      -> if isId2 (g2, d2)
+                         then d1
+                         else kisHash ([], SApp _B d1) (gs2, d2)
+      False:gs2     -> kisHash ([], d1) (gs2, d2)
+
+    True:gs1 -> case g2 of
+      []            -> if isId2 (g1, d1)
+                         then SApp _T d2
+                         else kisHash ([], SApp _R d2) (gs1, d1)
+      _ ->
+        if isId2 (g1, d1) && case g2 of { False:_ -> True; _ -> False }
+          then kisHash ([], _T) (tail g2, d2)
+        else
+          -- NEW: coalesce the longest run of identical head pairs and apply bulk op once
+          let ((h1, h2), count) = headPairRun g1 g2
+              g1' = drop count g1
+              g2' = drop count g2
+          in case (h1, h2) of
+               (False, False) ->
+                 kisHash (g1', d1) (g2', d2)
+               (False, True)  ->
+                 let d1' = kisHash ([], bulkB count) (g1', d1)
+                 in  kisHash (g1', d1') (g2', d2)
+               (True, False)  ->
+                 let d1' = kisHash ([], bulkC count) (g1', d1)
+                 in  kisHash (g1', d1') (g2', d2)
+               (True, True)   ->
+                 let d1' = kisHash ([], bulkS count) (g1', d1)
+                 in  kisHash (g1', d1') (g2', d2)
+
+    False:gs1 -> case g2 of
+      []            -> kisHash (gs1, d1) ([], d2)
+      _             ->
+        if isId2 (g1, d1) && case g2 of { False:_ -> True; _ -> False }
+          then kisHash ([], _T) (tail g2, d2)
+        else case g2 of
+          True:gs2   ->
+            let d1' = kisHash ([], _B) (gs1, d1)
+            in  kisHash (gs1, d1') (gs2, d2)
+          False:gs2  ->
+            kisHash (gs1, d1) (gs2, d2)
+  where
+    tail (_:xs) = xs
+    tail []     = []
+
+
+toSKIKiselyov :: DB -> TricuAST
+toSKIKiselyov body =
+  case kisConv body of
+    Right ([], d)          -> SApp _K d
+    Right (True:_ , d)     -> d
+    Right (False:g, d)     -> kisHash ([], _K) (g, d)  -- no snd
+    Left _                 -> starSKIBCOpEtaDB body   -- was: toSKIDB body
+
+zipWithDefault :: a -> (a -> a -> a) -> [a] -> [a] -> [a]
+zipWithDefault d f []     ys     = map (f d) ys
+zipWithDefault d f xs     []     = map (\x -> f x d) xs
+zipWithDefault d f (x:xs) (y:ys) = f x y : zipWithDefault d f xs ys
+
+isNode :: TricuAST -> Bool
+isNode t = case t of
+  TLeaf -> True
+  _     -> False
+
+isApp2 :: TricuAST -> Maybe (TricuAST, TricuAST)
+isApp2 (SApp a b) = Just (a, b)
+isApp2 _          = Nothing
+
+isKop :: TricuAST -> Bool
+isKop t = case isApp2 t of
+  Just (a,b) -> isNode a && isNode b
+  _          -> False
+
+-- detects the two canonical I-shapes in the tree calculus:
+--   △ (△ (△ △)) x    OR    △ (△ △ △) △
+isId :: TricuAST -> Bool
+isId t = case isApp2 t of
+  Just (ab, c) -> case isApp2 ab of
+    Just (a, b) | isNode a ->
+      case isApp2 b of
+        Just (b1, b2) ->
+          (isNode b1 && isKop b2) ||
+          (isKop b1 && isNode b2 && isNode c)
+        _ -> False
+    _ -> False
+  _ -> False
+
+-- head-True only, tail empty, and term is identity
+isId2 :: (Uses, TricuAST) -> Bool
+isId2 (True:[], t) = isId t
+isId2 _            = False
+
+-- Bulk helpers built from SKI (no new primitives)
+bPrime :: TricuAST
+bPrime = SApp _B _B                            -- B' = B B
+
+cPrime :: TricuAST
+cPrime = SApp (SApp _B (SApp _B _C)) _B        -- C' = B (B C) B
+
+sPrime :: TricuAST
+sPrime = SApp (SApp _B (SApp _B _S)) _B        -- S' = B (B S) B
+
+bulkB :: Int -> TricuAST
+bulkB n | n <= 1    = _B
+        | otherwise = SApp bPrime (bulkB (n - 1))
+
+bulkC :: Int -> TricuAST
+bulkC n | n <= 1    = _C
+        | otherwise = SApp cPrime (bulkC (n - 1))
+
+bulkS :: Int -> TricuAST
+bulkS n | n <= 1    = _S
+        | otherwise = SApp sPrime (bulkS (n - 1))
+
+-- Count how many leading pairs (a,b) repeat at the head of zip g1 g2
+headPairRun :: [Bool] -> [Bool] -> ((Bool, Bool), Int)
+headPairRun g1 g2 =
+  case zip g1 g2 of
+    []       -> ((False, False), 0)
+    (h:rest) -> (h, 1 + length (takeWhile (== h) rest))
+
+-- DB-native star_skibc_op_eta (adapted from strategies.mts), binder = level 0
+starSKIBCOpEtaDB :: DB -> TricuAST
+starSKIBCOpEtaDB t
+  | not (dependsOnLevel 0 t) = SApp _K (fromDBClosed t)
+starSKIBCOpEtaDB (BVar 0)     = _I
+starSKIBCOpEtaDB (BApp e1 e2)
+  -- if binder not in right: use C
+  | not (dependsOnLevel 0 e2)
+  = SApp (SApp _C (starSKIBCOpEtaDB e1)) (fromDBClosed e2)
+  -- if binder not in left:
+  | not (dependsOnLevel 0 e1)
+  = case e2 of
+      -- η case: \x. f x  ==>  f
+      BVar 0 -> fromDBClosed e1
+      _      -> SApp (SApp _B (fromDBClosed e1)) (starSKIBCOpEtaDB e2)
+  -- otherwise: S
+  | otherwise
+  = SApp (SApp _S (starSKIBCOpEtaDB e1)) (starSKIBCOpEtaDB e2)
+-- Structural nodes with binder underneath: fall back to plain SKI (rare)
+starSKIBCOpEtaDB other        = toSKIDB other

src/Lexer.hs

@@ -41,7 +41,6 @@ tricuLexer = do
       , try stringLiteral
       , assign
       , colon
-      , backslash
       , openParen
       , closeParen
       , openBracket
@@ -94,9 +93,6 @@ assign = char '=' $> LAssign
 colon :: Lexer LToken
 colon = char ':' $> LColon
 
-backslash :: Lexer LToken
-backslash = char '\\' $> LBackslash
-
 openParen :: Lexer LToken
 openParen = char '(' $> LOpenParen
 
@@ -126,7 +122,22 @@ integerLiteral = do
 stringLiteral :: Lexer LToken
 stringLiteral = do
   char '"'
-  content <- many (noneOf ['"'])
+  content <- manyTill Lexer.charLiteral (char '"')
-  char '"' --"
   return (LStringLiteral content)
 
+charLiteral :: Lexer Char
+charLiteral = escapedChar <|> normalChar
+  where
+    normalChar = noneOf ['"', '\\']
+    escapedChar = do
+      void $ char '\\'
+      c <- oneOf ['n', 't', 'r', 'f', 'b', '\\', '"', '\'']
+      return $ case c of
+        'n'  -> '\n'
+        't'  -> '\t'
+        'r'  -> '\r'
+        'f'  -> '\f'
+        'b'  -> '\b'
+        '\\' -> '\\'
+        '"'  -> '"'
+        '\'' -> '\''

src/Main.hs

@@ -63,18 +63,17 @@ main = do
   case args of
     Repl -> do
       putStrLn "Welcome to the tricu REPL"
-      putStrLn "You can exit with `CTRL+D` or the `!exit` command.`"
+      putStrLn "You may exit with `CTRL+D` or the `!exit` command."
+      putStrLn "Try typing `!` with tab completion for more commands."
       repl Map.empty
     Evaluate { file = filePaths, form = form } -> do
       result <- case filePaths of
-        [] -> do
+        [] -> runTricuT <$> getContents
-          t <- getContents
-          pure $ runTricu t
         (filePath:restFilePaths) -> do
             initialEnv <- evaluateFile filePath
             finalEnv <- foldM evaluateFileWithContext initialEnv restFilePaths
             pure $ mainResult finalEnv
-      let fRes = formatResult form result
+      let fRes = formatT form result
       putStr fRes
     TDecode { file = filePaths } -> do
       value <- case filePaths of
@@ -82,8 +81,48 @@ main = do
         (filePath:_) -> readFile filePath
       putStrLn $ decodeResult $ result $ evalTricu Map.empty $ parseTricu value
 
-runTricu :: String -> T
+-- Simple interfaces
-runTricu input =
+
+runTricu :: String -> String
+runTricu = formatT TreeCalculus . runTricuT
+
+runTricuT :: String -> T
+runTricuT input =
   let asts     = parseTricu input
       finalEnv = evalTricu Map.empty asts
    in result finalEnv
+
+runTricuEnv :: Env -> String -> String
+runTricuEnv env = formatT TreeCalculus . runTricuTEnv env
+
+runTricuTEnv :: Env -> String -> T
+runTricuTEnv env input =
+  let asts     = parseTricu input
+      finalEnv = evalTricu env asts
+   in result finalEnv
+
+runTricuWithEnvT :: String -> (Env, T)
+runTricuWithEnvT input =
+  let asts     = parseTricu input
+      finalEnv = evalTricu Map.empty asts
+   in (finalEnv, result finalEnv)
+
+runTricuWithEnv :: String -> (Env, String)
+runTricuWithEnv input =
+  let asts     = parseTricu input
+      finalEnv = evalTricu Map.empty asts
+      res      = result finalEnv
+   in (finalEnv, formatT TreeCalculus res)
+
+runTricuEnvWithEnvT :: Env -> String -> (Env, T)
+runTricuEnvWithEnvT env input =
+  let asts     = parseTricu input
+      finalEnv = evalTricu env asts
+   in (finalEnv, result finalEnv)
+
+runTricuEnvWithEnv :: Env -> String -> (Env, String)
+runTricuEnvWithEnv env input =
+  let asts     = parseTricu input
+      finalEnv = evalTricu env asts
+      res      = result finalEnv
+   in (finalEnv, formatT TreeCalculus res)

src/Parser.hs

@@ -130,7 +130,6 @@ parseFunctionM = do
 parseLambdaM :: ParserM TricuAST
 parseLambdaM = do
   let ident = (\case LIdentifier _ -> True; _ -> False)
-  _      <- satisfyM (== LBackslash)
   params <- some (satisfyM ident)
   _      <- satisfyM (== LColon)
   scnParserM
@@ -145,11 +144,11 @@ parseLambdaExpressionM = choice
 
 parseAtomicLambdaM :: ParserM TricuAST
 parseAtomicLambdaM = choice
-  [ parseVarM
+  [ try parseLambdaM
+  , parseVarM
   , parseTreeLeafM
   , parseLiteralM
   , parseListLiteralM
-  , try parseLambdaM
   , between (satisfyM (== LOpenParen)) (satisfyM (== LCloseParen)) parseLambdaExpressionM
   ]
 
@@ -205,7 +204,8 @@ parseTreeLeafOrParenthesizedM = choice
 
 parseAtomicM :: ParserM TricuAST
 parseAtomicM = choice
-  [ parseVarM
+  [ try parseLambdaM
+  , parseVarM
   , parseTreeLeafM
   , parseListLiteralM
   , parseGroupedM

src/REPL.hs

@@ -6,23 +6,22 @@ import Lexer
 import Parser
 import Research
 
-import Control.Exception         (IOException, SomeException, catch, displayException)
+import Control.Exception         (IOException, SomeException, catch
+                                 , displayException)
 import Control.Monad             (forM_)
-import Control.Monad.IO.Class    (liftIO)
 import Control.Monad.Catch       (handle, MonadCatch)
+import Control.Monad.IO.Class    (liftIO)
 import Control.Monad.Trans.Class (lift)
 import Control.Monad.Trans.Maybe (MaybeT(..), runMaybeT)
 import Data.Char                 (isSpace, isUpper)
-import Data.List                 ( dropWhile
+import Data.List                 (dropWhile, dropWhileEnd, isPrefixOf)
-                                 , dropWhileEnd
-                                 , isPrefixOf)
-import System.Console.Haskeline
-import Paths_tricu (version)
 import Data.Version (showVersion)
-import qualified Data.Text as T
+import Paths_tricu (version)
-import qualified Data.Text.IO as T
+import System.Console.Haskeline
 
 import qualified Data.Map as Map
+import qualified Data.Text as T
+import qualified Data.Text.IO as T
 
 repl :: Env -> IO ()
 repl env = runInputT settings (withInterrupt (loop env Decode))
@@ -153,7 +152,7 @@ repl env = runInputT settings (withInterrupt (loop env Decode))
           newEnv = evalTricu env asts
       case Map.lookup "!result" newEnv of
         Just r -> do
-          putStrLn $ "tricu > " ++ formatResult form r
+          putStrLn $ "tricu > " ++ formatT form r
         Nothing -> pure ()
       return newEnv
 
@@ -183,7 +182,7 @@ repl env = runInputT settings (withInterrupt (loop env Decode))
           liftIO $ writeFile filepath ""
           outputStrLn "File created..."
           forM_ definitions $ \(name, value) -> do
-            let content = name ++ " = " ++ formatResult TreeCalculus value ++ "\n"
+            let content = name ++ " = " ++ formatT TreeCalculus value ++ "\n"
             outputStrLn $ "Writing definition: " ++ name ++ " with length " ++ show (length content)
             liftIO $ appendFile filepath content
           outputStrLn $ "Saved " ++ show (length definitions) ++ " definitions to " ++ p

src/Research.hs

@@ -15,7 +15,7 @@ data T = Leaf | Stem T | Fork T T
 -- Abstract Syntax Tree for tricu
 data TricuAST
   = SVar String
-  | SInt Int
+  | SInt Integer
   | SStr String
   | SList [TricuAST]
   | SDef String [String] TricuAST
@@ -33,12 +33,11 @@ data LToken
   = LKeywordT
   | LIdentifier String
   | LNamespace String
-  | LIntegerLiteral Int
+  | LIntegerLiteral Integer
   | LStringLiteral String
   | LAssign
   | LColon
   | LDot
-  | LBackslash
   | LOpenParen
   | LCloseParen
   | LOpenBracket
@@ -85,9 +84,9 @@ _not = Fork (Fork _true (Fork Leaf _false)) Leaf
 
 -- Marshalling
 ofString :: String -> T
-ofString str = ofList $ map (ofNumber . fromEnum) str
+ofString str = ofList $ map (ofNumber . toInteger . fromEnum) str
 
-ofNumber :: Int -> T
+ofNumber :: Integer -> T
 ofNumber 0 = Leaf
 ofNumber n =
   Fork
@@ -97,7 +96,7 @@ ofNumber n =
 ofList :: [T] -> T
 ofList = foldr Fork Leaf
 
-toNumber :: T -> Either String Int
+toNumber :: T -> Either String Integer
 toNumber Leaf = Right 0
 toNumber (Fork Leaf rest) = case toNumber rest of
   Right n -> Right (2 * n)
@@ -109,7 +108,7 @@ toNumber _ = Left "Invalid Tree Calculus number"
 
 toString :: T -> Either String String
 toString tc = case toList tc of
-  Right list -> traverse (fmap toEnum . toNumber) list
+  Right list -> traverse (fmap (toEnum . fromInteger) . toNumber) list
   Left err -> Left "Invalid Tree Calculus string"
 
 toList :: T -> Either String [T]
@@ -120,13 +119,13 @@ toList (Fork x rest) = case toList rest of
 toList _ = Left "Invalid Tree Calculus list"
 
 -- Outputs
-formatResult :: EvaluatedForm -> T -> String
+formatT :: EvaluatedForm -> T -> String
-formatResult TreeCalculus = toSimpleT . show
+formatT TreeCalculus = toSimpleT . show
-formatResult FSL          = show
+formatT FSL          = show
-formatResult AST          = show . toAST
+formatT AST          = show . toAST
-formatResult Ternary      = toTernaryString
+formatT Ternary      = toTernaryString
-formatResult Ascii        = toAscii
+formatT Ascii        = toAscii
-formatResult Decode       = decodeResult
+formatT Decode       = decodeResult
 
 toSimpleT :: String -> String
 toSimpleT s = T.unpack
@@ -167,7 +166,7 @@ decodeResult tc =
     (_, _, Right n) -> show n
     (_, Right xs@(_:_), _) -> "[" ++ intercalate ", " (map decodeResult xs) ++ "]"
     (_, Right [], _) -> "[]"
-    _ -> formatResult TreeCalculus tc
+    _ -> formatT TreeCalculus tc
   where
     isCommonChar c =
       let n = fromEnum c

test/Spec.hs

@@ -21,8 +21,8 @@ import qualified Data.Set as Set
 main :: IO ()
 main = defaultMain tests
 
-runTricu :: String -> String
+tricuTestString :: String -> String
-runTricu s = show $ result (evalTricu Map.empty $ parseTricu s)
+tricuTestString s = show $ result (evalTricu Map.empty $ parseTricu s)
 
 tests :: TestTree
 tests = testGroup "Tricu Tests"
@@ -35,6 +35,8 @@ tests = testGroup "Tricu Tests"
   , modules
   , demos
   , decoding
+	, elimLambdaSingle
+	, stressElimLambda
   ]
 
 lexer :: TestTree
@@ -51,7 +53,22 @@ lexer = testGroup "Lexer Tests"
 
   , testCase "Lex escaped characters in strings" $ do
       let input = "\"hello\\nworld\""
-          expect = Right [LStringLiteral "hello\\nworld"]
+          expect = Right [LStringLiteral "hello\nworld"]
+      runParser tricuLexer "" input @?= expect
+
+  , testCase "Lex multiple escaped characters in strings" $ do
+      let input = "\"tab:\\t newline:\\n quote:\\\" backslash:\\\\\""
+          expect = Right [LStringLiteral "tab:\t newline:\n quote:\" backslash:\\"]
+      runParser tricuLexer "" input @?= expect
+
+  , testCase "Lex escaped characters in string literals" $ do
+      let input = "x = \"line1\\nline2\\tindented\""
+          expect = Right [LIdentifier "x", LAssign, LStringLiteral "line1\nline2\tindented"]
+      runParser tricuLexer "" input @?= expect
+
+  , testCase "Lex empty string with escape sequence" $ do
+      let input = "\"\\\"\""
+          expect = Right [LStringLiteral "\""]
       runParser tricuLexer "" input @?= expect
 
   , testCase "Lex mixed literals" $ do
@@ -87,7 +104,7 @@ parser = testGroup "Parser Tests"
         Right _ -> assertFailure "Expected failure when trying to assign the value of T"
 
   , testCase "Parse function definitions" $ do
-      let input = "x = (\\a b c : a)"
+      let input = "x = (a b c : a)"
           expect = SDef "x" [] (SLambda ["a"] (SLambda ["b"] (SLambda ["c"] (SVar "a"))))
       parseSingle input @?= expect
 
@@ -107,7 +124,7 @@ parser = testGroup "Parser Tests"
       parseSingle input @?= expect
 
   , testCase "Parse function with applications" $ do
-      let input  = "f = (\\x : t x)"
+      let input  = "f = (x : t x)"
           expect = SDef "f" [] (SLambda ["x"] (SApp TLeaf (SVar "x")))
       parseSingle input @?= expect
 
@@ -149,22 +166,22 @@ parser = testGroup "Parser Tests"
       parseSingle input @?= expect
 
   , testCase "Parse nested parentheses in function body" $ do
-      let input  = "f = (\\x : t (t (t t)))"
+      let input  = "f = (x : t (t (t t)))"
           expect = SDef "f" [] (SLambda ["x"] (SApp TLeaf (SApp TLeaf (SApp TLeaf TLeaf))))
       parseSingle input @?= expect
 
   , testCase "Parse lambda abstractions" $ do
-      let input  = "(\\a : a)"
+      let input  = "(a : a)"
           expect = (SLambda ["a"] (SVar "a"))
       parseSingle input @?= expect
 
   , testCase "Parse multiple arguments to lambda abstractions" $ do
-      let input  = "x = (\\a b : a)"
+      let input  = "x = (a b : 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)"
+      let input  = "x = (a : a)\nx (t)"
           expect = [SDef "x" [] (SLambda ["a"] (SVar "a")),SApp (SVar "x") TLeaf]
       parseTricu input @?= expect
 
@@ -251,7 +268,7 @@ simpleEvaluation = testGroup "Evaluation Tests"
   , testCase "Immutable definitions" $ do
       let input = "x = t t\nx = t\nx"
           env = evalTricu Map.empty (parseTricu input)
-      result <- try (evaluate (runTricu input)) :: IO (Either SomeException String)
+      result <- try (evaluate (tricuTestString input)) :: IO (Either SomeException String)
       case result of
         Left  _ -> return ()
         Right _ -> assertFailure "Expected evaluation error"
@@ -259,7 +276,7 @@ simpleEvaluation = testGroup "Evaluation Tests"
 
   , testCase "Apply identity to Boolean Not" $ do
       let not = "(t (t (t t) (t t t)) t)"
-      let input = "x = (\\a : a)\nx " ++ not
+      let input = "x = (a : a)\nx " ++ not
           env = evalTricu Map.empty (parseTricu input)
       result env @?= Fork (Fork (Stem Leaf) (Fork Leaf Leaf)) Leaf
   ]
@@ -267,85 +284,85 @@ simpleEvaluation = testGroup "Evaluation Tests"
 lambdas :: TestTree
 lambdas = testGroup "Lambda Evaluation Tests"
   [ testCase "Lambda Identity Function" $ do
-      let input = "id = (\\x : x)\nid t"
+      let input = "id = (x : x)\nid t"
-      runTricu input @?= "Leaf"
+      tricuTestString input @?= "Leaf"
 
   , testCase "Lambda Constant Function (K combinator)" $ do
-      let input = "k = (\\x y : x)\nk t (t t)"
+      let input = "k = (x y : x)\nk t (t t)"
-      runTricu input @?= "Leaf"
+      tricuTestString input @?= "Leaf"
 
   , testCase "Lambda Application with Variable" $ do
-      let input = "id = (\\x : x)\nval = t t\nid val"
+      let input = "id = (x : x)\nval = t t\nid val"
-      runTricu input @?= "Stem Leaf"
+      tricuTestString input @?= "Stem Leaf"
 
   , testCase "Lambda Application with Multiple Arguments" $ do
-      let input = "apply = (\\f x y : f x y)\nk = (\\a b : a)\napply k t (t t)"
+      let input = "apply = (f x y : f x y)\nk = (a b : a)\napply k t (t t)"
-      runTricu input @?= "Leaf"
+      tricuTestString input @?= "Leaf"
 
    , testCase "Nested Lambda Application" $ do
-      let input = "apply = (\\f x y : f x y)\nid = (\\x : x)\napply (\\f x : f x) id t"
+      let input = "apply = (f x y : f x y)\nid = (x : x)\napply (f x : f x) id t"
-      runTricu input @?= "Leaf"
+      tricuTestString input @?= "Leaf"
 
   , testCase "Lambda with a complex body" $ do
-      let input = "f = (\\x : t (t x))\nf t"
+      let input = "f = (x : t (t x))\nf t"
-      runTricu input @?= "Stem (Stem Leaf)"
+      tricuTestString input @?= "Stem (Stem Leaf)"
 
   , testCase "Lambda returning a function" $ do
-      let input = "f = (\\x : (\\y : x))\ng = f t\ng (t t)"
+      let input = "f = (x : (y : x))\ng = f t\ng (t t)"
-      runTricu input @?= "Leaf"
+      tricuTestString input @?= "Leaf"
 
   , testCase "Lambda with Shadowing" $ do
-      let input = "f = (\\x : (\\x : x))\nf t (t t)"
+      let input = "f = (x : (x : x))\nf t (t t)"
-      runTricu input @?= "Stem Leaf"
+      tricuTestString input @?= "Stem Leaf"
 
    , testCase "Lambda returning another lambda" $ do
-      let input = "k = (\\x : (\\y : x))\nk_app = k t\nk_app (t t)"
+      let input = "k = (x : (y : x))\nk_app = k t\nk_app (t t)"
-      runTricu input @?= "Leaf"
+      tricuTestString input @?= "Leaf"
 
    , testCase "Lambda with free variables" $ do
-      let input = "y = t t\nf = (\\x : y)\nf t"
+      let input = "y = t t\nf = (x : y)\nf t"
-      runTricu input @?= "Stem Leaf"
+      tricuTestString input @?= "Stem Leaf"
 
    , testCase "SKI Composition" $ do
-      let input = "s = (\\x y z : x z (y z))\nk = (\\x y : x)\ni = (\\x : x)\ncomp = s k i\ncomp t (t t)"
+      let input = "s = (x y z : x z (y z))\nk = (x y : x)\ni = (x : x)\ncomp = s k i\ncomp t (t t)"
-      runTricu input @?= "Stem (Stem Leaf)"
+      tricuTestString input @?= "Stem (Stem Leaf)"
 
    , testCase "Lambda with multiple parameters and application" $ do
-      let input = "f = (\\a b c : t a b c)\nf t (t t) (t t t)"
+      let input = "f = (a b c : t a b c)\nf t (t t) (t t t)"
-      runTricu input @?= "Stem Leaf"
+      tricuTestString input @?= "Stem Leaf"
 
    , testCase "Lambda with nested application in the body" $ do
-      let input = "f = (\\x : t (t (t x)))\nf t"
+      let input = "f = (x : t (t (t x)))\nf t"
-      runTricu input @?= "Stem (Stem (Stem Leaf))"
+      tricuTestString input @?= "Stem (Stem (Stem Leaf))"
 
     , testCase "Lambda returning a function and applying it" $ do
-        let input = "f = (\\x : (\\y : t x y))\ng = f t\ng (t t)"
+        let input = "f = (x : (y : t x y))\ng = f t\ng (t t)"
-        runTricu input @?= "Fork Leaf (Stem Leaf)"
+        tricuTestString input @?= "Fork Leaf (Stem Leaf)"
 
     , testCase "Lambda applying a variable" $ do
-        let input = "id = (\\x : x)\na = t t\nid a"
+        let input = "id = (x : x)\na = t t\nid a"
-        runTricu input @?= "Stem Leaf"
+        tricuTestString input @?= "Stem Leaf"
 
     , testCase "Nested lambda abstractions in the same expression" $ do
-        let input = "f = (\\x : (\\y : x y))\ng = (\\z : z)\nf g t"
+        let input = "f = (x : (y : x y))\ng = (z : z)\nf g t"
-        runTricu input @?= "Leaf"
+        tricuTestString input @?= "Leaf"
 
   , testCase "Lambda applied to string literal" $ do
-        let input = "f = (\\x : x)\nf \"hello\""
+        let input = "f = (x : x)\nf \"hello\""
-        runTricu input @?= "Fork (Fork Leaf (Fork Leaf (Fork Leaf (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) Leaf))))))) (Fork (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) (Fork Leaf (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) Leaf))))))) (Fork (Fork Leaf (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) Leaf))))))) (Fork (Fork Leaf (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) Leaf))))))) (Fork (Fork (Stem Leaf) (Fork (Stem Leaf) (Fork (Stem Leaf) (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) Leaf))))))) Leaf))))"
+        tricuTestString input @?= "Fork (Fork Leaf (Fork Leaf (Fork Leaf (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) Leaf))))))) (Fork (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) (Fork Leaf (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) Leaf))))))) (Fork (Fork Leaf (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) Leaf))))))) (Fork (Fork Leaf (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) Leaf))))))) (Fork (Fork (Stem Leaf) (Fork (Stem Leaf) (Fork (Stem Leaf) (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) Leaf))))))) Leaf))))"
 
 
    , testCase "Lambda applied to integer literal" $ do
-        let input = "f = (\\x : x)\nf 42"
+        let input = "f = (x : x)\nf 42"
-        runTricu input @?= "Fork Leaf (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) Leaf)))))"
+        tricuTestString input @?= "Fork Leaf (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) Leaf)))))"
 
    , testCase "Lambda applied to list literal" $ do
-        let input = "f = (\\x : x)\nf [t (t t)]"
+        let input = "f = (x : x)\nf [t (t t)]"
-        runTricu input @?= "Fork Leaf (Fork (Stem Leaf) Leaf)"
+        tricuTestString input @?= "Fork Leaf (Fork (Stem Leaf) Leaf)"
 
   , testCase "Lambda containing list literal" $ do
-      let input = "(\\a : [(a)]) 1"
+      let input = "(a : [(a)]) 1"
-      runTricu input @?= "Fork (Fork (Stem Leaf) Leaf) Leaf"
+      tricuTestString input @?= "Fork (Fork (Stem Leaf) Leaf) Leaf"
   ]
 
 providedLibraries :: TestTree
@@ -419,7 +436,7 @@ providedLibraries = testGroup "Library Tests"
 
   , testCase "List map" $ do
       library <- evaluateFile "./lib/list.tri"
-      let input = "head (tail (map (\\a : (t t t)) [(t) (t) (t)]))"
+      let input = "head (tail (map (a : (t t t)) [(t) (t) (t)]))"
           env = evalTricu library (parseTricu input)
       result env @?= Fork Leaf Leaf
 
@@ -518,7 +535,7 @@ demos = testGroup "Test provided demo functionality"
       decodeResult res @?= "\"(t (t (t t) (t t t)) (t t (t t t)))\""
   , testCase "Determining the size of functions" $ do
       res     <- liftIO $ evaluateFileResult "./demos/size.tri"
-      decodeResult res @?= "454"
+      decodeResult res @?= "321"
   , testCase "Level Order Traversal demo" $ do
       res     <- liftIO $ evaluateFileResult "./demos/levelOrderTraversal.tri"
       decodeResult res @?= "\"\n1 \n2 3 \n4 5 6 7 \n8 11 10 9 12 \""
@@ -555,3 +572,72 @@ decoding = testGroup "Decoding Tests"
       let input = ofList [ofList [ofString "nested"], ofString "string"]
       decodeResult input @?= "[[\"nested\"], \"string\"]"
   ]
+
+elimLambdaSingle :: TestTree
+elimLambdaSingle = testCase "elimLambda preserves eval, fires eta, and SDef binds" $ do
+  -- 1) eta reduction, purely structural and parsed from source
+  let [etaIn] = parseTricu "x : f x"
+      [fRef ] = parseTricu "f"
+  elimLambda etaIn @?= fRef
+
+  -- 2) SDef binds its own name and parameters
+  let [defFXY] = parseTricu "f x y : f x"
+      fv       = freeVars defFXY
+  assertBool "f should be bound in SDef" ("f" `Set.notMember` fv)
+  assertBool "x should be bound in SDef" ("x" `Set.notMember` fv)
+  assertBool "y should be bound in SDef" ("y" `Set.notMember` fv)
+
+  -- 3) semantics preserved on a small program that exercises compose and triage
+  let src =
+        unlines
+          [ "false = t"
+          , "_     = t"
+          , "true  = t t"
+          , "id    = a : a"
+          , "const = a b : a"
+          , "compose = f g x : f (g x)"
+          , "triage = leaf stem fork : t (t leaf stem) fork"
+          , "test   = triage \"Leaf\" (_ : \"Stem\") (_ _ : \"Fork\")"
+          , "main   = compose id id test"
+          ]
+      prog        = parseTricu src
+      progElim    = map elimLambda prog
+      evalBefore  = result (evalTricu Map.empty prog)
+      evalAfter   = result (evalTricu Map.empty progElim)
+  evalAfter @?= evalBefore
+
+stressElimLambda :: TestTree
+stressElimLambda = testCase "stress elimLambda on wide list under deep curried lambda" $ do
+  let numVars = 200
+      numBody = 800
+      vars    = [ "x" ++ show i | i <- [1..numVars] ]
+      body    = "(" ++ unwords (replicate numBody "t") ++ ")"
+      etaOne  = "h : f h"
+      etaTwo  = "k : id k"
+      defId   = "id = a : a"
+      lambda  = unwords vars ++ " : " ++ body
+      src     = unlines
+                  [ defId
+                  , etaOne
+                  , "compose = f g x : f (g x)"
+                  , "f = t t"
+                  , etaTwo
+                  , lambda
+                  , "main = compose id id (" ++ head vars ++ " : f " ++ head vars ++ ")"
+                  ]
+      prog    = parseTricu src
+
+  let out = map elimLambda prog
+  let noLambda term = case term of
+        SLambda _ _ -> False
+        SApp f g    -> noLambda f && noLambda g
+        SList xs    -> all noLambda xs
+        TFork l r   -> noLambda l && noLambda r
+        TStem u     -> noLambda u
+        _           -> True
+
+  assertBool "all lambdas eliminated" (all noLambda out)
+
+  let before = result (evalTricu Map.empty prog)
+      after  = result (evalTricu Map.empty out)
+  after @?= before

test/comments-1.tri

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

test/lambda-A.tri

@@ -1 +1 @@
-main = (\x : x) t
+main = (x : x) t

test/map.tri

@@ -1,2 +1,2 @@
-x = map (\i : append "Successfully concatenated " i) [("two strings!")]
+x = map (i : append "Successfully concatenated " i) [("two strings!")]
 main = equal? x [("Successfully concatenated two strings!")]

test/size.tri

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

test/string.tri

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

test/vars-B.tri

@@ -1 +1 @@
-y = \x : x
+y = x : x

tricu.cabal

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