diff --git a/collects/math/private/array/array-special-folds.rkt b/collects/math/private/array/array-special-folds.rkt
index 215d28d850..839660cca5 100644
--- a/collects/math/private/array/array-special-folds.rkt
+++ b/collects/math/private/array/array-special-folds.rkt
@@ -13,14 +13,15 @@
 (define array-count
   (case-lambda:
     [([f : (A -> Any)] [arr0 : (Array A)])
-     (assert (array-all-sum (inline-array-map (λ: ([a : A]) (if (f a) 1 0)) arr0)) index?)]
+     (assert (array-all-sum (inline-array-map (λ: ([a : A]) (if (f a) 1 0)) arr0) 0) index?)]
     [([f : (A B -> Any)] [arr0 : (Array A)] [arr1 : (Array B)])
      (assert
-      (array-all-sum (inline-array-map (λ: ([a : A] [b : B]) (if (f a b) 1 0)) arr0 arr1))
+      (array-all-sum (inline-array-map (λ: ([a : A] [b : B]) (if (f a b) 1 0)) arr0 arr1) 0)
       index?)]
     [([f : (A B T ... T -> Any)] [arr0 : (Array A)] [arr1 : (Array B)] . [arrs : (Array T) ... T])
      (assert
       (array-all-sum (apply array-map
                             (λ: ([a : A] [b : B] . [ts : T ... T]) (if (apply f a b ts) 1 0))
-                            arr0 arr1 arrs))
+                            arr0 arr1 arrs)
+                     0)
       index?)]))
diff --git a/collects/math/scribblings/math.scrbl b/collects/math/scribblings/math.scrbl
index 4969547574..9f97fc4f8c 100644
--- a/collects/math/scribblings/math.scrbl
+++ b/collects/math/scribblings/math.scrbl
@@ -14,10 +14,10 @@ for working with numbers and collections of numbers. These include
   @item{Additional constants and elementary functions}
   @item{Special functions}
   @item{@racket[Bigfloat]s, or arbitrary-precision floating-point numbers}
-  @item{Probability distributions}
-  @item{Statistical functions (currently undergoing refactoring)}
   @item{Number-theoretic functions}
   @item{@racket[Array]s for storing and transforming large rectangular data sets}
+  @item{Probability distributions}
+  @item{Statistical functions (currently undergoing refactoring)}
   @item{Linear algebra functions (currently under review)}
 ]
 
diff --git a/collects/math/tests/array-tests.rkt b/collects/math/tests/array-tests.rkt
index c4a80a29c4..0cda5804f9 100644
--- a/collects/math/tests/array-tests.rkt
+++ b/collects/math/tests/array-tests.rkt
@@ -2,13 +2,35 @@
 
 (require racket/flonum
          math/array
-         typed/rackunit
+         (rename-in
+          (except-in typed/rackunit check-eq?)
+          [check-equal?  old:check-equal?])
          math/private/array/utils)
 
 (define-predicate listof-index? (Listof Index))
 (define-predicate listof-flonum? (Listof Float))
 (define-predicate undefined? Undefined)
 
+;; This gets around the fact that typed/rackunit can no longer test higher-order values for equality,
+;; since TR has firmed up its rules on passing `Any' types in and out of untyped code
+(define-syntax-rule (check-equal? a b . message)
+  (check-true (equal? a b) . message))
+
+(define-syntax-rule (check-eq? a b . message)
+  (check-equal? (eq-hash-code a) (eq-hash-code b) . message))
+
+(define-syntax-rule (array-axis-andmap arr k pred?)
+  (array-axis-and (array-map pred? arr) k))
+
+(define-syntax-rule (array-axis-ormap arr k pred?)
+  (array-axis-or (array-map pred? arr) k))
+
+(define-syntax-rule (array-all-andmap arr pred?)
+  (array-all-and (array-map pred? arr)))
+
+(define-syntax-rule (array-all-ormap arr pred?)
+  (array-all-or (array-map pred? arr)))
+
 ;; ---------------------------------------------------------------------------------------------------
 ;; array-mutable
 
@@ -343,7 +365,7 @@
 (let ([arr  (array #[#[1.0 1.0 2.0 3.0] #[0.0 -1.0 2.0 3.0]])])
   (check-equal? (array-axis-count arr 0 positive?) (array #[1 1 2 2]))
   (check-equal? (array-axis-count arr 1 positive?) (array #[4 2]))
-  (check-equal? (array-all-count arr positive?) 6))
+  (check-equal? (array-count positive? arr) 6))
 
 (let ([arr  (array #[#[1.0 1.0 2.0 3.0] #[0.0 -1.0 2.0 3.0]])])
   (check-equal? (array-axis-andmap arr 0 positive?) (array #[#f #f #t #t]))
@@ -366,12 +388,12 @@
   (check-equal? (array-all-ormap arr positive?) #f))
 
 (let ([arr  (make-array #() 0.0)])
-  (check-equal? (array-all-count arr positive?) 0)
+  (check-equal? (array-count positive? arr) 0)
   (check-equal? (array-all-andmap arr positive?) #f)
   (check-equal? (array-all-ormap arr positive?) #f))
 
 (let ([arr  (make-array #() 1.0)])
-  (check-equal? (array-all-count arr positive?) 1)
+  (check-equal? (array-count positive? arr) 1)
   (check-equal? (array-all-andmap arr positive?) #t)
   (check-equal? (array-all-ormap arr positive?) #t))
 
@@ -382,7 +404,7 @@
   (check-equal? (array-axis-count arr 1 positive?)  (array #[0 0 0 0]))
   (check-equal? (array-axis-andmap arr 1 positive?) (array #[#t #t #t #t]))
   (check-equal? (array-axis-ormap arr 1 positive?)  (array #[#f #f #f #f]))
-  (check-equal? (array-all-count arr positive?) 0)
+  (check-equal? (array-count positive? arr) 0)
   (check-equal? (array-all-andmap arr positive?) #t)
   (check-equal? (array-all-ormap arr positive?) #f))
 
@@ -394,12 +416,12 @@
 (check-exn exn? (λ () (array-fft (make-array #(3) 1))))
 
 (let ([arr  (make-array #(4) 1)])
-  (check array-all= (array-fft arr) (array #[4 0 0 0]))
-  (check array-all= (array-inverse-fft (array-fft arr)) arr))
+  (check-true (array-all-and (array= (array-fft arr) (array #[4 0 0 0]))))
+  (check-true (array-all-and (array= (array-inverse-fft (array-fft arr)) arr))))
 
 (let ([arr  (make-array #(2 2) 1)])
-  (check array-all= (array-fft arr) (array #[#[4 0] #[0 0]]))
-  (check array-all= (array-inverse-fft (array-fft arr)) arr))
+  (check-true (array-all-and (array= (array-fft arr) (array #[#[4 0] #[0 0]]))))
+  (check-true (array-all-and (array= (array-inverse-fft (array-fft arr)) arr))))
 
 ;; ---------------------------------------------------------------------------------------------------
 ;; Unsafe ref
@@ -744,7 +766,7 @@
 (let ([arr  (indexes-array #(4))])
   (check-exn exn? (λ () (array-axis-ref arr 1 0)))
   (check-equal? (array-axis-ref arr 0 2)
-                (array #(2))))
+                (array '#(2))))
 
 (let ([arr  (indexes-array #(2 2))])
   (check-equal? (array-axis-ref arr 0 0)
diff --git a/collects/math/tests/mandelbrot-test.rkt b/collects/math/tests/mandelbrot-test.rkt
index 4092ddd1e6..6bbc4da811 100644
--- a/collects/math/tests/mandelbrot-test.rkt
+++ b/collects/math/tests/mandelbrot-test.rkt
@@ -6,39 +6,39 @@
 
 (: mandelbrot (Float Integer -> (Array Integer)))
 (define (mandelbrot step max-iters)
-  (define xs (sequence->list (in-range -2.0 0.800001 step)))
-  (define ys (sequence->list (in-range -1.4 1.400001 step)))
-  (define x ((inst list*->array Float) xs flonum?))
-  (define y (array-slice-ref ((inst list*->array Float) ys flonum?) (list ::... (::new 1))))
+  (define x (list->array (sequence->list (in-range -2.0 0.800001 step))))
+  (define y (array-slice-ref (list->array (sequence->list (in-range -1.4 1.400001 step)))
+                             (list ::... (::new 1))))
   (define c (array->fcarray (array+ x (array-scale y +1.0i))))
   (define-values (z divtime)
     (for/fold: ([z : FCArray c]
                 [divtime : (Array Integer)  (make-array (array-shape c) max-iters)]
                 ) ([i  (in-range max-iters)])
       (let ([z  (fcarray+ (fcarray-sqr z) c)])
-        (values z (array-strict (array-if (array-and (flarray> (fcarray-magnitude z) (flarray 4.0))
+        (values z (array-strict (array-if (array-and (array> (fcarray-magnitude z) (flarray 4.0))
                                                      (array= divtime (array max-iters)))
                                           (array i)
                                           divtime))))))
   divtime)
 
-(check-equal? (mandelbrot 0.2 20)
-              (array #[#[0 1 1 1 1 1 1 1 1 1 1 1 1 1 1]
-                       #[1 1 1 1 1 1 2 2 2 3 2 2 1 1 1]
-                       #[1 1 1 1 1 2 2 2 3 6 20 3 2 1 1]
-                       #[1 1 1 2 2 2 3 4 5 20 17 4 3 2 1]
-                       #[1 1 2 2 3 3 4 11 20 20 20 10 14 2 2]
-                       #[1 2 3 4 6 6 6 20 20 20 20 20 9 3 2]
-                       #[2 3 4 6 18 20 14 20 20 20 20 20 20 3 2]
-                       #[20 20 20 20 20 20 20 20 20 20 20 20 5 3 2]
-                       #[2 3 4 6 18 20 14 20 20 20 20 20 20 3 2]
-                       #[1 2 3 4 6 6 6 20 20 20 20 20 9 3 2]
-                       #[1 1 2 2 3 3 4 11 20 20 20 10 14 2 2]
-                       #[1 1 1 2 2 2 3 4 5 20 17 4 3 2 1]
-                       #[1 1 1 1 1 2 2 2 3 6 20 3 2 1 1]
-                       #[1 1 1 1 1 1 2 2 2 3 2 2 1 1 1]
-                       #[0 1 1 1 1 1 1 1 1 1 1 1 1 1 1]]))
-
+(check-true
+ (equal? (mandelbrot 0.2 20)
+         (array #[#[0 1 1 1 1 1 1 1 1 1 1 1 1 1 1]
+                  #[1 1 1 1 1 1 2 2 2 3 2 2 1 1 1]
+                  #[1 1 1 1 1 2 2 2 3 6 20 3 2 1 1]
+                  #[1 1 1 2 2 2 3 4 5 20 17 4 3 2 1]
+                  #[1 1 2 2 3 3 4 11 20 20 20 10 14 2 2]
+                  #[1 2 3 4 6 6 6 20 20 20 20 20 9 3 2]
+                  #[2 3 4 6 18 20 14 20 20 20 20 20 20 3 2]
+                  #[20 20 20 20 20 20 20 20 20 20 20 20 5 3 2]
+                  #[2 3 4 6 18 20 14 20 20 20 20 20 20 3 2]
+                  #[1 2 3 4 6 6 6 20 20 20 20 20 9 3 2]
+                  #[1 1 2 2 3 3 4 11 20 20 20 10 14 2 2]
+                  #[1 1 1 2 2 2 3 4 5 20 17 4 3 2 1]
+                  #[1 1 1 1 1 2 2 2 3 6 20 3 2 1 1]
+                  #[1 1 1 1 1 1 2 2 2 3 2 2 1 1 1]
+                  #[0 1 1 1 1 1 1 1 1 1 1 1 1 1 1]])))
+#;
 (begin
   (require images/flomap)