;;;; Displaced adjustable arrays are one of the great mysteries.
#|
I wanted to convert a multidimensional array like  #2A((1) (2))
to the same shape of list '((1) (2)) since common lisp's string
formatter works with nested lists, for the go game I am playing
with gef
7go board       /users/screwtape/cgi-bin/go     gopher.club     70
however I am not aware of a canonical way of doing this. My way
is below.
In particular I used a displaced array version of the multi-dim
array, though I could have collected in a loop using
#'ROW-MAJOR-AREF which ignores dimensions.  A displaced array's
elements are references to a different array.    Here I am just
making a flat array, but other things are possible.
|#
(setq *array* (make-array 6 :initial-element '0))
(setq *drray* (make-array 5 :adjustable t))
(adjust-array *drray* 3 :displaced-to *array*)
(setf (aref *drray* 1) '1)
(adjust-array *drray* 3 :displaced-to *array*
            :displaced-index-offset 3)
(setf (aref *drray* 1) '2)
(print *array*)
(terpri)
;; #(0 1 0 0 2 0)

(defun fold (list dims &aux (ims (cdr dims))
                          (mims (apply '* ims))) "
fold (list list) (list dims)
folds a flat list into dims. Must
(= (length list) (apply '* dims))
"
(cond (ims (loop for x
            below (truncate (length list) mims)
            collect (fold (loop for l in
                               (subseq list (* x mims)
                                      (* (1+ x) mims))
                               collect l)
                         (cdr dims))))
      ((null ims) list)))

(defun array2list (array &aux (ims (array-dimensions array))
                            (mims (apply '* ims))) "
array2list ((array array))
displaces array to flat array to list then
(fold list (array-dimensions array))
"
(let ((flat-array (make-array mims :adjustable t)))
 (adjust-array flat-array mims :displaced-to array)
 (values (fold (loop for x across flat-array collect x)
              ims))))