I'm not sure if I'm missing something here. You don't want `in-vector`
because you want to set the values of the vector, correct?
You can already do something very much like this with
```
(iter (for x in-vector *my-vector* with-index i)
(incf (aref *my-vector* i) 10))
```
I think you could probably add `access` for yourself using the existing
extension facilities of `iterate`. I would be reluctant to see this
added to the core version of `iterate` without a lot of thought about
how it interacts with other features, a very detailed implementation
plan, etc.
ITERATE is a very core piece of code for those who use it, and only to
be messed with after very deep thought, especially for things that are
easy to implement on top of it.
On 5 Aug 2025, at 11:44, Felecarp wrote:
Hello all,
I am a newcomer in lisp. I hope the mailling list is a right channel
to write this.
I imaginated a feature for iterate. A built-in clause that inserts a
symbol-macro in iterate output. It seems useful to me because
symbol-macros are elegant setf-able places.
Here is a clause named `ACCESS var IN-VECTOR v` with a symbol macro
for var.
```
(defparameter *my-vector* (make-array 8
:initial-contents (iter (for i from 1 to 8) (collect i)))
(print *my-vector*)
#(1 2 3 4 5 6 7 8)
(iter (access i in-vector *my-vector*)
(incf i 10))
(print *my-vector*)
#(11 12 13 14 15 16 17 18)
```
The clause would be writen like this :
```
(defmacro-clause (ACCESS var IN-VECTOR v)
"Access the elements of a vector"
(let ((vect (gensym))
(end (gensym))
(index (gensym)))
‘(progn
(with ,vect = ,v)
(with ,end = (array-dimension ,vect 0))
(for ,index from 0 to (1- ,end))
(with-symbol-macro ,var (aref ,vect ,index)))))
```
I see no way to implement it without modifications in the iterate
macro. But I think this can be implemented inserting a
`symbol-macrolet ,(nreverse *symbol-macro-bindings*)` just after `let*
,(nreverse *bindings*)` in the iterate macro output.
I would like to try to implement it.
My questions :
1. Are they existing approaches to get the same result in iterate ?
2. Does some common lisp iteration systems already provides this
feature in their built-ins clauses or in the extension mechanism ?
3. Does someone already tried to implement this kind of feature in
iterate ?
4. What are the contributing guidelines on the common lisp gitlab
repository ? I plan to imitate the current symbol naming, comment and
commit style ; and writing the corresponding unit tests.
