Again.

02-trees/main.rkt

@@ -25,18 +25,18 @@
           ; 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
           ; Recursively checks left & right with lower & upper bounds.
           (define (recurse t lower upper)
-            (cond [(symbol? t) (symbol=? t 'end)]
+            (or (symbol? t)
-                  [else (and (<2 lower (tree-n t) upper)
+                (and (<2 lower (tree-n t) upper)
-                             (recurse (tree-left t) lower (tree-n t))
+                     (recurse (tree-left t) lower (tree-n t))
-                             (recurse (tree-right t) (tree-n t) upper))]))]
+                     (recurse (tree-right t) (tree-n t) upper))))]
-         (recurse t 'quite-little 'very-big)))
+    (recurse t 'quite-little 'very-big)))
 
 (check-expect (bst? sprout) #t)
 (check-expect (bst? sapling) #t)

04-typed-racket/main.rkt

@@ -61,9 +61,10 @@
 ; good-bt?: t BT → Bool
 ; Determine whether bt is good.
 (define (good-bt? t)
-  ()
+  (cases t
-  #|
+    [end (symbol]))
-  (local [; <2: U{Num, Sym}, Num, U{Num, Sym} → Bool
+#|  (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]