Interested by those map-array macros?

[q3cpma]

Made these "proper" macros that mimic the sequence map because I didn't like vectorize's need for symbols.

(defmacro map-array-into (dest fun &rest arrays)
  "map for arrays. Only the arrays' total-size must be equal."
  (assert arrays () "map-array-into needs at least one array argument")
  (let ((array-num (length arrays)))
    (once-only (dest (arrays ``(,,@arrays)))
      `(iter
         (initially (assert (apply #'= (array-total-size ,dest) (mapcar #'array-total-size ,arrays))
                            () "map-array-into array arguments must have the same total size"))
         (for i below (array-total-size (car ,arrays)))
         (with arrays-vec = (coerce ,arrays 'vector))
         (setf (row-major-aref ,dest i)
               (funcall ,fun
                        ,@(iter (for i below array-num)
                            (collect `(row-major-aref (aref arrays-vec ,i) i)))))
         (finally (return ,dest))))))

(defmacro map-array (fun &rest arrays)
  "map for arrays. Only the arrays' total-size must be equal.
The resulting array uses the dimensions of the first array parameter."
  (assert arrays () "map-array needs at least one array argument")
  (let ((array-num (length arrays)))
    (once-only ((arrays ``(,,@arrays)))
      `(iter
         (initially (assert (apply #'= (mapcar #'array-total-size ,arrays))
                            () "map-array array arguments must have the same total size"))
         (with ret = (make-array (array-dimensions (car ,arrays))))
         (for i below (array-total-size (car ,arrays)))
         (with arrays-vec = (coerce ,arrays 'vector))
         (setf (row-major-aref ret i)
               (funcall ,fun
                        ,@(iter (for i below array-num)
                            (collect `(row-major-aref (aref arrays-vec ,i) i)))))
         (finally (return ret))))))

would you be interested? If so, I'd convert iter to loop and make a PR. I also plan on making an array version for all the relevant sequence functions (substitute, count, find, position, replace, fill, etc...).

[snunez1]

Looks interesting. We'd need tests to go along with the code.

But, I'm not quite clear on what problem this solves. Can you give some context and use cases on why/when/where someone would want this? That would be a good start on docs as well.

[q3cpma]

On Wed Dec 14, 2022 at 1:53 PM CET, Steve Nunez wrote: Looks interesting. We'd need tests to go along with the code. But, I'm not quite clear on what problem this solves. Can you give some context and use cases on why/when/where someone would want this? That would be a good start on docs as well. --

Basically, the same problem as vectorize (https://lisp-stat.dev/docs/manuals/array-operations/#vectorize), but without the limitations of needing bound symbols argument and using these symbols as lambda list. Exactly like map, but generalized to arrays. Of course, I'd make some tests and doc in a proper PR.