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

Ergonomic language features and lib cleanup

Browse Source 
+ let bindings
+ where bindings
+ do notation

I explored enough of the alternative language design space and decided
that we should commit fully to Lambda style. That means no more highly
tacit/concatenative point-free/partial programs as default. We'll keep
taking advantage of those capabilities when it makes sense, but the
library will continue to see massive overhauls.
This commit is contained in:
James Eversole
2026-05-22 18:23:13 -05:00
parent 7cea3d1559
commit 2e2db07bd6
17 changed files with 1039 additions and 589 deletions
Download Patch File Download Diff File Expand all files Collapse all files

315
lib/list.tri
View File

@@ -8,144 +8,188 @@ 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)))
lExist? = y (self x : matchList
false
(h z : or? (equal? x h) (self x z)))
map_ = y (self :
append_ self xs ys =
matchList
(_ : t)
(head tail f : pair (f head) (self tail f)))
map = f l : map_ l f
ys
(h r : pair h (self r ys))
xs
append = xs ys : y append_ xs ys
filter_ = y (self : matchList
(_ : t)
(head tail f : matchBool (t head) id (f head) (self tail f)))
filter = f l : filter_ l f
lExist?_ self x xs =
matchList
false
(h r : or? (equal? x h) (self x r))
xs
lExist? = x xs : y lExist?_ x xs
foldl_ = y (self l f x : matchList (acc : acc) (head tail acc : self tail f (f acc head)) l x)
foldl = f x l : foldl_ l f x
map_ self l f =
matchList
t
(h r : pair (f h) (self r f))
l
map = f l : y map_ l f
foldr_ = y (self l f x : matchList x (head tail : f (self tail f x) head) l)
foldr = f x l : foldr_ l f x
filter_ self l f =
matchList
t
(h r :
matchBool
(pair h (self r f))
(self r f)
(f h))
l
filter = f l : y filter_ l f
length = y (self : matchList
0
(_ tail : succ (self tail)))
foldl_ self l f acc =
matchList
acc
(h r : self r f (f acc h))
l
foldl = f x l : y foldl_ l f x
reverse_ = y (self xs acc :
foldr_ self l f x =
matchList
x
(h r : f (self r f x) h)
l
foldr = f x l : y foldr_ l f x
length_ self xs =
matchList
0
(_ r : succ (self r))
xs
length = xs : y length_ xs
reverse_ self xs acc =
matchList
acc
(h r : self r (pair h acc))
xs)
xs
reverse = xs : y reverse_ xs t
reverse = xs : reverse_ xs t
snoc_ self x xs =
matchList
(pair x t)
(h r : pair h (self x r))
xs
snoc = x xs : y snoc_ x xs
snoc = y (self x : matchList
(pair x t)
(h z : pair h (self x z)))
count_ self x xs =
matchList
0
(h r :
matchBool
(succ (self x r))
(self x r)
(equal? x h))
xs
count = x xs : y count_ x xs
count = y (self x : matchList
0
(h z : matchBool
(succ (self x z))
(self x z)
(equal? x h)))
last = y (self : matchList
t
(hd tl : matchBool
hd
(self tl)
(emptyList? tl)))
all? = y (self pred : matchList
true
(h z : and? (pred h) (self pred z)))
any? = y (self pred : matchList
false
(h z : or? (pred h) (self pred z)))
intersect = xs ys : filter (x : lExist? x ys) xs
nth_ = y (self n xs i :
last_ self xs =
matchList
t
(h r :
matchBool
h
(self n r (succ i))
(equal? i n))
xs)
(self r)
(emptyList? r))
xs
last = xs : y last_ xs
nth = n xs : nth_ n xs 0
all?_ self pred xs =
matchList
true
(h r : and? (pred h) (self pred r))
xs
all? = pred xs : y all?_ pred xs
any?_ self pred xs =
matchList
false
(h r : or? (pred h) (self pred r))
xs
any? = pred xs : y any?_ pred xs
intersect = xs ys : filter (x : lExist? x ys) xs
nth_ self xs n i =
matchList
t
(h r :
matchBool
h
(self r n (succ i))
(equal? i n))
xs
nth = n xs : y nth_ xs n 0
headMaybe = matchList nothing (h _ : just h)
lastMaybe = y (self : matchList
nothing
(hd tl : matchBool
(just hd)
(self tl)
(emptyList? tl)))
nthMaybe_ = y (self n xs i :
lastMaybe_ self xs =
matchList
nothing
(h r :
matchBool
(just h)
(self n r (succ i))
(self r)
(emptyList? r))
xs
lastMaybe = xs : y lastMaybe_ xs
nthMaybe_ self xs n i =
matchList
nothing
(h r :
matchBool
(just h)
(self r n (succ i))
(equal? i n))
xs)
xs
nthMaybe = n xs : y nthMaybe_ xs n 0
nthMaybe = n xs : nthMaybe_ n xs 0
take_ = y (self n xs i :
take_ self xs n i =
matchList
t
(h r :
matchBool
t
(pair h (self n r (succ i)))
(pair h (self r n (succ i)))
(equal? i n))
xs)
xs
take = n xs : y take_ xs n 0
take = n xs : take_ n xs 0
drop_ = y (self n xs i :
drop_ self xs n i =
matchBool
xs
(matchList
t
(_ r : self n r (succ i))
(_ r : self r n (succ i))
xs)
(equal? i n))
drop = n xs : drop_ n xs 0
(equal? i n)
drop = n xs : y drop_ xs n 0
splitAt = n xs : pair (take n xs) (drop n xs)
concatMap_ = y (self f xs :
concatMap_ self f xs =
matchList
t
(h r : append (f h) (self f r))
xs)
xs
concatMap = f xs : y concatMap_ f xs
concatMap = f xs : concatMap_ f xs
find = y (self pred xs :
find_ self pred xs =
matchList
nothing
(h r : matchBool (just h) (self pred r) (pred h))
xs)
(h r :
matchBool
(just h)
(self pred r)
(pred h))
xs
find = pred xs : y find_ pred xs
partition_ = y (self pred xs trues falses :
partition_ self pred xs trues falses =
matchList
(pair (reverse trues) (reverse falses))
(h r :
@@ -153,83 +197,80 @@ partition_ = y (self pred xs trues falses :
(self pred r (pair h trues) falses)
(self pred r trues (pair h falses))
(pred h))
xs)
partition = pred xs : partition_ pred xs t t
xs
partition = pred xs : y partition_ pred xs t t
strLength = length
strAppend = append
strEq? = equal?
strEmpty? = emptyList?
startsWith? = (prefix input :
((go :
go prefix input)
(y (self p s :
startsWith?_ self prefix input =
matchList
true
(ph pr :
matchList
true
(ph pr :
matchList
false
(sh sr :
matchBool
(self pr sr)
false
(sh sr :
matchBool
(self pr sr)
false
(equal? ph sh))
s)
p))))
(equal? ph sh))
input)
prefix
startsWith? = prefix input : y startsWith?_ prefix input
endsWith? = prefix str : startsWith? (reverse prefix) (reverse str)
contains? = y (self needle haystack :
contains?_ self needle haystack =
matchBool
true
(matchList
false
(_ r : self needle r)
haystack)
(startsWith? needle haystack))
(startsWith? needle haystack)
contains? = needle haystack : y contains?_ needle haystack
lines_ = y (self str :
linesFinish current accRev =
reverse (pair (reverse current) accRev)
lines_ self str accRev current =
matchList
(acc current : snoc (reverse current) acc)
(linesFinish current accRev)
(h r :
acc current :
matchBool
(self r (snoc (reverse current) acc) t)
(self r acc (pair h current))
(self r (pair (reverse current) accRev) t)
(self r accRev (pair h current))
(equal? h 10))
str)
str
lines = str : y lines_ str t t
lines = str : lines_ str t t
unlines = y (self lines :
unlines_ self lines =
matchList
""
(h r : append h (append "\n" (self r)))
lines)
lines
unlines = lines : y unlines_ lines
words_ = y (self str :
wordsAdd current accRev =
matchBool
accRev
(pair (reverse current) accRev)
(emptyList? current)
words_ self str accRev current =
matchList
(acc current :
matchBool
acc
(snoc (reverse current) acc)
(emptyList? current))
(reverse (wordsAdd current accRev))
(h r :
acc current :
matchBool
(matchBool
(self r acc current)
(self r (snoc (reverse current) acc) t)
(emptyList? current))
(self r acc (pair h current))
(self r (wordsAdd current accRev) t)
(self r accRev (pair h current))
(equal? h 32))
str)
str
words = str : y words_ str t t
words = str : words_ str t t
unwords = y (self words :
unwords_ self words =
matchList
""
(h r :
@@ -237,9 +278,10 @@ unwords = y (self words :
h
(append h (append " " (self r)))
(emptyList? r))
words)
words
unwords = words : y unwords_ words
zipWith = y (self f xs ys :
zipWith_ self f xs ys =
matchList
t
(xh xt :
@@ -247,4 +289,5 @@ zipWith = y (self f xs ys :
t
(yh yt : pair (f xh yh) (self f xt yt))
ys)
xs)
xs
zipWith = f xs ys : y zipWith_ f xs ys