anchor.diff:  (present (matmul MA MA))
   
   (present
  - (matmul (reshape 3.0 (~ 4 ~ 8))
  -         (reshape 2.0 (~ 8 ~ 4))))
  + (matmul (lazy-reshape 3.0 (~ 4 ~ 8))
  +         (lazy-reshape 2.0 (~ 8 ~ 4))))
   
  -(defparameter M (reshape #(1 2 3 4 5 6) (~ 6 ~ 6)))
  +(defparameter M (lazy-reshape #(1 2 3 4 5 6) (~ 6 ~ 6)))
   
   (present M)
   
   (present
  - (matmul M (reshape M (transform m n to n m))))
  + (matmul M (lazy-reshape M (transform m n to n m))))
   
   ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   ;;;
   ;;;  Jacobi's Method
   
   (defun jacobi-2d (grid)
  -  (let ((interior (array-interior grid)))
  -    (fuse*
  +  (let ((interior (lazy-array-interior grid)))
  +    (lazy-overwrite
        grid
        (lazy #'* 1/4
  -        (lazy #'+
  -           (reshape grid (transform i j to (1+ i) j) interior)
  -           (reshape grid (transform i j to (1- i) j) interior)
  -           (reshape grid (transform i j to i (1+ j)) interior)
  -           (reshape grid (transform i j to i (1- j)) interior))))))
  +           (lazy #'+
  +                 (lazy-reshape grid (transform i j to (1+ i) j) interior)
  +                 (lazy-reshape grid (transform i j to (1- i) j) interior)
  +                 (lazy-reshape grid (transform i j to i (1+ j)) interior)
  +                 (lazy-reshape grid (transform i j to i (1- j)) interior))))))
   
   (defparameter domain
  -  (fuse* (reshape 1.0 (~ 10 ~ 10))
  -         (reshape 0.0 (~ 1 9 ~ 1 9))))
  +  (lazy-overwrite
  +   (lazy-reshape 1.0 (~ 10 ~ 10))
  +   (lazy-reshape 0.0 (~ 1 9 ~ 1 9))))
   
   (present domain)
   
  
positive.code: ;;; Petalisp Basics
  
  (present
   (reshape 0 (~))) ; the empty space
  
  (defun zeros (shape)
    (reshape 0 shape))
  
  (present
   (zeros (~ 10))) ; ten zeros
  
  (present
   (array-indices (zeros (~ 10)))) ; the numbers from 0 to 9 (inclusive)
  
  (present
   (reshape #2a((1 2 3 4) (5 6 7 8)) (~ 0 2 ~ 1 3))) ; selecting values
  
  (present
   (reshape #2a((1 2 3 4) (5 6 7 8))
            (transform i j to j i))) ; transforming
  
  ;; arrays can be merged with fuse
  
  (present (fuse (reshape 5 (~ 0 3))
                 (reshape 1 (~ 3 6))))
  
  ;; arrays can be overwritten with fuse*
  
  (present
   (fuse* (zeros (~ 10 ~ 10))
          (reshape 1 (~ 2 8 ~ 2 8))))
  
  ;; lazy arrays permit beautiful functional abstractions
  
  (defun chessboard (h w)
    (fuse (reshape 0 (~ 0 h 2 ~ 0 w 2))
          (reshape 0 (~ 1 h 2 ~ 1 w 2))
          (reshape 1 (~ 0 h 2 ~ 1 w 2))
          (reshape 1 (~ 1 h 2 ~ 0 w 2))))
  
  (present
   (chessboard 8 8))
  
negative.code: (defun matmul (A B)
    (lazy-reduce #'+
       (lazy #'*
          (lazy-reshape A (transform m n to n m 0))
          (lazy-reshape B (transform n k to n 0 k)))))
  
  (defparameter MI #2a((1.0 0.0)
                       (0.0 1.0)))
  