James/tricu
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Drop backslash from lambda definitions

Browse Source
This commit is contained in:
James Eversole
2025-04-15 10:34:38 -05:00
parent 5024a2be4c
commit f2beb86d8a
16 changed files with 181 additions and 182 deletions
Download Patch File Download Diff File Expand all files Collapse all files

58
test/Spec.hs
View File

@ -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\"]"
]
]

4
test/comments-1.tri
View File

@ -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

2
test/lambda-A.tri
View File

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

2
test/map.tri
View File

@ -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!")]

14
test/size.tri
View File

@ -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

2
test/string.tri
View File

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

2
test/vars-B.tri
View File

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