diff --git a/lib/srfi/231/base.scm b/lib/srfi/231/base.scm
index d306f674..f52c4bae 100644
--- a/lib/srfi/231/base.scm
+++ b/lib/srfi/231/base.scm
@@ -61,7 +61,7 @@
 (define (interval-width iv i)
   (- (interval-upper-bound iv i) (interval-lower-bound iv i)))
 (define (interval-widths iv)
-  (vector-map - (interval-lb iv) (interval-ub iv)))
+  (vector-map - (interval-ub iv) (interval-lb iv)))
 
 (define (interval= iv1 iv2)
   (assert (and (interval? iv1) (interval? iv2)))
diff --git a/lib/srfi/231/transforms.scm b/lib/srfi/231/transforms.scm
index 09499553..0426b180 100644
--- a/lib/srfi/231/transforms.scm
+++ b/lib/srfi/231/transforms.scm
@@ -568,15 +568,23 @@
                             (interval-lower-bound b-domain d))))
                   (lp (- d 1)))))))
 
-(define (array-append axis a . o)
+(define (array-append axis arrays . o)
   (assert (and (exact-integer? axis)
-               (array? a)
-               (< -1 axis (array-dimension a))
-               (every array? o)))
-  (let ((a-domain (array-domain a)))
+               (pair? arrays)
+               (< -1 axis (array-dimension (car arrays)))
+               (every array? arrays)))
+  (let* ((a (car arrays))
+         (a-domain (array-domain a))
+         (storage (if (pair? o) (car o) generic-storage-class))
+         (mutable? (if (and (pair? o) (pair? (cdr o)))
+                       (cadr o)
+                       (specialized-array-default-mutable?)))
+         (safe? (if (and (pair? o) (pair? (cdr o)) (pair? (cddr o)))
+                    (car (cddr o))
+                    (specialized-array-default-safe?))))
     (assert (every (lambda (b)
                      (dimensions-compatible? a-domain (array-domain b) axis))
-                   o))
+                   (cdr arrays)))
     (let* ((a-lo (interval-lower-bounds->vector a-domain))
            (c-lo (make-vector (interval-dimension a-domain) 0))
            (c-hi (interval-widths a-domain)))
@@ -585,16 +593,14 @@
                    (fold (lambda (b sum)
                            (+ sum (interval-width (array-domain b) axis)))
                          (vector-ref c-hi axis)
-                         o))
+                         (cdr arrays)))
       (let* ((c-domain (make-interval c-lo c-hi))
-             (c (make-specialized-array c-domain
-                                        (or (array-storage-class a)
-                                            generic-storage-class)))
+             (c (make-specialized-array c-domain storage mutable? safe?))
              (b-trans (make-vector (array-dimension a) 0)))
         (array-assign!
          (array-extract c (make-interval c-lo (interval-widths a-domain)))
          (array-translate a (vector-map - a-lo)))
-        (let lp ((arrays o)
+        (let lp ((arrays (cdr arrays))
                  (b-offset (- (interval-upper-bound a-domain axis)
                               (interval-lower-bound a-domain axis))))
           (if (null? arrays)