diff --git a/collects/compiler/info.ss b/collects/compiler/info.ss
index e13ab00fa8..3d6a517bac 100644
--- a/collects/compiler/info.ss
+++ b/collects/compiler/info.ss
@@ -9,4 +9,4 @@
   (define mred-launcher-names (list "gmzc"))
 
   (define compile-omit-files
-    '("mrspidey.ss" "mrspideyf.ss" "mrspideyi.ss" "embedr.ss")))
+    '("embedr.ss")))
diff --git a/collects/frtime/etc.ss b/collects/frtime/etc.ss
index 5a644b70de..9f74ecdb52 100644
--- a/collects/frtime/etc.ss
+++ b/collects/frtime/etc.ss
@@ -1,7 +1,6 @@
 
 (module etc (lib "frtime.ss" "frtime")
-  (require (lib "spidey.ss")
-           (lib "main-collects.ss" "setup"))
+  (require (lib "main-collects.ss" "setup"))
   (require-for-syntax (lib "kerncase.ss" "syntax")
 		      (lib "stx.ss" "syntax")
 		      (lib "name.ss" "syntax")
@@ -39,11 +38,10 @@
   (define true #t)
   (define false #f)
   
-  (define identity (polymorphic (lambda (x) x)))
+  (define identity (lambda (x) x))
   
   (define compose
-    (polymorphic
-     (case-lambda 
+    (case-lambda 
       [(f) (if (procedure? f) f (raise-type-error 'compose "procedure" f))]
       [(f g)
        (let ([f (compose f)]
@@ -63,7 +61,7 @@
                     f)))))]
       [(f . more)
        (let ([m (apply compose more)])
-         (compose f m))])))
+         (compose f m))]))
   
 
 #|
@@ -88,8 +86,7 @@
   
 #|
   (define build-vector
-    (polymorphic
-     (lambda (n fcn)
+    (lambda (n fcn)
        (unless (and (integer? n) (exact? n) (>= n 0))
          (error 'build-vector "~s must be an exact integer >= 0" n))
        (unless (procedure? fcn)
@@ -99,11 +96,10 @@
            (if (= i n) vec
                (begin
                  (vector-set! vec i (fcn i))
-                 (loop (add1 i)))))))))
+                 (loop (add1 i))))))))
   |#
   (define  build-list
-    (polymorphic
-     (lambda  (n  fcn)
+    (lambda  (n  fcn)
        (unless  (and (integer? n) (exact? n) (>= n 0))
          (error  'build-list  "~s must be an exact integer >= 0"  n))
        (unless  (procedure? fcn)
@@ -111,15 +107,14 @@
        (let loop ([i (sub1 n)]  [p '()])
          (if  (>= i 0)
               (loop (sub1 i) (cons (fcn i) p))
-              p)))))
+              p))))
 
   (define loop-until
-    (polymorphic
-     (lambda (start done? next body)
+    (lambda (start done? next body)
        (let loop ([i start])
          (unless (done? i)
            (body i)
-           (loop (next i)))))))
+           (loop (next i))))))
   
   (define boolean=?
     (lambda (x y)
diff --git a/collects/mzlib/etc.ss b/collects/mzlib/etc.ss
index b664fae6be..7a03accef3 100644
--- a/collects/mzlib/etc.ss
+++ b/collects/mzlib/etc.ss
@@ -1,15 +1,13 @@
 
 (module etc mzscheme
-  
-  (require "spidey.ss"
-           (lib "main-collects.ss" "setup"))
-  
+
+  (require (lib "main-collects.ss" "setup"))
+
   (require-for-syntax (lib "kerncase.ss" "syntax")
 		      (lib "stx.ss" "syntax")
 		      (lib "name.ss" "syntax")
 		      (lib "context.ss" "syntax")
                       (lib "main-collects.ss" "setup")
-                      "list.ss"
                       "private/stxset.ss")
 
   
@@ -48,11 +46,10 @@
   (define true #t)
   (define false #f)
   
-  (define identity (polymorphic (lambda (x) x)))
+  (define identity (lambda (x) x))
   
   (define compose
-    (polymorphic
-     (case-lambda 
+    (case-lambda 
       [(f) (if (procedure? f) f (raise-type-error 'compose "procedure" f))]
       [(f g)
        (let ([f (compose f)]
@@ -72,379 +69,299 @@
                     f)))))]
       [(f . more)
        (let ([m (apply compose more)])
-         (compose f m))])))
-  
+         (compose f m))]))
+
+
+  (define (build-string n fcn)
+    (unless (and (integer? n) (exact? n) (>= n 0))
+      (error 'build-string  "~s must be an exact integer >= 0"  n))
+    (unless (procedure? fcn)
+      (error 'build-string  "~s must be a procedure"  fcn))
+      (let ([str (make-string n)])
+        (let loop ((i 0))
+          (if (= i n)
+            str
+            (begin (string-set! str i (fcn i)) (loop (add1 i)))))))
 
-  (define  build-string
-    (lambda  (n  fcn)
-      (unless  (and (integer? n) (exact? n) (>= n 0))
-        (error  'build-string  "~s must be an exact integer >= 0"  n))
-      (unless  (procedure? fcn)
-        (error  'build-string  "~s must be a procedure"  fcn))
-      (let  ((str  (make-string n)))
-        (let  loop  ((i  0))
-          (if (= i n)  
-              str
-              (begin
-                (string-set!  str  i  (fcn i))
-                (loop  (add1 i))))))))
-  
   ;; (build-vector n f) returns a vector 0..n-1 where the ith element is (f i).
   ;; The eval order is guaranteed to be: 0, 1, 2, ..., n-1.
   ;; eg: (build-vector 4 (lambda (i) i)) ==> #4(0 1 2 3)
-  
-  (define  build-vector
-    (polymorphic
-     (lambda  (n  fcn)
-       (unless  (and (integer? n) (exact? n) (>= n 0))
-         (error  'build-vector  "~s must be an exact integer >= 0"  n))
-       (unless  (procedure? fcn)
-         (error  'build-vector  "~s must be a procedure"  fcn))
-       (let  ((vec  (make-vector n)))
-         (let  loop  ((i  0))
-           (if  (= i n)  vec
-                (begin
-                  (vector-set!  vec  i  (fcn i))
-                  (loop  (add1 i)))))))))
-  
-  (define  build-list
-    (polymorphic
-     (lambda  (n  fcn)
-       (unless  (and (integer? n) (exact? n) (>= n 0))
-         (error  'build-list  "~s must be an exact integer >= 0"  n))
-       (unless  (procedure? fcn)
-         (error  'build-list  "~s must be a procedure"  fcn))
-       (if  (zero? n)  '()
-            (let  ([head  (list (fcn 0))])
-              (let  loop  ([i 1]  [p head])
-                (if  (= i n)  head
-                     (begin
-                       (set-cdr!  p  (list (fcn i)))
-                       (loop  (add1 i)  (cdr p))))))))))
-  
-  (define loop-until
-    (polymorphic
-     (lambda (start done? next body)
-       (let loop ([i start])
-         (unless (done? i)
-           (body i)
-           (loop (next i)))))))
-  
-  (define boolean=?
-    (lambda (x y)
-      (unless (and (boolean? x)
-                   (boolean? y))
-        (raise-type-error 'boolean=? 
-                          "boolean"
-                          (if (boolean? x) y x)))
-      (eq? x y)))
-  
-  (define (symbol=? x y)
-    (unless (and (symbol? x)
-		 (symbol? y))
-      (raise-type-error 'symbol=? "symbol"
-			(if (symbol? x) y x)))
+
+  (define (build-vector n fcn)
+    (unless (and (integer? n) (exact? n) (>= n 0))
+      (error 'build-vector  "~s must be an exact integer >= 0"  n))
+    (unless (procedure? fcn)
+      (error 'build-vector  "~s must be a procedure"  fcn))
+    (let ([vec (make-vector n)])
+      (let loop ((i 0))
+        (if (= i n)
+          vec
+          (begin (vector-set! vec i (fcn i)) (loop (add1 i)))))))
+
+  (define (build-list n fcn)
+    (unless (and (integer? n) (exact? n) (>= n 0))
+      (error 'build-list  "~s must be an exact integer >= 0"  n))
+    (unless (procedure? fcn)
+      (error 'build-list  "~s must be a procedure"  fcn))
+    (if (zero? n)
+      '()
+      (let ([head (list (fcn 0))])
+        (let loop ([i 1] [p head])
+          (if (= i n)
+            head
+            (begin (set-cdr! p (list (fcn i)))
+                   (loop (add1 i) (cdr p))))))))
+
+  (define (loop-until start done? next body)
+    (let loop ([i start])
+      (unless (done? i)
+        (body i)
+        (loop (next i)))))
+
+  (define (boolean=? x y)
+    (unless (and (boolean? x) (boolean? y))
+      (raise-type-error 'boolean=? "boolean" (if (boolean? x) y x)))
     (eq? x y))
 
- (define-syntax opt-lambda 
-   (lambda (stx)
-     (with-syntax ([name (or (syntax-local-infer-name stx)
-			     (quote-syntax opt-lambda-proc))])
-       (syntax-case stx ()
-	 [(_ args body1 body ...)
-	  (let ([clauses (let loop ([pre-args null]
-				    [args (syntax args)]
-				    [needs-default? #f])
-			   (syntax-case args ()
-			     [id
-			      (identifier? (syntax id))
-			      (with-syntax ([(pre-arg ...) pre-args])
-				(syntax ([(pre-arg ... . id)
-					  body1 body ...])))]
-                             [()
-			      (with-syntax ([(pre-arg ...) pre-args])
-				(syntax ([(pre-arg ...)
-					  body1 body ...])))]
-			     [(id . rest)
-			      (identifier? (syntax id))
-			      (begin
-				(when needs-default?
-				  (raise-syntax-error
-				   #f
-				   "default value missing"
-				   stx
-				   (syntax id)))
-				(loop (append pre-args (list (syntax id)))
-				      (syntax rest)
-				      #f))]
-			     [([id default] . rest)
-			      (identifier? (syntax id))
-                              (with-syntax ([rest (loop (append pre-args (list (syntax id)))
-                                                        (syntax rest)
-                                                        #t)]
-                                            [(pre-arg ...) pre-args])
-                                (syntax ([(pre-arg ...) (name pre-arg ... default)]
-                                         . rest)))]
-			     [(bad . rest)
-			      (raise-syntax-error
-			       #f
-			       "not an identifier or identifier with default"
-			       stx
-			       (syntax bad))]
-			     [else
-			      (raise-syntax-error
-			       #f
-			       "bad identifier sequence"
-			       stx
-			       (syntax args))]))])
-            (with-syntax ([clauses clauses])
-              (syntax/loc stx
-                          (letrec ([name
-                                    (case-lambda
-                                     . clauses)])
-                            name))))]))))
- 
- (define-syntax local 
-   (lambda (stx)
+  (define (symbol=? x y)
+    (unless (and (symbol? x) (symbol? y))
+      (raise-type-error 'symbol=? "symbol" (if (symbol? x) y x)))
+    (eq? x y))
+
+ (define-syntax (opt-lambda stx)
+   (with-syntax ([name (or (syntax-local-infer-name stx)
+                           (quote-syntax opt-lambda-proc))])
      (syntax-case stx ()
-       [(_ (defn ...) body1 body ...)
-	(let ([defs (let ([expand-context (generate-expand-context)])
-		      (let loop ([defns (syntax->list (syntax (defn ...)))])
-			(apply
-			 append
-			 (map
-			  (lambda (defn)
-			    (let ([d (local-expand
-				      defn
-				      expand-context
-				      (kernel-form-identifier-list 
-				       (quote-syntax here)))]
-				  [check-ids (lambda (ids)
-					       (for-each
-						(lambda (id)
-						  (unless (identifier? id)
-						    (raise-syntax-error
-						     #f
-						     "not an identifier for definition"
-						     stx
-						     id)))
-						ids))])
-			      (syntax-case d (define-values define-syntaxes begin)
-				[(begin defn ...)
-				 (loop (syntax->list (syntax (defn ...))))]
-				[(define-values (id ...) body)
-				 (begin
-				   (check-ids (syntax->list (syntax (id ...))))
-				   (list d))]
-				[(define-values . rest)
-				 (raise-syntax-error
-				  #f
-				  "ill-formed definition"
-				  stx
-				  d)]
-				[(define-syntaxes (id ...) body)
-				 (begin
-				   (check-ids (syntax->list (syntax (id ...))))
-				   (list d))]
-				[(define-syntaxes . rest)
-				 (raise-syntax-error
-				  #f
-				  "ill-formed definition"
-				  stx
-				  d)]
-				[_else
-				 (raise-syntax-error
-				  #f
-				  "not a definition"
-				  stx
-				  defn)])))
-			  defns))))])
-	  (let ([ids (apply append
-			    (map
-			     (lambda (d)
-			       (syntax-case d ()
-				 [(_ ids . __)
-				  (syntax->list (syntax ids))]))
-			     defs))])
-	    (let ([dup (check-duplicate-identifier ids)])
-	      (when dup
-		(raise-syntax-error
-		 #f
-		 "duplicate identifier"
-		 stx
-		 dup)))
-	    (with-syntax ([(def ...) defs])
-	      (syntax/loc
-	       stx
-	       (let ()
-		 def ...
-		 (let ()
-		   body1
-		   body ...))))))]
-       [(_ x body1 body ...)
-	(raise-syntax-error
-	 #f
-	 "not a definition sequence"
-	 stx
-	 (syntax x))])))
+       [(_ args body1 body ...)
+        (let ([clauses (let loop ([pre-args null]
+                                  [args (syntax args)]
+                                  [needs-default? #f])
+                         (syntax-case args ()
+                           [id
+                            (identifier? (syntax id))
+                            (with-syntax ([(pre-arg ...) pre-args])
+                              (syntax ([(pre-arg ... . id)
+                                        body1 body ...])))]
+                           [()
+                            (with-syntax ([(pre-arg ...) pre-args])
+                              (syntax ([(pre-arg ...)
+                                        body1 body ...])))]
+                           [(id . rest)
+                            (identifier? (syntax id))
+                            (begin
+                              (when needs-default?
+                                (raise-syntax-error
+                                 #f "default value missing" stx (syntax id)))
+                              (loop (append pre-args (list (syntax id)))
+                                    (syntax rest)
+                                    #f))]
+                           [([id default] . rest)
+                            (identifier? (syntax id))
+                            (with-syntax ([rest (loop (append pre-args (list (syntax id)))
+                                                      (syntax rest)
+                                                      #t)]
+                                          [(pre-arg ...) pre-args])
+                              (syntax ([(pre-arg ...) (name pre-arg ... default)]
+                                       . rest)))]
+                           [(bad . rest)
+                            (raise-syntax-error
+                             #f
+                             "not an identifier or identifier with default"
+                             stx
+                             (syntax bad))]
+                           [else
+                            (raise-syntax-error
+                             #f "bad identifier sequence" stx (syntax args))]))])
+          (with-syntax ([clauses clauses])
+            (syntax/loc stx
+              (letrec ([name (case-lambda . clauses)]) name))))])))
+
+ (define-syntax (local stx)
+   (syntax-case stx ()
+     [(_ (defn ...) body1 body ...)
+      (let ([defs (let ([expand-context (generate-expand-context)])
+                    (let loop ([defns (syntax->list (syntax (defn ...)))])
+                      (apply
+                       append
+                       (map
+                        (lambda (defn)
+                          (let ([d (local-expand
+                                    defn
+                                    expand-context
+                                    (kernel-form-identifier-list 
+                                     (quote-syntax here)))]
+                                [check-ids (lambda (ids)
+                                             (for-each
+                                              (lambda (id)
+                                                (unless (identifier? id)
+                                                  (raise-syntax-error
+                                                   #f
+                                                   "not an identifier for definition"
+                                                   stx
+                                                   id)))
+                                              ids))])
+                            (syntax-case d (define-values define-syntaxes begin)
+                              [(begin defn ...)
+                               (loop (syntax->list (syntax (defn ...))))]
+                              [(define-values (id ...) body)
+                               (begin
+                                 (check-ids (syntax->list (syntax (id ...))))
+                                 (list d))]
+                              [(define-values . rest)
+                               (raise-syntax-error
+                                #f "ill-formed definition" stx d)]
+                              [(define-syntaxes (id ...) body)
+                               (begin
+                                 (check-ids (syntax->list (syntax (id ...))))
+                                 (list d))]
+                              [(define-syntaxes . rest)
+                               (raise-syntax-error
+                                #f "ill-formed definition" stx d)]
+                              [_else
+                               (raise-syntax-error
+                                #f "not a definition" stx defn)])))
+                        defns))))])
+        (let ([ids (apply append
+                          (map
+                           (lambda (d)
+                             (syntax-case d ()
+                               [(_ ids . __) (syntax->list (syntax ids))]))
+                           defs))])
+          (let ([dup (check-duplicate-identifier ids)])
+            (when dup
+              (raise-syntax-error #f "duplicate identifier" stx dup)))
+          (with-syntax ([(def ...) defs])
+            (syntax/loc stx
+              (let () def ... (let () body1 body ...))))))]
+     [(_ x body1 body ...)
+      (raise-syntax-error #f "not a definition sequence" stx (syntax x))]))
 
  ;; recur is another name for 'let' in a named let
- (define-syntax recur 
-   (lambda (stx)
-     (syntax-case stx ()
-       [(_ . rest)
-	(syntax/loc stx (let . rest))])))
+ (define-syntax (recur stx)
+   (syntax-case stx ()
+     [(_ . rest) (syntax/loc stx (let . rest))]))
 
  ;; define a recursive value
- (define-syntax rec
-   (lambda (stx)
-     (syntax-case stx ()
-       [(_ name expr)
-	(begin
-	  (unless (identifier? (syntax name))
-	    (raise-syntax-error
-	     #f
-	     "not an identifier"
-	     stx
-	     (syntax name)))
-	  (syntax/loc stx
-	      (letrec ([name expr])
-		name)))])))
+ (define-syntax (rec stx)
+   (syntax-case stx ()
+     [(_ name expr)
+      (begin (unless (identifier? (syntax name))
+               (raise-syntax-error #f "not an identifier" stx (syntax name)))
+             (syntax/loc stx (letrec ([name expr]) name)))]))
 
- (define-syntax evcase 
-   (lambda (stx)
-     (syntax-case stx ()
-       [(_ val [test body ...] ...)
-	(let ([tests (syntax->list (syntax (test ...)))])
-	  (with-syntax ([(a-test ...)
-			 (map
-			  (lambda (t)
-			    (syntax-case t (else)
-			      [else (syntax #t)]
-			      [_else (with-syntax ([t t])
-				       (syntax (eqv? evcase-v t)))]))
-			  tests)])
-	    ;; Make sure else is last:
-	    (unless (null? tests)
-	      (let loop ([tests tests])
-		(unless (null? (cdr tests))
-		  (when (and (identifier? (car tests))
-			     (module-identifier=? (quote-syntax else) (car tests)))
-		    (raise-syntax-error
-		     #f
-		     "else is not in last clause"
-		     stx
-		     (car tests)))
-		  (loop (cdr tests)))))
-	    (syntax/loc stx
-	      (let ([evcase-v val])
-		(cond
-		 [a-test
-		  (begin body ...)]
-		 ...)))))]
-       [(_ val something ...)
-	;; Provide a good error message:
-	(for-each
-	 (lambda (s)
-	   (syntax-case s ()
-	     [(t a ...)
-	      (raise-syntax-error
-	       #f
-	       "invalid clause"
-	       stx
-	       s)]))
-	 (syntax->list (syntax (something ...))))])))
-       
- (define-syntax nor
-   (lambda (stx)
-     (syntax-case stx ()
-       [(_ expr ...)
-	(syntax/loc stx (not (or expr ...)))])))
- 
- (define-syntax nand
-   (lambda (stx)
-     (syntax-case stx ()
-       [(_ expr ...)
-	(syntax/loc stx (not (and expr ...)))])))
+ (define-syntax (evcase stx)
+   (syntax-case stx ()
+     [(_ val [test body ...] ...)
+      (let ([tests (syntax->list (syntax (test ...)))])
+        (with-syntax ([(a-test ...)
+                       (map (lambda (t)
+                              (syntax-case t (else)
+                                [else (syntax #t)]
+                                [_else (with-syntax ([t t])
+                                         (syntax (eqv? evcase-v t)))]))
+                            tests)])
+          ;; Make sure else is last:
+          (unless (null? tests)
+            (let loop ([tests tests])
+              (unless (null? (cdr tests))
+                (when (and (identifier? (car tests))
+                           (module-identifier=? (quote-syntax else) (car tests)))
+                  (raise-syntax-error
+                   #f "else is not in last clause" stx (car tests)))
+                (loop (cdr tests)))))
+          (syntax/loc stx
+            (let ([evcase-v val])
+              (cond [a-test (begin body ...)]
+                    ...)))))]
+     [(_ val something ...)
+      ;; Provide a good error message:
+      (for-each
+       (lambda (s)
+         (syntax-case s ()
+           [(t a ...) (raise-syntax-error #f "invalid clause" stx s)]))
+       (syntax->list (syntax (something ...))))]))
 
- (define-syntax let+
-   (lambda (stx)
-     (syntax-case stx ()
-       [(_ [clause ...] body1 body ...)
-	(let ([clauses (syntax->list (syntax (clause ...)))]
-	      [bad (lambda (c n)
-		     (raise-syntax-error
-		      #f
-		      (format "illegal use of ~a for a clause" n)
-		      stx
-		      c))]
-	      [var? (lambda (x)
-		      (or (identifier? x)
-			  (let ([l (syntax->list x)])
-			    (and l
-				 (pair? l)
-				 (eq? (syntax-e (car l)) 'values)
-				 (andmap identifier? (cdr l))))))]
-	      [normal-var (lambda (x)
-			    (if (identifier? x)
-				(list x)
-				(cdr (syntax-e x))))])
-	  ;; syntax checks
-	  (for-each
-	   (lambda (clause)
-	     (syntax-case* clause (val rec vals recs _) (lambda (a b) 
-							  (eq? (syntax-e b) 
-							       (syntax-e a)))
-	       [(val var expr)
-		(var? (syntax var))
-		'ok]
-	       [(rec var expr)
-		(var? (syntax var))
-		'ok]
-	       [(vals (var expr) ...)
-		(andmap var? (syntax->list (syntax (var ...))))
-		'ok]
-	       [(recs (var expr) ...)
-		(andmap var? (syntax->list (syntax (var ...))))
-		'ok]
-	       [(_ expr0 expr ...)
-		'ok]
-	       [(val . __) (bad clause "val")]
-	       [(rec . __) (bad clause "rec")]
-	       [(vals . __) (bad clause "vals")]
-	       [(recs . __) (bad  clause"recs")]
-	       [(_ . __) (bad clause "_")]
-	       [_else (raise-syntax-error #f "bad clause" stx clause)]))
-	   clauses)
-	  ;; result
+ (define-syntax (nor stx)
+   (syntax-case stx ()
+     [(_ expr ...) (syntax/loc stx (not (or expr ...)))]))
+
+ (define-syntax (nand stx)
+   (syntax-case stx ()
+     [(_ expr ...) (syntax/loc stx (not (and expr ...)))]))
+
+ (define-syntax (let+ stx)
+   (syntax-case stx ()
+     [(_ [clause ...] body1 body ...)
+      (let ([clauses (syntax->list (syntax (clause ...)))]
+            [bad (lambda (c n)
+                   (raise-syntax-error
+                    #f (format "illegal use of ~a for a clause" n) stx c))]
+            [var? (lambda (x)
+                    (or (identifier? x)
+                        (let ([l (syntax->list x)])
+                          (and l
+                               (pair? l)
+                               (eq? (syntax-e (car l)) 'values)
+                               (andmap identifier? (cdr l))))))]
+            [normal-var (lambda (x)
+                          (if (identifier? x)
+                            (list x)
+                            (cdr (syntax-e x))))])
+        ;; syntax checks
+        (for-each
+         (lambda (clause)
+           (syntax-case* clause (val rec vals recs _)
+                         (lambda (a b) (eq? (syntax-e b) (syntax-e a)))
+             [(val var expr)
+              (var? (syntax var))
+              'ok]
+             [(rec var expr)
+              (var? (syntax var))
+              'ok]
+             [(vals (var expr) ...)
+              (andmap var? (syntax->list (syntax (var ...))))
+              'ok]
+             [(recs (var expr) ...)
+              (andmap var? (syntax->list (syntax (var ...))))
+              'ok]
+             [(_ expr0 expr ...)
+              'ok]
+             [(val . __) (bad clause "val")]
+             [(rec . __) (bad clause "rec")]
+             [(vals . __) (bad clause "vals")]
+             [(recs . __) (bad  clause"recs")]
+             [(_ . __) (bad clause "_")]
+             [_else (raise-syntax-error #f "bad clause" stx clause)]))
+         clauses)
+        ;; result
 	(let loop ([clauses clauses])
 	  (if (null? clauses)
-	      (syntax (let () body1 body ...))
-	      (with-syntax ([rest (loop (cdr clauses))])
-		(syntax-case* (car clauses) (val rec vals recs _)  (lambda (a b) 
-								     (eq? (syntax-e b) 
-									  (syntax-e a)))
-		  [(val var expr)
-		   (with-syntax ([vars (normal-var (syntax var))])
-		     (syntax (let-values ([vars expr]) rest)))]
-		  [(rec var expr)
-		   (with-syntax ([vars (normal-var (syntax var))])
-		     (syntax (letrec-values ([vars expr]) rest)))]
-		  [(vals (var expr) ...)
-		   (with-syntax ([(vars ...) (map normal-var (syntax->list (syntax (var ...))))])
-		     (syntax (let-values ([vars expr] ...) rest)))]
-		  [(recs (var expr) ...)
-		   (with-syntax ([(vars ...) (map normal-var (syntax->list (syntax (var ...))))])
-		     (syntax (letrec-values ([vars expr] ...) rest)))]
-		  [(_ expr0 expr ...)
-		   (syntax (begin expr0 expr ... rest))])))))])))
+            (syntax (let () body1 body ...))
+            (with-syntax ([rest (loop (cdr clauses))])
+              (syntax-case* (car clauses) (val rec vals recs _)
+                            (lambda (a b) (eq? (syntax-e b) (syntax-e a)))
+                [(val var expr)
+                 (with-syntax ([vars (normal-var (syntax var))])
+                   (syntax (let-values ([vars expr]) rest)))]
+                [(rec var expr)
+                 (with-syntax ([vars (normal-var (syntax var))])
+                   (syntax (letrec-values ([vars expr]) rest)))]
+                [(vals (var expr) ...)
+                 (with-syntax ([(vars ...) (map normal-var (syntax->list (syntax (var ...))))])
+                   (syntax (let-values ([vars expr] ...) rest)))]
+                [(recs (var expr) ...)
+                 (with-syntax ([(vars ...) (map normal-var (syntax->list (syntax (var ...))))])
+                   (syntax (letrec-values ([vars expr] ...) rest)))]
+                [(_ expr0 expr ...)
+                 (syntax (begin expr0 expr ... rest))])))))]))
 
  (define ns-undefined (gensym))
 
  (define (namespace-defined? n)
    (unless (symbol? n)
      (raise-type-error 'namespace-defined? "symbol" n))
-   (not (eq? (namespace-variable-value n #t (lambda () ns-undefined)) ns-undefined)))
+   (not (eq? (namespace-variable-value n #t (lambda () ns-undefined))
+             ns-undefined)))
 
  (define-syntax (this-expression-source-directory stx)
    (syntax-case stx ()
diff --git a/collects/mzlib/list.ss b/collects/mzlib/list.ss
index eb3ecf259a..577e6b78a6 100644
--- a/collects/mzlib/list.ss
+++ b/collects/mzlib/list.ss
@@ -1,6 +1,5 @@
 
 (module list mzscheme
-  (require "spidey.ss")
 
   (provide set-first!
            first
@@ -148,271 +147,211 @@
     (sort-internal lst less? #t 'sort))
 
   ;; deprecated!
-  (define quicksort
-    (polymorphic
-     (lambda (l less-than)
-       (unless (list? l)
-	 (raise-type-error 'quicksort "proper list" l))
-       (unless (procedure-arity-includes? less-than 2)
-	 (raise-type-error 'quicksort "procedure of arity 2" less-than))
-       (let* ([v (list->vector l)]
-              [count (vector-length v)])
-	 (let loop ([min 0][max count])
-           (if (< min (sub1 max))
-               (let ([pval (vector-ref v min)])
-                 (let pivot-loop ([pivot min]
-                                  [pos (add1 min)])
-                   (if (< pos max)
-                       (let ([cval (vector-ref v pos)])
-                         (if (less-than cval pval)
-                             (begin
-                               (vector-set! v pos (vector-ref v pivot))
-                               (vector-set! v pivot cval)
-                               (pivot-loop (add1 pivot) (add1 pos)))
-                             (pivot-loop pivot (add1 pos))))
-                       (if (= min pivot)
-                           (loop (add1 pivot) max)
-                           (begin
-                             (loop min pivot)
-                             (loop pivot max))))))))
-         (vector->list v)))))
+  (define (quicksort l less-than)
+    (unless (list? l)
+      (raise-type-error 'quicksort "proper list" l))
+    (unless (procedure-arity-includes? less-than 2)
+      (raise-type-error 'quicksort "procedure of arity 2" less-than))
+    (let* ([v (list->vector l)]
+           [count (vector-length v)])
+      (let loop ([min 0][max count])
+        (if (< min (sub1 max))
+          (let ([pval (vector-ref v min)])
+            (let pivot-loop ([pivot min] [pos (add1 min)])
+              (if (< pos max)
+                (let ([cval (vector-ref v pos)])
+                  (if (less-than cval pval)
+                    (begin (vector-set! v pos (vector-ref v pivot))
+                           (vector-set! v pivot cval)
+                           (pivot-loop (add1 pivot) (add1 pos)))
+                    (pivot-loop pivot (add1 pos))))
+                (if (= min pivot)
+                  (loop (add1 pivot) max)
+                  (begin (loop min pivot)
+                         (loop pivot max))))))))
+      (vector->list v)))
 
   ;; deprecated!
   (define mergesort sort)
 
   (define remove
-    (polymorphic
-     (letrec ([rm (case-lambda 
-                   [(item list) (rm item list equal?)]
-                   [(item list equal?)
-                    (let loop ([list list])
-                      (cond
-			[(null? list) ()]
-			[(equal? item (car list)) (cdr list)]
-			[else (cons (car list)
-				    (loop (cdr list)))]))])])
-       rm)))
+    (letrec ([rm (case-lambda 
+                  [(item list) (rm item list equal?)]
+                  [(item list equal?)
+                   (let loop ([list list])
+                     (cond [(null? list) ()]
+                           [(equal? item (car list)) (cdr list)]
+                           [else (cons (car list) (loop (cdr list)))]))])])
+      rm))
 
-  (define remq
-    (polymorphic
-     (lambda (item list)
-       (remove item list eq?))))
+  (define (remq item list)
+    (remove item list eq?))
 
-  (define remv
-    (polymorphic
-     (lambda (item list)
-       (remove item list eqv?))))
+  (define (remv item list)
+    (remove item list eqv?))
 
   (define remove*
-    (polymorphic
-     (case-lambda
+    (case-lambda
       [(l r equal?)
-       (cond 
+       (cond
 	[(null? r) null]
 	[else (let ([first-r (car r)])
 		(let loop ([l-rest l])
-		  (cond 
+		  (cond
 		   [(null? l-rest) (cons first-r (remove* l (cdr r) equal?))]
 		   [(equal? (car l-rest) first-r) (remove* l (cdr r) equal?)]
 		   [else (loop (cdr l-rest))])))])]
-      [(l r) (remove* l r equal?)])))
+      [(l r) (remove* l r equal?)]))
+
+  (define (remq* l r)
+    (remove* l r eq?))
+
+  (define (remv* l r)
+    (remove* l r eqv?))
 
-  (define remq*
-    (polymorphic
-     (lambda (l r)
-       (remove* l r eq?))))
-  
-  (define remv*
-    (polymorphic
-     (lambda (l r)
-       (remove* l r eqv?))))
-  
   ;; fold : ((A B -> B) B (listof A) -> B)
   ;; fold : ((A1 ... An B -> B) B (listof A1) ... (listof An) -> B)
-  
+
   ;; foldl builds "B" from the beginning of the list to the end of the
   ;; list and foldr builds the "B" from the end of the list to the
   ;; beginning of the list.
-  
-  (define mapadd
-    (polymorphic
-     (lambda (f l last)
-       (letrec ((helper
-                 (lambda (l)
-                   (cond
-		     [(null? l) (list last)]
-		     [else (cons (f (car l)) (helper (cdr l)))]))))
-         (helper l)))))
-  
+
+  (define (mapadd f l last)
+    (letrec ((helper
+              (lambda (l)
+                (cond [(null? l) (list last)]
+                      [else (cons (f (car l)) (helper (cdr l)))]))))
+      (helper l)))
+
   (define foldl
-    (polymorphic
-     (letrec ((fold-one
-               (lambda (f init l)
-                 (letrec ((helper
-                           (lambda (init l)
-                             (cond
-			       [(null? l) init]
-			       [else (helper (f (car l) init) (cdr l))]))))
-                   (helper init l))))
-              (fold-n
-               (lambda (f init  l)
-                 (cond
-		   [(ormap null? l)
-		    (if (andmap null? l) 
-			init
-			(error 'foldl "received non-equal length input lists"))]
-		   [else (fold-n
-			  f
-			  (apply f (mapadd car l init))
-			  (map cdr l))]))))
-       (case-lambda
-        [(f init l) (fold-one f init l)]
-        [(f init l . ls) (fold-n f init (cons l ls))]))))
-  
+    (letrec ([fold-one
+              (lambda (f init l)
+                (letrec ((helper
+                          (lambda (init l)
+                            (cond [(null? l) init]
+                                  [else (helper (f (car l) init) (cdr l))]))))
+                  (helper init l)))]
+             [fold-n
+              (lambda (f init  l)
+                (cond
+                 [(ormap null? l)
+                  (if (andmap null? l) 
+                    init
+                    (error 'foldl "received non-equal length input lists"))]
+                 [else (fold-n f (apply f (mapadd car l init)) (map cdr l))]))])
+      (case-lambda
+       [(f init l) (fold-one f init l)]
+       [(f init l . ls) (fold-n f init (cons l ls))])))
+
   (define foldr
-    (polymorphic
-     (letrec ((fold-one
-               (lambda (f init l)
-                 (letrec ((helper
-                           (lambda (init l)
-                             (cond
-			       [(null? l) init]
-			       [else (f (car l) (helper init (cdr l)))]))))
-                   (helper init l))))
-              (fold-n
-               (lambda (f init l)
-                 (cond
-		   [(ormap null? l)
-		    (if (andmap null? l)
-			init
-			(error 'foldr "received non-equal length input lists"))]
-		   [else (apply f
-				(mapadd car l
-					(fold-n f init (map cdr l))))]))))
-       (case-lambda
-        [(f init l) (fold-one f init l)]
-        [(f init l . ls) (fold-n f init (cons l ls))]))))
-  
-  (define make-find
-    (lambda (name whole-list?)
-      (polymorphic
-       (lambda (f list)
-         (unless (and (procedure? f)
-                      (procedure-arity-includes? f 1))
-           (raise-type-error name "procedure (arity 1)" f))
-         (let loop ([l list])
-           (cond
-	     [(null? l) #f]
-	     [(not (pair? l)) 
-	      (raise (make-exn:fail:contract
-		      (format "~a: second argument must be a (proper) list; given ~e" name list)
-		      (current-continuation-marks)))]
-	     [else (let ([a (car l)])
-		     (if whole-list?
-			 (if (f a)
-			     l
-			     (loop (cdr l)))
-			 (if (pair? a)
-			     (if (f (car a))
-				 a
-				 (loop (cdr l)))
-			     (raise-mismatch-error
-			      name
-			      "found a non-pair in the list: "
-			      a))))]))))))
+    (letrec ([fold-one
+              (lambda (f init l)
+                (letrec ((helper
+                          (lambda (init l)
+                            (cond [(null? l) init]
+                                  [else (f (car l) (helper init (cdr l)))]))))
+                  (helper init l)))]
+             [fold-n
+              (lambda (f init l)
+                (cond
+                 [(ormap null? l)
+                  (if (andmap null? l)
+                    init
+                    (error 'foldr "received non-equal length input lists"))]
+                 [else (apply f (mapadd car l (fold-n f init (map cdr l))))]))])
+      (case-lambda
+       [(f init l) (fold-one f init l)]
+       [(f init l . ls) (fold-n f init (cons l ls))])))
+
+  (define (make-find name whole-list?)
+    (lambda (f list)
+      (unless (and (procedure? f) (procedure-arity-includes? f 1))
+        (raise-type-error name "procedure (arity 1)" f))
+      (let loop ([l list])
+        (cond [(null? l) #f]
+              [(not (pair? l)) 
+               (raise (make-exn:fail:contract
+                       (format "~a: second argument must be a (proper) list; given ~e" name list)
+                       (current-continuation-marks)))]
+              [else (let ([a (car l)])
+                      (if whole-list?
+                        (if (f a) l (loop (cdr l)))
+                        (if (pair? a)
+                          (if (f (car a)) a (loop (cdr l)))
+                          (raise-mismatch-error
+                           name "found a non-pair in the list: " a))))]))))
 
   (define assf
     (let ([a (make-find 'assf #f)])
-      (polymorphic
-       (lambda (f l)
-	 (a f l)))))
-  
+      (lambda (f l) (a f l))))
+
   (define memf
     (let ([a (make-find 'memf #t)])
-      (polymorphic
-       (lambda (f l)
-	 (a f l)))))
-  
-  (define filter
-    (polymorphic
-     (lambda (f list)
-       (unless (and (procedure? f)
-                    (procedure-arity-includes? f 1))
-         (raise-type-error 'filter "procedure (arity 1)" f))
-       ;; We use the reverse! trick because it's too easy to
-       ;;  overflow the internal stack using natural recursion.
-       ;; It's too bad that our Scheme system is so bad, but
-       ;;  until someone fixes it...
-       (let loop ([l list][result null])
-         (cond
-	   [(null? l) (reverse! result)]
-	   [(pair? l)
-	    (loop (cdr l) (if (f (car l))
-			      (cons (car l) result)
-			      result))]
-	   [else (raise-mismatch-error
-		  'filter
-		  "expects a proper list: "
-		  list)])))))
-  
-  (define first (polymorphic (lambda (x) 
-                               (unless (pair? x)
-                                 (raise-type-error 'first "non-empty list" x))
-                               (car x))))
-  (define set-first! 
-    (polymorphic (lambda (x v)
-                   (unless (pair? x)
-                     (raise-type-error 'set-first! "non-empty list" x))
-                   (set-car! x v))))
+      (lambda (f l) (a f l))))
+
+  (define (filter f list)
+    (unless (and (procedure? f)
+                 (procedure-arity-includes? f 1))
+      (raise-type-error 'filter "procedure (arity 1)" f))
+    ;; We use the reverse! trick because it's too easy to
+    ;;  overflow the internal stack using natural recursion.
+    ;; It's too bad that our Scheme system is so bad, but
+    ;;  until someone fixes it...
+    (let loop ([l list] [result null])
+      (cond
+       [(null? l) (reverse! result)]
+       [(pair? l) (loop (cdr l) (if (f (car l)) (cons (car l) result) result))]
+       [else (raise-mismatch-error
+              'filter "expects a proper list: " list)])))
+
+  (define (first x)
+    (unless (pair? x) (raise-type-error 'first "non-empty list" x))
+    (car x))
+  (define (set-first! x v)
+    (unless (pair? x) (raise-type-error 'set-first! "non-empty list" x))
+    (set-car! x v))
   (define (lget name npos)
     (lambda (x)
       (let loop ([l x][pos npos])
 	(cond
-	 [(and (= pos 1) (pair? l))
-	  (car l)]
-	 [(pair? l)
-	  (loop (cdr l) (sub1 pos))]
-	 [else
-	  (raise-type-error name 
-			    (format "list with ~a or more items" npos) 
-			    x)]))))
+	 [(and (= pos 1) (pair? l)) (car l)]
+	 [(pair? l) (loop (cdr l) (sub1 pos))]
+	 [else (raise-type-error
+                name (format "list with ~a or more items" npos) x)]))))
 
   ;; Gives the function a name:
   (define-syntax (mk-lget stx)
     (syntax-case stx ()
       [(_ name pos)
-       (syntax (polymorphic (let ([g (lget 'name pos)])
-			      (lambda (x) (g x)))))]))
+       (syntax (let ([g (lget 'name pos)]) (lambda (x) (g x))))]))
 
-  (define second (mk-lget second 2))
-  (define third (mk-lget third 3))
-  (define fourth (mk-lget fourth 4))
-  (define fifth (mk-lget fifth 5))
-  (define sixth (mk-lget sixth 6))
+  (define second  (mk-lget second  2))
+  (define third   (mk-lget third   3))
+  (define fourth  (mk-lget fourth  4))
+  (define fifth   (mk-lget fifth   5))
+  (define sixth   (mk-lget sixth   6))
   (define seventh (mk-lget seventh 7))
-  (define eighth (mk-lget eighth 8))
-  
-  (define rest (polymorphic (lambda (x) 
-                              (unless (pair? x)
-                                (raise-type-error 'rest "non-empty list" x))
-                              (cdr x))))
-  
-  (define set-rest! (polymorphic (lambda (x v)
-                                   (unless (pair? x)
-                                     (raise-type-error 'set-rest! "non-empty list" x))
-                                   (unless (or (null? v) (pair? v))
-                                     (raise-type-error 'set-rest! "second argument must be a list" v))
-                                   (set-cdr! x v))))
-    
-  (define last-pair
-    (polymorphic
-     (lambda (l)
-       (if (pair? l)
-	   (let loop ((l l) (x (cdr l)))
-	     (if (pair? x)
-		 (loop x (cdr x))
-		 l))
-	   (raise-type-error 'last-pair "pair" l)))))
+  (define eighth  (mk-lget eighth  8))
+
+  (define (rest x)
+    (unless (pair? x)
+      (raise-type-error 'rest "non-empty list" x))
+    (cdr x))
+
+  (define (set-rest! x v)
+    (unless (pair? x)
+      (raise-type-error 'set-rest! "non-empty list" x))
+    (unless (or (null? v) (pair? v))
+      (raise-type-error 'set-rest! "second argument must be a list" v))
+    (set-cdr! x v))
+
+  (define (last-pair l)
+    (if (pair? l)
+      (let loop ([l l] [x (cdr l)])
+        (if (pair? x)
+          (loop x (cdr x))
+          l))
+      (raise-type-error 'last-pair "pair" l)))
 
   (define cons? (lambda (x) (pair? x)))
   (define empty? (lambda (x) (null? x)))
diff --git a/collects/mzlib/spidey.ss b/collects/mzlib/spidey.ss
deleted file mode 100644
index 05fc7d1199..0000000000
--- a/collects/mzlib/spidey.ss
+++ /dev/null
@@ -1,31 +0,0 @@
-
-(module spidey mzscheme
-
-  (provide define-constructor
-	  define-type
-	  :
-	  mrspidey:control
-	  polymorphic
-	  type:)
-
-  (define-syntax define-constructor
-    (lambda (stx) (syntax (void))))
-
-  (define-syntax define-type
-    (lambda (stx) (syntax (void))))
-
-  (define-syntax :
-    (lambda (stx)
-      (syntax-case stx ()
-	[(_ v t) (syntax v)])))
-
-  (define-syntax mrspidey:control
-    (lambda (stx) (syntax (void))))  
-
-  (define-syntax polymorphic
-    (lambda (stx)
-      (syntax-case stx ()
-	[(_ e) (syntax e)])))
-
-  (define-syntax type:
-    (lambda (stx) (syntax (void)))))
diff --git a/collects/mzlib/thread.ss b/collects/mzlib/thread.ss
index 0135fc64ee..d216239e50 100644
--- a/collects/mzlib/thread.ss
+++ b/collects/mzlib/thread.ss
@@ -1,12 +1,10 @@
 
 (module thread mzscheme
-  (require "spidey.ss"
-	   "etc.ss"
-	   "contract.ss")
+  (require "etc.ss" "contract.ss")
 
   (provide run-server
 	   consumer-thread)
-  
+
   #|
   t accepts a function, f, and creates a thread. It returns the thread and a
   function, g. When g is applied it passes it's argument to f, and evaluates