anchor.diff:                (return-from layout-load load))))))
       ;; If no buffer can be reused, create a now one, load from it, and
       ;; register both entities.
  -    (let* ((lazy-array (layout-lazy-array layout))
  -           (buffer (make-buffer
  +    (let* ((buffer (make-buffer
                       :shape shape
                       :reusablep t
  -                    :ntype (petalisp.type-inference:generalize-ntype
  -                            (element-ntype lazy-array))))
  +                    :ntype (layout-ntype layout)))
              (load (make-load-instruction buffer transformation))
              (new-entry `(,buffer ,load)))
         (push new-entry (cdr layout-entry))
  
positive.code:         (kernel-targets kernel)
        (trivia:when-match (list (cons _ input))
            (instruction-inputs store-instruction)
          (when (and (eq input load-instruction))
            (return-from copy-kernel-p t))))))
  
  (defun copy-kernel-transformation (kernel)
  
negative.code:      (value t)
       (shape shape)
       (transformation transformation))
    (let* ((buffer (make-buffer
                    :shape shape
                    :reusablep t
                    :ntype (layout-ntype layout)))
           (store (make-store-instruction value buffer transformation)))
      (push `(,buffer ,store) (layout-buffer-stores layout))
      store))
  