anchor.diff:                  (array-immediate storage
                    &aux
                      (lazy-array array-immediate)
  +                   (ntype
  +                    (petalisp.type-inference:generalize-ntype
  +                     (element-ntype array-immediate)))
                      (buffer
                       (make-buffer
                        :shape (shape array-immediate)
  -                     :ntype (element-ntype array-immediate)
  +                     :ntype ntype
                        :storage storage)))))
     (buffer nil :type buffer))
   
  
positive.code:      (value t)
       (shape shape)
       (transformation transformation))
    (let* ((lazy-array (layout-lazy-array layout))
           (buffer (make-buffer
                    :shape shape
                    :reusablep t
                    :ntype (petalisp.type-inference:generalize-ntype
                            (element-ntype lazy-array))))
           (store (make-store-instruction value buffer transformation)))
      (push `(,buffer ,store) (layout-buffer-stores layout))
      store))
  
negative.code:         (kernel-targets kernel)
        (trivia:when-match (list (cons _ input))
            (instruction-inputs store-instruction)
          (when (eq input load-instruction)
            (return-from copy-kernel-p t))))))
  
  (defun copy-kernel-transformation (kernel)
  