Fixed and typed result/option monads

2 files changed, 20 insertions, 18 deletions

diff --git a/std/Option.bruijn b/std/Option.bruijn
index b48fdc2..c0d57b4 100644
--- a/std/Option.bruijn
+++ b/std/Option.bruijn
@@ -1,45 +1,46 @@
 # MIT License, Copyright (c) 2022 Marvin Borner
 
 :import std/Combinator .
+:import std/Logic .
 
 # empty option
-none true
+none true ⧗ (Option a)
 
 # encapsulates value in option
-some [[[0 2]]]
+some [[[0 2]]] ⧗ (Option a)
 
 # checks whether option is none
-none? [0 true [false]]
+none? [0 true [false]] ⧗ (Option a) → Boolean
 
 :test (none? none) (true)
 :test (none? (some [[0]])) (false)
 
 # checks whether option is some
-some? [0 false [true]]
+some? [0 false [true]] ⧗ (Option a) → Boolean
 
 :test (some? none) (false)
 :test (some? (some [[0]])) (true)
 
 # applies a function to the value in option
-map [[0 none [some (2 0)]]]
+map [[0 none [some (2 0)]]] ⧗ (a → b) → (Option a) → (Option b)
 
 :test (map [[1]] (some [[0]])) (some [[[0]]])
 :test (map [[1]] none) (none)
 
 # applies a function to the value in option or returns first arg if none
-map-or [[[0 2 1]]]
+map-or [[[0 2 1]]] ⧗ (a → b) → (Option a) → (Option c)
 
 :test (map-or [[[2]]] [[1]] (some [[0]])) ([[[0]]])
 :test (map-or [[[2]]] [[1]] none) ([[[2]]])
 
 # extracts value from option or returns first argument if none
-unwrap-or [[0 1 I]]
+unwrap-or [[0 1 i]] ⧗ a → (Option b) → c
 
 :test (unwrap-or false (some true)) (true)
 :test (unwrap-or false none) (false)
 
 # applies encapsulated value to given function
-apply [[1 none 0]]
+apply [[1 none 0]] ⧗ (Option a) → (a → b) → c
 
 :test (apply none [some ([[1]] 0)]) (none)
 :test (apply (some [[0]]) [some ([[1]] 0)]) (some [[[0]]])
diff --git a/std/Result.bruijn b/std/Result.bruijn
index fe4561b..838032c 100644
--- a/std/Result.bruijn
+++ b/std/Result.bruijn
@@ -1,62 +1,63 @@
 # MIT License, Copyright (c) 2022 Marvin Borner
 
 :import std/Combinator .
+:import std/Logic .
 :import std/Option .
 
 # encapsulates a value in ok
-ok [[[1 2]]]
+ok [[[1 2]]] ⧗ (Result a)
 
 :test (ok [[0]]) ([[1 [[0]]]])
 
 # encapsulates a value in err
-err [[[0 2]]]
+err [[[0 2]]] ⧗ (Result a)
 
 :test (err [[0]]) ([[0 [[0]]]])
 
 # checks whether result is ok
-ok? [0 [true] [false]]
+ok? [0 [true] [false]] ⧗ (Result a) → Boolean
 
 :test (ok? (ok [[0]])) (true)
 :test (ok? (err [[0]])) (false)
 
 # checks whether result is not ok
-err? [0 [false] [true]]
+err? [0 [false] [true]] ⧗ (Result a) → Boolean
 
 :test (err? (ok [[0]])) (false)
 :test (err? (err [[0]])) (true)
 
 # encapsulates result ok value in a option
-option-ok [0 some [none]]
+option-ok [0 some [none]] ⧗ (Result a) → (Option a)
 
 :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]
+option-err [0 [none] some] ⧗ (Result a) → (Option a)
 
 :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]]]
+unwrap-or [[0 i [2]]] ⧗ a → (Result b) → c
 
 :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]]
+map [[0 [ok (2 0)] err]] ⧗ (a → b) → (Result a) → (Result b)
 
 :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)]]]
+map-err [[0 ok [err (2 0)]]] ⧗ (a → b) → (Result a) → (Result b)
 
 :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]]
+apply [[1 0 err]] ⧗ (Result a) → (a → b) → (Result b)
 
 :test (apply (err [[0]]) [ok ([[1]] 0)]) (err [[0]])
 :test (apply (ok [[0]]) [ok ([[1]] 0)]) (ok [[[0]]])