diff git a/scrutinizer.scm b/scrutinizer.scm
index 6ecf7ba..27093f5 100644
a

b


913  913  ;; (vector x y z) => (vector * * *) 
914  914  (change! (cons 'vector (map (constantly '*) (cdr t)))) 
915  915  (car t)) 
 916  ((struct) 
 917  (dd " smashing `~s' in ~a" (caar lst) where) 
 918  ;; (vector x y z) => (vector * * *) 
 919  (when (and (= 3 (length t)) 
 920  (caddr t)) 
 921  (change! `(struct ,(cadr t) ,(map (constantly '*) (caddr t))))) 
 922  (car t)) 
916  923  ((listof list) 
917  924  (dd " smashing `~s' in ~a" (caar lst) where) 
918  925  (change! '(or pair null)) 
… 
… 

1087  1094  (results2 (procedureresults t2))) 
1088  1095  (and (matchargs args1 args2) 
1089  1096  (matchresults results1 results2)))) 
1090   ((struct) (equal? t1 t2)) 
 1097  ((struct) 
 1098  (and (equal? (cadr t1) (cadr t2)) 
 1099  (or (null? (cddr t1)) 
 1100  (null? (cddr t2)) 
 1101  (not (caddr t1)) 
 1102  (not (caddr t2)) 
 1103  (and (pair? (caddr t1)) 
 1104  (pair? (caddr t2)) 
 1105  (= (length (caddr t1)) (length (caddr t2))) 
 1106  (every match1 (caddr t1) (caddr t2)))))) 
1091  1107  ((pair) (every match1 (cdr t1) (cdr t2))) 
1092  1108  ((listof vectorof) (match1 (second t1) (second t2))) 
1093  1109  ((list vector) 
… 
… 

1292  1308  `(list ,@(map simplify (cdr t))))) 
1293  1309  ((vector) 
1294  1310  `(vector ,@(map simplify (cdr t)))) 
 1311  ((struct) 
 1312  (cond 
 1313  ((= 2 (length t)) t) 
 1314  ((not (caddr t)) `(struct ,(cadr t))) 
 1315  (else 
 1316  `(struct ,(cadr t) ,(map simplify (caddr t)))))) 
1295  1317  ((procedure) 
1296  1318  (let* ((name (and (named? t) (cadr t))) 
1297  1319  (rtypes (if name (cdddr t) (cddr t)))) 
… 
… 

1715  1737  ((forall) `(forall ,(second t) ,(resolve (third t) done))) 
1716  1738  ((pair list vector vectorof listof) 
1717  1739  (cons (car t) (map (cut resolve <> done) (cdr t)))) 
 1740  ((struct) 
 1741  (if (and (= 3 (length t)) 
 1742  (list? (caddr t))) 
 1743  `(struct ,(cadr t) ,(map (cut resolve <> done) (caddr t))) 
 1744  t)) 
1718  1745  ((procedure) 
1719  1746  (let* ((name (procedurename t)) 
1720  1747  (argtypes (procedurearguments t)) 
… 
… 

2014  2041  (second t)) 
2015  2042  constraints)) 
2016  2043  (validate (third t) rec))))) 
2017   ((eq? 'or (car t)) 
 2044  ((eq? 'or (car t)) 
2018  2045  (and (list? t) 
2019  2046  (let ((ts (map validate (cdr t)))) 
2020  2047  (and (every identity ts) 
2021  2048  `(or ,@ts))))) 
2022  2049  ((eq? 'struct (car t)) 
2023   (and (= 2 (length t)) 
 2050  (and (<= 2 (length t) 3) 
2024  2051  (symbol? (cadr t)) 
2025   t)) 
 2052  (if (not (null? (cddr t))) 
 2053  ;; copy of vector/list case 
 2054  (or (and (not (caddr t)) `(struct ,(cadr t))) 
 2055  (and (pair? (caddr t)) 
 2056  (let loop ((ts (caddr t)) (ts2 '())) 
 2057  (cond ((null? ts) `(struct ,(cadr t) ,(reverse ts2))) 
 2058  ((validate (car ts)) => 
 2059  (lambda (t2) (loop (cdr ts) (cons t2 ts2)))) 
 2060  (else #f))))) 
 2061  t))) 
2026  2062  ((eq? 'deprecated (car t)) 
2027  2063  (and (= 2 (length t)) (symbol? (second t)) t)) 
2028  2064  ((or (memq* '> t) (memq* '> t)) => 
diff git a/types.db b/types.db
index d142e64..53a3429 100644
a

b


2597  2597  (hashbyidentity (#(procedure #:pure #:enforce) hashbyidentity (* #!optional fixnum fixnum) fixnum)) 
2598  2598  (hashtable>alist (#(procedure #:clean #:enforce) hashtable>alist ((struct hashtable)) (listof pair))) 
2599  2599  (hashtableclear! (#(procedure #:clean #:enforce) hashtableclear! ((struct hashtable)) undefined)) 
2600   (hashtablecopy (#(procedure #:clean #:enforce) hashtablecopy ((struct hashtable)) (struct hashtable))) 
2601   (hashtabledelete! (#(procedure #:clean #:enforce) hashtabledelete! ((struct hashtable) *) boolean)) 
2602  2600  (hashtableequivalencefunction (#(procedure #:clean #:enforce) hashtableequivalencefunction ((struct hashtable)) (procedure (* *) *))) 
2603   (hashtableexists? (#(procedure #:clean #:enforce) hashtableexists? ((struct hashtable) *) boolean)) 
2604  2601  (hashtablefold (#(procedure #:enforce) hashtablefold ((struct hashtable) (procedure (* * *) *) *) *)) 
2605  2602  (hashtableforeach (#(procedure #:enforce) hashtableforeach ((struct hashtable) (procedure (* *) . *)) undefined)) 
2606  2603  
… 
… 

2611  2608  (((struct hashtable)) (##sys#slot #(1) '4))) 
2612  2609  
2613  2610  (hashtableinitial (#(procedure #:clean #:enforce) hashtableinitial ((struct hashtable)) *)) 
2614   (hashtablekeys (#(procedure #:clean #:enforce) hashtablekeys ((struct hashtable)) list)) 
2615  2611  (hashtablemap (#(procedure #:clean #:enforce) hashtablemap ((struct hashtable) (procedure (* *) *)) list)) 
2616  2612  
2617  2613  (hashtablemaxload (#(procedure #:clean #:enforce) hashtablemaxload ((struct hashtable)) fixnum) 
… 
… 

2622  2618  
2623  2619  (hashtableminload (#(procedure #:clean #:enforce) hashtableminload ((struct hashtable)) fixnum) 
2624  2620  (((struct hashtable)) (##sys#slot #(1) '5))) 
2625   
2626   (hashtableref (#(procedure #:clean #:enforce) hashtableref ((struct hashtable) * #!optional (procedure () *)) *)) 
2627   (hashtableref/default (#(procedure #:clean #:enforce) hashtableref/default ((struct hashtable) * *) *)) 
2628  2621  (hashtableremove! (#(procedure #:clean #:enforce) hashtableremove! ((struct hashtable) (procedure (* *) *)) undefined)) 
2629   (hashtableset! (#(procedure #:clean #:enforce) hashtableset! ((struct hashtable) * *) undefined)) 
2630   
2631  2622  (hashtablesize (#(procedure #:clean #:enforce) hashtablesize ((struct hashtable)) fixnum) 
2632  2623  (((struct hashtable)) (##sys#slot #(1) '2))) 
2633  2624  
2634  2625  (hashtableupdate! (#(procedure #:enforce) hashtableupdate! ((struct hashtable) * (procedure (*) *) #!optional (procedure () *)) *)) 
2635  2626  (hashtableupdate!/default (#(procedure #:clean #:enforce) hashtableupdate!/default ((struct hashtable) * (procedure (*) *) *) *)) 
2636   (hashtablevalues (#(procedure #:clean #:enforce) hashtablevalues ((struct hashtable)) list)) 
2637   (hashtablewalk (#(procedure #:enforce) hashtablewalk ((struct hashtable) (procedure (* *) . *)) undefined)) 
 2627  
 2628  (hashtablevalues (forall (v) (#(procedure #:clean #:enforce) hashtablevalues ((struct hashtable (* v))) (listof v)))) 
 2629  (hashtablewalk (forall (k v) (#(procedure #:enforce) hashtablewalk ((struct hashtable (k v)) (procedure (k v) . *)) undefined))) 
 2630  (hashtableset! (#(procedure #:enforce) hashtableset! ((struct hashtable) * *) undefined)) 
 2631  (hashtableref (forall (k v) (#(procedure #:clean #:enforce) hashtableref ((struct hashtable (k v)) k #!optional (procedure () *)) v))) 
 2632  (hashtableref/default (forall (k v d) (#(procedure #:clean #:enforce) hashtableref/default ((struct hashtable (k v)) k d) (or v d)))) 
 2633  (hashtablekeys (forall (k) (#(procedure #:clean #:enforce) hashtablekeys ((struct hashtable (k *))) (listof k)))) 
 2634  (hashtabledelete! (forall (k) (#(procedure #:clean #:enforce) hashtabledelete! ((struct hashtable (k *)) k) boolean))) 
 2635  (hashtablecopy (forall (k v) (#(procedure #:clean #:enforce) hashtablecopy ((struct hashtable (k v))) (struct hashtable (k v))))) 
 2636  (hashtableexists? (forall (k) (#(procedure #:clean #:enforce) hashtableexists? ((struct hashtable (k *)) k) boolean))) 
2638  2637  
2639  2638  (hashtableweakkeys (#(procedure #:clean #:enforce) hashtableweakkeys ((struct hashtable)) boolean) 
2640  2639  (((struct hashtable)) (##sys#slot #(1) '7))) 