Combinator replacements

8 files changed, 195 insertions, 183 deletions

diff --git a/std/Byte.bruijn b/std/Byte.bruijn
index 72e2c6e..3dd8c63 100644
--- a/std/Byte.bruijn
+++ b/std/Byte.bruijn
@@ -5,10 +5,10 @@
 :import std/List .
 
 # bit 0
-b0 F
+b0 false
 
 # bit 1
-b1 T
+b1 true
 
 # generates a byte with correct endianness
-byte [[[[[[[[cons 0 (cons 1 (cons 2 (cons 3 (cons 4 (cons 5 (cons 6 (cons 7 empty)))))))]]]]]]]]
+byte [[[[[[[[0 : (1 : (2 : (3 : (4 : (5 : (6 : (7 : empty)))))))]]]]]]]]
diff --git a/std/Combinator.bruijn b/std/Combinator.bruijn
index 45158e9..6144519 100644
--- a/std/Combinator.bruijn
+++ b/std/Combinator.bruijn
@@ -48,13 +48,13 @@ E [[[[[4 3 (2 1 0)]]]]]
 E' [[[[[[[6 (5 4 3) (2 1 0)]]]]]]]
 
 # Finch combinator
-Fi [[[0 1 2]]]
+F [[[0 1 2]]]
 
 # Finch once removed combinator
-Fi* [[[[3 0 1 2]]]]
+F* [[[[3 0 1 2]]]]
 
 # Finch twice removed combinator
-Fi** [[[[[4 3 0 1 2]]]]]
+F** [[[[[4 3 0 1 2]]]]]
 
 # Goldfinch combinator
 G [[[[3 0 (2 1)]]]]
@@ -138,10 +138,10 @@ R** [[[[[4 3 1 0 2]]]]]
 # Starling combinator: <*>
 S [[[2 0 (1 0)]]]
 
-# Thrush combinator
-Th [[0 1]]
+# Thrush combinator: Flipped $
+T [[0 1]]
 
-(&) Th
+(&) T
 
 # Turing combinator
 U [[0 (1 1 0)]]
@@ -180,10 +180,10 @@ Z [[1 [1 1 0]] [1 [1 1 0]]]
 i [0 S K]
 
 # True
-T K
+true K
 
 # False
-F KI
+false KI
 
 # -- combinator equivalency tests --
 
@@ -200,9 +200,9 @@ F KI
 :test (D'') (B B (B B))
 :test (E) (B (B B B))
 :test (E') (B (B B B) (B (B B B)))
-:test (Fi) (E Th Th E Th)
-:test (Fi*) (B C* R*)
-:test (Fi**) (B Fi*)
+:test (F) (E T T E T)
+:test (F*) (B C* R*)
+:test (F**) (B F*)
 :test (G) (B B C)
 :test (H) (B W (B C))
 :test (I) (S K K)
@@ -216,15 +216,15 @@ F KI
 :test (Q) (C B)
 :test (Q') (B C B)
 :test (Q'') (C (B C B))
-:test (Q''') (B Th)
-:test (Q'''') (Fi* B)
-:test (R) (B B Th)
+:test (Q''') (B T)
+:test (Q'''') (F* B)
+:test (R) (B B T)
 :test (R*) (C* C*)
 :test (R**) (B R*)
-:test (Th) (C I)
+:test (T) (C I)
 :test (U) (L O)
-:test (V) (B C Th)
-:test (V*) (C* Fi*)
+:test (V) (B C T)
+:test (V*) (C* F*)
 :test (V**) (B V*)
 :test (W) (C (B M R))
 :test (W*) (B W)
diff --git a/std/List.bruijn b/std/List.bruijn
index 6cabfd1..d1f6394 100644
--- a/std/List.bruijn
+++ b/std/List.bruijn
@@ -9,13 +9,13 @@
 :import std/Number N
 
 # empty list element
-empty F
+empty false
 
 # returns whether a list is empty
-empty? [0 [[[F]]] T]
+empty? [0 [[[false]]] true]
 
-:test (empty? empty) (T)
-:test (empty? (cons (+2) empty)) (F)
+:test (empty? empty) (true)
+:test (empty? (cons (+2) empty)) (false)
 
 # appends an element to a list
 cons P.pair
@@ -75,14 +75,14 @@ map Z [[[empty? 0 [empty] [(2 (head 1)) : (3 2 (tail 1))] I]]]
 # applies a left fold on a list
 foldl Z [[[[empty? 0 [2] [4 3 (3 2 (head 1)) (tail 1)] I]]]]
 
-:test (N.eq? (foldl N.add (+0) ((+1) : ((+2) : ((+3) : empty)))) (+6)) (T)
-:test (N.eq? (foldl N.sub (+6) ((+1) : ((+2) : ((+3) : empty)))) (+0)) (T)
+:test (N.eq? (foldl N.add (+0) ((+1) : ((+2) : ((+3) : empty)))) (+6)) (true)
+:test (N.eq? (foldl N.sub (+6) ((+1) : ((+2) : ((+3) : empty)))) (+0)) (true)
 
 # applies a right fold on a list
 foldr [[[Z [[empty? 0 [4] [5 (head 1) (2 (tail 1))] I]] 0]]]
 
-:test (N.eq? (foldr N.add (+0) ((+1) : ((+2) : ((+3) : empty)))) (+6)) (T)
-:test (N.eq? (foldr N.sub (+2) ((+1) : ((+2) : ((+3) : empty)))) (+0)) (T)
+:test (N.eq? (foldr N.add (+0) ((+1) : ((+2) : ((+3) : empty)))) (+6)) (true)
+:test (N.eq? (foldr N.sub (+2) ((+1) : ((+2) : ((+3) : empty)))) (+0)) (true)
 
 # filters a list based on a predicate
 filter Z [[[empty? 0 [empty] [2 (head 1) (cons (head 1)) I (3 2 (tail 1))] I]]]
diff --git a/std/Logic.bruijn b/std/Logic.bruijn
index c2a12a4..a254715 100644
--- a/std/Logic.bruijn
+++ b/std/Logic.bruijn
@@ -2,82 +2,82 @@
 
 :import std/Combinator .
 
-not [0 F T]
+not [0 false true]
 
 !( not
 
-:test (!T) (F)
-:test (!F) (T)
+:test (!true) (false)
+:test (!false) (true)
 
-and [[1 0 F]]
+and [[1 0 false]]
 
 (&&) and
 
-:test (T && T) (T)
-:test (T && F) (F)
-:test (F && T) (F)
-:test (F && F) (F)
+:test (true && true) (true)
+:test (true && false) (false)
+:test (false && true) (false)
+:test (false && false) (false)
 
-nand [[1 0 1 F T]]
+nand [[1 0 1 false true]]
 
-:test (nand T T) (F)
-:test (nand T F) (T)
-:test (nand F T) (T)
-:test (nand F F) (T)
+:test (nand true true) (false)
+:test (nand true false) (true)
+:test (nand false true) (true)
+:test (nand false false) (true)
 
-or [[1 T 0]]
+or [[1 true 0]]
 
 (||) or
 
-:test (T || T) (T)
-:test (T || F) (T)
-:test (F || T) (T)
-:test (F || F) (F)
+:test (true || true) (true)
+:test (true || false) (true)
+:test (false || true) (true)
+:test (false || false) (false)
 
-nor [[1 1 0 F T]]
+nor [[1 1 0 false true]]
 
-:test (nor T T) (F)
-:test (nor T F) (F)
-:test (nor F T) (F)
-:test (nor F F) (T)
+:test (nor true true) (false)
+:test (nor true false) (false)
+:test (nor false true) (false)
+:test (nor false false) (true)
 
 xor [[1 (not 0) 0]]
 
-:test (xor T T) (F)
-:test (xor T F) (T)
-:test (xor F T) (T)
-:test (xor F F) (F)
+:test (xor true true) (false)
+:test (xor true false) (true)
+:test (xor false true) (true)
+:test (xor false false) (false)
 
 xnor [[1 0 (not 0)]]
 
-:test (xnor T T) (T)
-:test (xnor T F) (F)
-:test (xnor F T) (F)
-:test (xnor F F) (T)
+:test (xnor true true) (true)
+:test (xnor true false) (false)
+:test (xnor false true) (false)
+:test (xnor false false) (true)
 
 if [[[2 1 0]]]
 
 (?!) if
 
-:test (if T T F) (T)
-:test ((T ?! T) F) (T)
-:test (if F T F) (F)
-:test ((F ?! T) F) (F)
+:test (if true true false) (true)
+:test ((true ?! true) false) (true)
+:test (if false true false) (false)
+:test ((false ?! true) false) (false)
 
 implies [[or (not 1) 0]]
 
 (=>?) implies
 
-:test (T =>? T) (T)
-:test (T =>? F) (F)
-:test (F =>? T) (T)
-:test (F =>? F) (T)
+:test (true =>? true) (true)
+:test (true =>? false) (false)
+:test (false =>? true) (true)
+:test (false =>? false) (true)
 
 iff [[and (implies 1 0) (implies 0 1)]]
 
 (<=>?) iff
 
-:test (T <=>? T) (T)
-:test (T <=>? F) (F)
-:test (F <=>? T) (F)
-:test (F <=>? F) (T)
+:test (true <=>? true) (true)
+:test (true <=>? false) (false)
+:test (false <=>? true) (false)
+:test (false <=>? false) (true)
diff --git a/std/Number.bruijn b/std/Number.bruijn
index bd54232..de56762 100644
--- a/std/Number.bruijn
+++ b/std/Number.bruijn
@@ -1,5 +1,5 @@
 # MIT License, Copyright (c) 2022 Marvin Borner
-# According to works of T.Æ. Mogensen
+# Heavily inspired by the works of T.Æ. Mogensen (see refs in README)
 
 :import std/Combinator .
 
@@ -11,29 +11,29 @@
 trit-neg [[[2]]]
 
 # returns whether a trit is negative
-trit-neg? [0 T F F]
+trit-neg? [0 true false false]
 
 # positive trit indicating coeffecient of (+1)
 trit-pos [[[1]]]
 
 # returns whether a trit is positive
-trit-pos? [0 F T F]
+trit-pos? [0 false true false]
 
 # zero trit indicating coeffecient of 0
 trit-zero [[[0]]]
 
 # returns whether a trit is zero
-trit-zero? [0 F F T]
-
-:test (trit-neg? trit-neg) (T)
-:test (trit-neg? trit-pos) (F)
-:test (trit-neg? trit-zero) (F)
-:test (trit-pos? trit-neg) (F)
-:test (trit-pos? trit-pos) (T)
-:test (trit-pos? trit-zero) (F)
-:test (trit-zero? trit-neg) (F)
-:test (trit-zero? trit-pos) (F)
-:test (trit-zero? trit-zero) (T)
+trit-zero? [0 false false true]
+
+:test (trit-neg? trit-neg) (true)
+:test (trit-neg? trit-pos) (false)
+:test (trit-neg? trit-zero) (false)
+:test (trit-pos? trit-neg) (false)
+:test (trit-pos? trit-pos) (true)
+:test (trit-pos? trit-zero) (false)
+:test (trit-zero? trit-neg) (false)
+:test (trit-zero? trit-pos) (false)
+:test (trit-zero? trit-zero) (true)
 
 # shifts a negative trit into a balanced ternary number
 up-neg [[[[[2 (4 3 2 1 0)]]]]]
@@ -71,10 +71,10 @@ up [[[[[[5 2 1 0 (4 3 2 1 0)]]]]]]
 
 # shifts the least significant trit out - basically div by 3
 down [snd (0 z neg pos zero)]
-	z pair (+0) (+0)
-	neg [0 [[pair (^<1) 1]]]
-	pos [0 [[pair (^>1) 1]]]
-	zero [0 [[pair (^=1) 1]]]
+	z (+0) : (+0)
+	neg [0 [[(^<1) : 1]]]
+	pos [0 [[(^>1) : 1]]]
+	zero [0 [[(^=1) : 1]]]
 
 # negates a balanced ternary number
 negate [[[[[4 3 1 2 0]]]]]
@@ -87,19 +87,19 @@ negate [[[[[4 3 1 2 0]]]]]
 
 # converts a balanced ternary number to a list of trits
 list! [0 z neg pos zero]
-	z F
-	neg [[pair trit-neg 1]]
-	pos [[pair trit-pos 1]]
-	zero [[pair trit-zero 1]]
+	z true
+	neg [[trit-neg : 1]]
+	pos [[trit-pos : 1]]
+	zero [[trit-zero : 1]]
 
 # TODO: Tests!
 
 # strips leading 0s from balanced ternary number
 strip [fst (0 z neg pos zero)]
-	z pair (+0) T
-	neg [0 [[pair (^<1) F]]]
-	pos [0 [[pair (^>1) F]]]
-	zero [0 [[pair (0 (+0) (^=1)) 0]]]
+	z (+0) : true
+	neg [0 [[(^<1) : false]]]
+	pos [0 [[(^>1) : false]]]
+	zero [0 [[(0 (+0) (^=1)) : 0]]]
 
 ~( strip
 
@@ -133,30 +133,30 @@ negative? [trit-neg? (mst 0)]
 
 <?( negative?
 
-:test (<?(+0)) (F)
-:test (<?(-1)) (T)
-:test (<?(+1)) (F)
-:test (<?(+42)) (F)
+:test (<?(+0)) (false)
+:test (<?(-1)) (true)
+:test (<?(+1)) (false)
+:test (<?(+42)) (false)
 
 # returns whether balanced ternary number is positive
 positive? [trit-pos? (mst 0)]
 
 >?( positive?
 
-:test (>?(+0)) (F)
-:test (>?(-1)) (F)
-:test (>?(+1)) (T)
-:test (>?(+42)) (T)
+:test (>?(+0)) (false)
+:test (>?(-1)) (false)
+:test (>?(+1)) (true)
+:test (>?(+42)) (true)
 
 # checks whether balanced ternary number is zero
-zero? [0 T [F] [F] I]
+zero? [0 true [false] [false] I]
 
 =?( zero?
 
-:test (=?(+0)) (T)
-:test (=?(-1)) (F)
-:test (=?(+1)) (F)
-:test (=?(+42)) (F)
+:test (=?(+0)) (true)
+:test (=?(-1)) (false)
+:test (=?(+1)) (false)
+:test (=?(+42)) (false)
 
 # converts the normal balanced ternary representation into abstract
 # -> the abstract representation is used in add/sub/mul
@@ -183,21 +183,21 @@ normal! ω rec
 # -> ignores leading 0s!
 eq? [[abs 1 (abstract! 0)]]
 	z [zero? (normal! 0)]
-	neg [[0 F [2 0] [F] [F]]]
-	pos [[0 F [F] [2 0] [F]]]
-	zero [[0 (1 0) [F] [F] [2 0]]]
+	neg [[0 false [2 0] [false] [false]]]
+	pos [[0 false [false] [2 0] [false]]]
+	zero [[0 (1 0) [false] [false] [2 0]]]
 	abs [0 z neg pos zero]
 
 (=?) eq?
 
-:test ((-42) =? (-42)) (T)
-:test ((-1) =? (-1)) (T)
-:test ((-1) =? (+0)) (F)
-:test ((+0) =? (+0)) (T)
-:test ((+1) =? (+0)) (F)
-:test ((+1) =? (+1)) (T)
-:test ((+42) =? (+42)) (T)
-:test ([[[[(1 (0 (0 (0 (0 3)))))]]]] =? (+1)) (T)
+:test ((-42) =? (-42)) (true)
+:test ((-1) =? (-1)) (true)
+:test ((-1) =? (+0)) (false)
+:test ((+0) =? (+0)) (true)
+:test ((+1) =? (+0)) (false)
+:test ((+1) =? (+1)) (true)
+:test ((+42) =? (+42)) (true)
+:test ([[[[(1 (0 (0 (0 (0 3)))))]]]] =? (+1)) (true)
 
 # I believe Mogensen's Paper has an error in its inc/dec/add/mul/eq definitions.
 # They use 3 instead of 2 abstractions in the functions, also we use switched
@@ -206,39 +206,39 @@ eq? [[abs 1 (abstract! 0)]]
 
 # adds (+1) to a balanced ternary number (can introduce leading 0s)
 inc [snd (0 z neg pos zero)]
-	z pair (+0) (+1)
-	neg [0 [[pair (^<1) (^=1)]]]
-	zero [0 [[pair (^=1) (^>1)]]]
-	pos [0 [[pair (^>1) (^<0)]]]
+	z (+0) : (+1)
+	neg [0 [[(^<1) : (^=1)]]]
+	zero [0 [[(^=1) : (^>1)]]]
+	pos [0 [[(^>1) : (^<0)]]]
 
 ++( inc
 
 # adds (+1) to a balanced ternary number and strips leading 0s
-ssinc [~(++0)]
+ssinc strip . inc
 
-:test ((++(-42)) =? (-41)) (T)
-:test ((++(-1)) =? (+0)) (T)
-:test ((++(+0)) =? (+1)) (T)
-:test ((++(++(++(++(++(+0)))))) =? (+5)) (T)
-:test ((++(+42)) =? (+43)) (T)
+:test ((++(-42)) =? (-41)) (true)
+:test ((++(-1)) =? (+0)) (true)
+:test ((++(+0)) =? (+1)) (true)
+:test ((++(++(++(++(++(+0)))))) =? (+5)) (true)
+:test ((++(+42)) =? (+43)) (true)
 
 # subs (+1) from a balanced ternary number (can introduce leading 0s)
 dec [snd (0 dec-z dec-neg dec-pos dec-zero)]
-	dec-z pair (+0) (-1)
-	dec-neg [0 [[pair (^<1) (^>0)]]]
-	dec-zero [0 [[pair (^=1) (^<1)]]]
-	dec-pos [0 [[pair (^>1) (^=1)]]]
+	dec-z (+0) : (-1)
+	dec-neg [0 [[(^<1) : (^>0)]]]
+	dec-zero [0 [[(^=1) : (^<1)]]]
+	dec-pos [0 [[(^>1) : (^=1)]]]
 
 --( dec
 
 # subs (+1) from a balanced ternary number and strips leading 0s
-ssub [~(--0)]
+sdec strip . dec
 
-:test ((--(-42)) =? (-43)) (T)
-:test ((--(+0)) =? (-1)) (T)
-:test ((--(--(--(--(--(+5)))))) =? (+0)) (T)
-:test ((--(+1)) =? (+0)) (T)
-:test ((--(+42)) =? (+41)) (T)
+:test ((--(-42)) =? (-43)) (true)
+:test ((--(+0)) =? (-1)) (true)
+:test ((--(--(--(--(--(+5)))))) =? (+0)) (true)
+:test ((--(+1)) =? (+0)) (true)
+:test ((--(+42)) =? (+41)) (true)
 
 # adds two balanced ternary numbers (can introduce leading 0s)
 add [[abs 1 (abstract! 0)]]
@@ -257,14 +257,14 @@ add [[abs 1 (abstract! 0)]]
 (+) add
 
 # adds two balanced ternary numbers and strips leading 0s
-sadd [[~(1 + 0)]]
+sadd strip ... add
 
-:test (((-42) + (-1)) =? (-43)) (T)
-:test (((-5) + (+6)) =? (+1)) (T)
-:test (((-1) + (+0)) =? (-1)) (T)
-:test (((+0) + (+0)) =? (+0)) (T)
-:test (((+1) + (+2)) =? (+3)) (T)
-:test (((+42) + (+1)) =? (+43)) (T)
+:test (((-42) + (-1)) =? (-43)) (true)
+:test (((-5) + (+6)) =? (+1)) (true)
+:test (((-1) + (+0)) =? (-1)) (true)
+:test (((+0) + (+0)) =? (+0)) (true)
+:test (((+1) + (+2)) =? (+3)) (true)
+:test (((+42) + (+1)) =? (+43)) (true)
 
 # subs two balanced ternary numbers (can introduce leading 0s)
 sub [[1 + -0]]
@@ -272,14 +272,14 @@ sub [[1 + -0]]
 (-) sub
 
 # subs two balanced ternary numbers and strips leading 0s
-ssub [[~(1 - 0)]]
+ssub strip ... sub
 
-:test (((-42) - (-1)) =? (-41)) (T)
-:test (((-5) - (+6)) =? (-11)) (T)
-:test (((-1) - (+0)) =? (-1)) (T)
-:test (((+0) - (+0)) =? (+0)) (T)
-:test (((+1) - (+2)) =? (-1)) (T)
-:test (((+42) - (+1)) =? (+41)) (T)
+:test (((-42) - (-1)) =? (-41)) (true)
+:test (((-5) - (+6)) =? (-11)) (true)
+:test (((-1) - (+0)) =? (-1)) (true)
+:test (((+0) - (+0)) =? (+0)) (true)
+:test (((+1) - (+2)) =? (-1)) (true)
+:test (((+42) - (+1)) =? (+41)) (true)
 
 # returns whether number is greater than other number
 gre? [[negative? (sub 0 1)]]
@@ -299,9 +299,9 @@ mul [[1 (+0) neg pos zero]]
 
 (*) mul
 
-smul [[strip (mul 1 0)]]
+smul strip ... mul
 
-:test (((+42) * (+0)) =? (+0)) (T)
-:test (((-1) * (+42)) =? (-42)) (T)
-:test (((+3) * (+11)) =? (+33)) (T)
-:test (((+42) * (-4)) =? (-168)) (T)
+:test (((+42) * (+0)) =? (+0)) (true)
+:test (((-1) * (+42)) =? (-42)) (true)
+:test (((+3) * (+11)) =? (+33)) (true)
+:test (((+42) * (-4)) =? (-168)) (true)
diff --git a/std/Option.bruijn b/std/Option.bruijn
index c8a9a95..26de3de 100644
--- a/std/Option.bruijn
+++ b/std/Option.bruijn
@@ -3,20 +3,20 @@
 :import std/Combinator .
 
 # empty option
-none T
+none true
 
 # encapsulates value in option
 some [[[0 2]]]
 
 # checks whether option is none
-none? [0 T [F]]
-:test (none? none) (T)
-:test (none? (some [[0]])) (F)
+none? [0 true [false]]
+:test (none? none) (true)
+:test (none? (some [[0]])) (false)
 
 # checks whether option is some
-some? [0 F [T]]
-:test (some? none) (F)
-:test (some? (some [[0]])) (T)
+some? [0 false [true]]
+:test (some? none) (false)
+:test (some? (some [[0]])) (true)
 
 # applies a function to the value in option
 map [[0 none [some (2 0)]]]
@@ -30,8 +30,8 @@ map-or [[[0 2 1]]]
 
 # extracts value from option or returns first argument if none
 unwrap-or [[0 1 I]]
-:test (unwrap-or F (some T)) (T)
-:test (unwrap-or F none) (F)
+:test (unwrap-or false (some true)) (true)
+:test (unwrap-or false none) (false)
 
 # applies encapsulated value to given function
 apply [[1 none 0]]
diff --git a/std/Pair.bruijn b/std/Pair.bruijn
index cca4217..46302cc 100644
--- a/std/Pair.bruijn
+++ b/std/Pair.bruijn
@@ -5,32 +5,34 @@
 # pairs two expressions into one
 pair [[[0 2 1]]]
 
+(:) pair
+
 # extracts first expression from pair
-fst [0 T]
+fst [0 K]
 
 # test fst with example pair of [[0]] and [[1]]
-:test (fst (pair [[0]] [[1]])) ([[0]])
+:test (fst ([[0]] : [[1]])) ([[0]])
 
 # extracts second expression from pair
-snd [0 F]
+snd [0 KI]
 
 # test snd with example pair of [[0]] and [[1]]
-:test (snd (pair [[0]] [[1]])) ([[1]])
+:test (snd ([[0]] : [[1]])) ([[1]])
 
 # applies both elements of a pair to a function
 uncurry [[1 (fst 0) (snd 0)]]
 
 # test uncurry with example pair of [[0]] and [[1]] and some combinator
-:test (uncurry W (pair [[0]] [[1]])) ([[1]])
+:test (uncurry W ([[0]] : [[1]])) ([[1]])
 
 # applies a function to the pair of two values
-curry [[[2 (pair 1 0)]]]
+curry [[[2 (1 : 0)]]]
 
 # test curry with example pair of [[0]] and [[1]] and fst
 :test (curry fst [[0]] [[1]]) ([[0]])
 
 # swaps the values of a pair
-swap [pair (snd 0) (fst 0)]
+swap [(snd 0) : (fst 0)]
 
 # test swap with example pair of [[0]] and [[1]]
-:test (swap (pair [[0]] [[1]])) (pair [[1]] [[0]])
+:test (swap ([[0]] : [[1]])) ([[1]] : [[0]])
diff --git a/std/Result.bruijn b/std/Result.bruijn
index 3e9960d..fe4561b 100644
--- a/std/Result.bruijn
+++ b/std/Result.bruijn
@@ -5,48 +5,58 @@
 
 # encapsulates a value in ok
 ok [[[1 2]]]
+
 :test (ok [[0]]) ([[1 [[0]]]])
 
 # encapsulates a value in err
 err [[[0 2]]]
+
 :test (err [[0]]) ([[0 [[0]]]])
 
 # checks whether result is ok
-ok? [0 [T] [F]]
-:test (ok? (ok [[0]])) (T)
-:test (ok? (err [[0]])) (F)
+ok? [0 [true] [false]]
+
+:test (ok? (ok [[0]])) (true)
+:test (ok? (err [[0]])) (false)
 
 # checks whether result is not ok
-err? [0 [F] [T]]
-:test (err? (ok [[0]])) (F)
-:test (err? (err [[0]])) (T)
+err? [0 [false] [true]]
+
+:test (err? (ok [[0]])) (false)
+:test (err? (err [[0]])) (true)
 
 # encapsulates result ok value in a option
 option-ok [0 some [none]]
+
 :test (option-ok (ok [[0]])) (some [[0]])
 :test (option-ok (err [[0]])) (none)
 
 # encapsulate result err value in a option
 option-err [0 [none] some]
+
 :test (option-err (ok [[0]])) (none)
 :test (option-err (err [[0]])) (some [[0]])
 
 # extracts value from result or returns first arg
 unwrap-or [[0 I [2]]]
+
 :test (unwrap-or [[1]] (ok [[0]])) ([[0]])
 :test (unwrap-or [[1]] (err [[0]])) ([[1]])
 
 # applies a function to the value in ok result
 map [[0 [ok (2 0)] err]]
+
 :test (map [[1]] (ok [[0]])) (ok [[[0]]])
 :test (map [[1]] (err [[0]])) (err [[0]])
 
 # applies a function to the value in err result
 map-err [[0 ok [err (2 0)]]]
+
 :test (map-err [[1]] (ok [[0]])) ((ok [[0]]))
 :test (map-err [[1]] (err [[0]])) ((err [[[0]]]))
 
 # applies encapsulated value to given function (if ok)
 apply [[1 0 err]]
+
 :test (apply (err [[0]]) [ok ([[1]] 0)]) (err [[0]])
 :test (apply (ok [[0]]) [ok ([[1]] 0)]) (ok [[[0]]])