From 2e4d817391e5fa75a69180a3ca3dc460246ebf21 Mon Sep 17 00:00:00 2001
From: Sam Tobin-Hochstadt <samth@racket-lang.org>
Date: Thu, 19 Jun 2008 16:55:26 -0400
Subject: [PATCH] More tests!

original commit: e62598ef08326c3a0f20a57c5b8370d0319473a5
---
 .../tests/typed-scheme/succeed/fold-left.ss   | 26 ++++++++++++-
 .../unit-tests/typecheck-tests.ss             | 39 +++++++++++++++++--
 2 files changed, 59 insertions(+), 6 deletions(-)

diff --git a/collects/tests/typed-scheme/succeed/fold-left.ss b/collects/tests/typed-scheme/succeed/fold-left.ss
index 8b035175..ca1364da 100644
--- a/collects/tests/typed-scheme/succeed/fold-left.ss
+++ b/collects/tests/typed-scheme/succeed/fold-left.ss
@@ -15,5 +15,27 @@
           (ormap null? bss))
       c
       (apply f
-             (apply fold-left f c (cdr as) (map cdr bss))
-             (car as) (map car bss))))
\ No newline at end of file
+             (apply fold-right f c (cdr as) (map cdr bss))
+             (car as) (map car bss))))
+
+;; Matthias -- tell me why this returns 4.
+((plambda: (x ...) [xs : x ... x] 
+    (apply fold-left 
+           (lambda: ([a : Integer] [b : Integer] . [xs : x ... x])
+             (+ a b))
+           3 
+           (list 1 2 3) 
+           (map list xs)))
+ 3 4 5)
+
+((plambda: (x ...) [xs : x ... x] 
+    (apply fold-right
+           (lambda: ([a : Integer] [b : Integer] . [xs : x ... x])
+             (+ a b))
+           3 
+           (list 1 2 3) 
+           (map list xs)))
+ 3 4 5)
+
+(fold-left  (lambda: ([a : (Listof Integer)] [c : Integer]) (cons c a)) null (list 3 4 5 6))
+(fold-right (lambda: ([a : (Listof Integer)] [c : Integer]) (cons c a)) null (list 3 4 5 6))
\ No newline at end of file
diff --git a/collects/tests/typed-scheme/unit-tests/typecheck-tests.ss b/collects/tests/typed-scheme/unit-tests/typecheck-tests.ss
index 1f5b1d1f..bb0c8dcb 100644
--- a/collects/tests/typed-scheme/unit-tests/typecheck-tests.ss
+++ b/collects/tests/typed-scheme/unit-tests/typecheck-tests.ss
@@ -559,9 +559,10 @@
                           (apply (plambda: (b) ([x : Number] . [y : Number ... a]) x)
                                  1 w))]
         
-        [tc-err (plambda: (a ...) ([z : String] . [w : Number ... a])
-                          (apply (plambda: (b ...) ([x : Number] . [y : Number ... b]) x)
-                                 1 w))]
+        [tc-e (plambda: (a ...) ([z : String] . [w : Number ... a])
+                        (apply (plambda: (b ...) ([x : Number] . [y : Number ... b]) x)
+                               1 w))
+              (-polydots (a) ((list -String) (N a) . ->... . N))]
         ;; instantiating non-dotted terms
         [tc-e (inst (plambda: (a) ([x : a]) x) Integer)
               (-Integer . -> . -Integer : (list (make-Latent-Var-True-Effect)) (list (make-Latent-Var-False-Effect)))]
@@ -578,7 +579,7 @@
                . -> . -Integer)]
         
         [tc-e (plambda: (z x y ...) () (inst map z x y ... y))
-              (-polydots (z x y) ((list ((list z x) (y y) . ->... . z) z (-lst x)) ((-lst y) y) . ->... . (-lst z)))]
+              (-polydots (z x y) (-> ((list ((list x) (y y) . ->... . z) (-lst x)) ((-lst y) y) . ->... . (-lst z))))]
         
         ;; error tests
         [tc-err (#%variable-reference number?)]
@@ -610,6 +611,36 @@
         [tc-e (filter even? (filter integer? (list 1 2 3 'foo)))
               (-lst -Integer)]
         
+        [tc-err (plambda: (a ...) [as : a ... a]
+                          (apply fold-left (lambda: ([c : Integer] [a : Char] . [xs : a ... a]) c)
+                                 3 (list #\c) as))]
+        [tc-err (plambda: (a ...) [as : a ... a]
+                          (apply fold-left (lambda: ([c : Integer] [a : String] . [xs : a ... a]) c)
+                                 3 (list #\c) (map list as)))]
+        [tc-err (plambda: (a ...) [as : a ... a]
+                          (apply fold-left (lambda: ([c : Integer] [a : Char] . [xs : a ... a]) c)
+                                 3 (list #\c) (map list (map list as))))]
+        
+        [tc-e (plambda: (a ...) [as : a ... a]
+                        (apply fold-left (lambda: ([c : Integer] [a : Char] . [xs : a ... a]) c)
+                               3 (list #\c) (map list as)))
+              (-polydots (a) ((list) (a a) . ->... . -Integer))]
+        
+        ;; First is same as second, but with map explicitly instantiated.
+        [tc-e (plambda: (a ...) [ys : (a ... a -> Number) *]
+                (lambda: [zs : a ... a]
+                  ((inst map Number (a ... a -> Number))
+                   (lambda: ([y : (a ... a -> Number)])
+                     (apply y zs))
+                   ys)))
+              (-polydots (a) ((list) ((list) (a a) . ->... . N) . ->* . ((list) (a a) . ->... . (-lst N))))]
+        [tc-e (plambda: (a ...) [ys : (a ... a -> Number) *]
+                (lambda: [zs : a ... a]
+                  (map (lambda: ([y : (a ... a -> Number)])
+                         (apply y zs))
+                       ys)))
+              (-polydots (a) ((list) ((list) (a a) . ->... . N) . ->* . ((list) (a a) . ->... . (-lst N))))]
+        
         #;[tc-err (let: ([fact : (Number -> Number) (lambda: ([n : Number]) (if (zero? n) 1 (* n (fact (- n 1)))))])
                         (fact 20))]