commit d89f406026b6e5c9d19938ff59c27b1bb28f2c28
parent 59002258c09f5c8fb87bd0b741c2243e20ee4063
Author: James Eversole <james@eversole.co>
Date: Tue, 15 Apr 2025 10:34:38 -0500
Drop backslash from lambda definitions
Diffstat:
16 files changed, 181 insertions(+), 183 deletions(-)
diff --git a/README.md b/README.md
@@ -11,12 +11,11 @@ tricu is the word for "tree" in Lojban: `(x1) is a tree of species/cultivar (x2)
## Features
- Tree Calculus operator: `t`
-- Assignments: `x = t t`
-- Immutable definitions
-- Lambda abstraction syntax: `id = (\a : a)`
+- Immutable definitions: `x = t t`
+- Lambda abstraction: `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")]`
+- 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
@@ -24,15 +23,15 @@ tricu is the word for "tree" in Lojban: `(x1) is a tree of species/cultivar (x2)
```
tricu < -- Anything after `--` on a single line is a comment
-tricu < id = (\a : a) -- Lambda abstraction is eliminated to tree calculus terms
-tricu < head (map (\i : append i " world!") [("Hello, ")])
+tricu < id = (a : a) -- Lambda abstraction is eliminated to tree calculus terms
+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 < test = triage "Leaf" (\z : "Stem") (\a b : "Fork")
+tricu < triage = (a b c : t (t a b) c)
+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)
diff --git a/demos/equality.tri b/demos/equality.tri
@@ -11,11 +11,11 @@ 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_matchBool = (\ot of : demo_triage
+demo_triage = a b c : t (t a b) c
+demo_matchBool = (ot of : demo_triage
of
- (\_ : ot)
- (\_ _ : ot)
+ (_ : ot)
+ (_ _ : ot)
)
-- Lambda representation of the Boolean `not` function
not_Lambda? = demo_matchBool demo_false demo_true
diff --git a/demos/levelOrderTraversal.tri b/demos/levelOrderTraversal.tri
@@ -18,47 +18,47 @@ main = exampleTwo
-- / / \
-- 4 5 6
-label = \node : head node
+label = node : head node
-left = (\node : if (emptyList? node)
- []
- (if (emptyList? (tail 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)))
- []
+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))
+processLevel = y (self queue : if (emptyList? queue)
+ []
+ (pair (map label queue) (self (filter
+ (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)
- ""
- (append
- (append (map (\x : append x " ") (head levels)) "")
+toLineString = y (self levels : if (emptyList? levels)
+ ""
+ (append
+ (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]
+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]]]
+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]]]
diff --git a/demos/size.tri b/demos/size.tri
@@ -3,11 +3,11 @@
main = size size
-size = (\x :
- (y (\self x :
+size = (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))
diff --git a/demos/toSource.tri b/demos/toSource.tri
@@ -18,7 +18,7 @@ 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.
@@ -26,7 +26,7 @@ sourceStem = (\convert : (\a 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.
@@ -36,7 +36,7 @@ sourceFork = (\convert : (\a b 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)))"
diff --git a/lib/base.tri b/lib/base.tri
@@ -1,74 +1,74 @@
false = t
_ = t
true = t t
-id = \a : a
-const = \a b : a
+id = a : 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)))
- (\x : x x)
- (\a0 a1 a2 : t (t a0) (t t a2) a1))
+y = ((mut wait fun : wait mut (x : fun (wait mut x)))
+ (x : x x)
+ (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
-test = triage "Leaf" (\_ : "Stem") (\_ _ : "Fork")
+triage = leaf stem fork : t (t leaf stem) fork
+test = triage "Leaf" (_ : "Stem") (_ _ : "Fork")
-matchBool = (\ot of : triage
+matchBool = (ot of : triage
of
- (\_ : ot)
- (\_ _ : ot)
+ (_ : ot)
+ (_ _ : ot)
)
lAnd = (triage
- (\_ : false)
- (\_ x : x)
- (\_ _ x : x))
+ (_ : false)
+ (_ x : x)
+ (_ _ x : x))
lOr = (triage
- (\x : x)
- (\_ _ : true)
- (\_ _ _ : true))
+ (x : x)
+ (_ _ : 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))
- (\ax :
+ (_ : false)
+ (_ _ : false))
+ (ax :
triage
false
(self ax)
- (\_ _ : false))
- (\ax ay :
+ (_ _ : false))
+ (ax ay :
triage
false
- (\_ : false)
- (\bx by : lAnd (self ax bx) (self ay by))))
+ (_ : false)
+ (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))
diff --git a/lib/list.tri b/lib/list.tri
@@ -1,68 +1,68 @@
!import "base.tri" !Local
-matchList = \a b : triage a _ b
+matchList = a b : triage a _ b
-emptyList? = matchList true (\_ _ : false)
-head = matchList t (\head _ : head)
-tail = matchList t (\_ tail : tail)
+emptyList? = matchList true (_ _ : false)
+head = matchList t (head _ : head)
+tail = matchList t (_ tail : tail)
-append = y (\self : matchList
- (\k : k)
- (\h r k : pair h (self r k)))
+append = y (self : matchList
+ (k : k)
+ (h r k : pair h (self r k)))
-lExist? = y (\self x : matchList
+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)
- (\head tail f : pair (f head) (self tail f)))
-map = \f l : map_ l f
+ (_ : t)
+ (head tail f : pair (f head) (self tail f)))
+map = f l : map_ l f
-filter_ = y (\self : matchList
- (\_ : t)
- (\head tail f : matchBool (t head) id (f head) (self tail f)))
-filter = \f l : filter_ l f
+filter_ = y (self : matchList
+ (_ : t)
+ (head tail f : matchBool (t head) id (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
+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
+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
-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
diff --git a/lib/patterns.tri b/lib/patterns.tri
@@ -1,36 +1,36 @@
!import "list.tri" !Local
-match_ = y (\self value patterns :
+match_ = y (self value patterns :
triage
t
- (\_ : t)
- (\pattern rest :
+ (_ : t)
+ (pattern rest :
triage
t
- (\_ : t)
- (\test result :
+ (_ : t)
+ (test result :
if (test value)
(result value)
(self value rest))
pattern)
patterns)
-match = (\value patterns :
- match_ value (map (\sublist :
+match = (value patterns :
+ match_ value (map (sublist :
pair (head sublist) (head (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!")]])
+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!")]])
diff --git a/src/Parser.hs b/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
diff --git a/test/Spec.hs b/test/Spec.hs
@@ -87,7 +87,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 +107,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 +149,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
@@ -259,7 +259,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,84 +267,84 @@ 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"
, 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"
, 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"
, 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"
, 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"
, 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)"
, 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"
, 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"
, 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"
, 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"
, 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)"
, 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"
, 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))"
, 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)"
, 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"
, 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"
, 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))))"
, 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)))))"
, 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)"
, testCase "Lambda containing list literal" $ do
- let input = "(\\a : [(a)]) 1"
+ let input = "(a : [(a)]) 1"
runTricu input @?= "Fork (Fork (Stem Leaf) Leaf) Leaf"
]
@@ -419,7 +419,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
@@ -554,4 +554,4 @@ decoding = testGroup "Decoding Tests"
, testCase "Decode nested lists with strings" $ do
let input = ofList [ofList [ofString "nested"], ofString "string"]
decodeResult input @?= "[[\"nested\"], \"string\"]"
- ]
-\ No newline at end of file
+ ]
diff --git a/test/comments-1.tri b/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
diff --git a/test/lambda-A.tri b/test/lambda-A.tri
@@ -1 +1 @@
-main = (\x : x) t
+main = (x : x) t
diff --git a/test/map.tri b/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!")]
diff --git a/test/size.tri b/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 :
- (y (\self x :
+size = (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
diff --git a/test/string.tri b/test/string.tri
@@ -1 +1 @@
-head (map (\i : append "String " i) [("test!")])
+head (map (i : append "String " i) [("test!")])
diff --git a/test/vars-B.tri b/test/vars-B.tri
@@ -1 +1 @@
-y = \x : x
+y = x : x
