Finished typed racket. It sucks.

04-typed-racket/main.rkt

@@ -57,32 +57,49 @@
         (Node 6 end (Node 11 end end))
         (Node 12 end end)))
 
-(: good-bt? : (BT -> Boolean))
+; <2: U{Num, Sym}, Num, U{Num, Sym} → Bool
-; good-bt?: t BT → Bool
+(: <2 : ((U Number Symbol) Number (U Number Symbol) -> Boolean))
-; Determine whether bt is good.
+; Convenient form of greater than. Slightly hack.
-(define (good-bt? t)
+(define (<2 a b c)
-  (cases t
-    [end (symbol]))
-#|  (local [; <2: U{Num, Sym}, Num, U{Num, Sym} → Bool
-          (: (U Number Symbol))
-          ; Convenient form of greater than. Slightly hack.
-          (define (<2 a b c)
   (cond [(and (symbol? a) (symbol? c)) #t]
-                  [(symbol? a) (< (- b 1) b c)]
+        [(symbol? a) (< b c)]
-                  [(symbol? c) (< a b (+ b 1))]
+        [(symbol? c) (< a b)]
         [else (< a b c)]))
 
-          ; recurse: t: Tree, lower: Num, upper: Num → Bool
+; recurse: t: Tree, lower: U{Num, Sym}, upper: U{Num, Sym} → Bool
-          ; Recursively checks left & right with lower & upper bounds.
+(: good-bt?r : (BT (U Number Symbol) (U Number Symbol) -> Boolean))
-          (define (recurse t lower upper)
+; Recursively checks left & right with lower & upper bounds.
-            (cond [(symbol? t) (symbol=? t 'end)]
+(define (good-bt?r t lower upper)
-                  [else (and (<2 lower (tree-n t) upper)
+  (cases t
-                             (recurse (tree-left t) lower (tree-n t))
+    [(Node n t1 t2) (and (<2 lower n upper)
-                             (recurse (tree-right t) (tree-n t) upper))]))]
+                         (good-bt?r t1 lower n)
-         (recurse t 'quite-little 'very-big)))|#
+                         (good-bt?r t2 n upper))]
+    [(End what) #t]))
 
-(check-expect (bst? sprout) #t)
+; good-bt?: t BT → Bool
-(check-expect (bst? sapling) #t)
+(: good-bt? : (BT -> Boolean))
-(check-expect (bst? good-tree) #t)
+; Determine whether bt is good.
-(check-expect (bst? broke-tree) #f)
+(define (good-bt? t)
-(check-expect (bst? deeply-broke-tree) #f)
+  (good-bt?r t 'quite-little 'very-big))
+
+(test (good-bt? sprout) => #t)
+(test (good-bt? sapling) => #t)
+(test (good-bt? deeply-broke-tree) => #f)
+
+; goodies/help: l: [A], i: Index, a: [Index] → [Index]
+(: goodies/help : (All(A) (A -> Boolean) (Listof A) Number (Listof Number) -> (Listof Number)))
+(define (goodies/help good? l i a)
+  (match l
+    ['() (reverse a)]
+    [(cons f r) (if (good? f)
+                    (goodies/help good? r (add1 i) (cons i a))
+                    (goodies/help good? r (add1 i) a))]))
+
+; goodies: good?: (A → Boolean), l: [A] → [Index]
+(: goodies : (All(A) (A -> Boolean) (Listof A) -> (Listof Number)))
+; Returns a list of indices considered "good."
+(define (goodies good? l)
+  (goodies/help good? l 0 '()))
+
+(test (goodies even? '(1 2 3 4 5)) => '(1 3))
+(test (goodies even? '()) => '())