From f2beb86d8a64799510d3524a05900379a0abe37c Mon Sep 17 00:00:00 2001 From: James Eversole Date: Tue, 15 Apr 2025 10:34:38 -0500 Subject: [PATCH] Drop backslash from lambda definitions --- README.md | 17 ++++----- demos/equality.tri | 8 ++-- demos/levelOrderTraversal.tri | 56 +++++++++++++-------------- demos/size.tri | 8 ++-- demos/toSource.tri | 8 ++-- lib/base.tri | 64 +++++++++++++++---------------- lib/list.tri | 72 +++++++++++++++++------------------ lib/patterns.tri | 38 +++++++++--------- src/Parser.hs | 8 ++-- test/Spec.hs | 58 ++++++++++++++-------------- test/comments-1.tri | 4 +- test/lambda-A.tri | 2 +- test/map.tri | 2 +- test/size.tri | 14 +++---- test/string.tri | 2 +- test/vars-B.tri | 2 +- 16 files changed, 181 insertions(+), 182 deletions(-) diff --git a/README.md b/README.md index a62c8fd..c5d6d4f 100644 --- 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 index 86ace3b..16b1ccc 100644 --- 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 index 803a1dd..9474cdb 100644 --- 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 index cbfd6c9..12e0a25 100644 --- 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 index 354943e..0141382 100644 --- 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 index 1dbc0ef..a6e7641 100644 --- 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 index 4b9640f..b888b6b 100644 --- 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 index 48b2d12..bad463b 100644 --- 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 index ba9a7de..8efa9e4 100644 --- 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 index 86b97d7..ea4d54d 100644 --- 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 index 82ef6bd..a3997c6 100644 --- 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 index da8cc0f..24a68a2 100644 --- 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 index 95fb49f..6af4820 100644 --- 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 index 2efd2c1..fdf51a8 100644 --- 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 index db492a2..44beb0a 100644 --- 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 index 765d006..44bcb7b 100644 --- a/test/vars-B.tri +++ b/test/vars-B.tri @@ -1 +1 @@ -y = \x : x +y = x : x