forgot to add maybe.rkt and either.rkt

racket/typed/either.rkt

@@ -0,0 +1,34 @@
+#lang turnstile
+
+(provide Left
+         Right
+         Either
+         left
+         right
+         partition/either)
+
+(require "core-types.rkt")
+(require "core-expressions.rkt")
+(require "for-loops.rkt")
+(require "list.rkt")
+
+(define-constructor* (left : Left v))
+(define-constructor* (right : Right v))
+
+(define-type-alias (Either A B)
+  (U (Left A)
+     (Right B)))
+
+(define (∀ (X Y Z) (partition/either [xs : (List X)]
+                                     [pred : (→fn X (Either Y Z))]
+                                     -> (Tuple (List Y) (List Z))))
+  (for/fold ([acc (Tuple (List Y) (List Z)) (tuple (list) (list))])
+            ([x xs])
+    (define y-or-z (pred x))
+    (match y-or-z
+      [(left (bind y Y))
+       (tuple (cons y (select 0 acc))
+              (select 1 acc))]
+      [(right (bind z Z))
+       (tuple (select 0 acc)
+              (cons z (select 1 acc)))])))

racket/typed/maybe.rkt

@@ -0,0 +1,37 @@
+#lang turnstile
+
+(provide Maybe
+         None
+         None*
+         Some
+         some
+         none)
+
+(require "core-types.rkt")
+
+
+(define-constructor* (none* : None*))
+(define-constructor* (some : Some v))
+
+(define-type-alias None (None*))
+
+(define none : None
+  (none*))
+
+(define-type-alias (Maybe X)
+  (U None
+     (Some X)))
+
+#;(define (∀ (X Y) (partition/maybe [xs : (List X)]
+                                  [pred : (→fn X (Maybe Y))]
+                                  -> (Tuple (List Y) (List X))))
+    #f)
+
+#;(require (only-in "core-expressions.rkt" match error discard)
+         "prim.rkt")
+#;(define (∀ (X) (unwrap! [x : (Maybe X)] -> (Maybe X)))
+  (match x
+    [(some discard)
+     (error "some")]
+    [none
+     (error "none")]))