Using `iter-yield` with `seq.el` and mapping functions?

Using `iter-yield` with `seq.el` and mapping functions?

[Okamsn]

Hello,

Is it possible to use `iter-yield` via mapping functions and `seq.el`
functions? For example, when I do

     (setq iter-maker (iter-lambda (x)
                        (seq-doseq (item x)
                          (iter-yield item))))
     (setq my-iter (funcall iter-maker '(1 2 3)))
     (iter-next my-iter)

I get an error "(void-function cps-internal-yield)".

When I try

     (setq iter-maker (iter-lambda (x)
                        (seq-do #'iter-yield x)))
     (setq my-iter (funcall iter-maker '(1 2 3)))
     (iter-next my-iter)

I get the error "(error "‘iter-yield’ used outside a generator")".

These are both with lexical binding enabled on Emacs 28.1.

Can iterators be used with these functions and other mapping functions,
such as `mapatoms`, `mapc`, and the like?

Thank you.

Re: Using `iter-yield` with `seq.el` and mapping functions?

[Michael Heerdegen]

Okamsn <okamsn@protonmail.com> writes:

> Is it possible to use `iter-yield` via mapping functions and `seq.el`
> functions? For example, when I do
>
>      (setq iter-maker (iter-lambda (x)
>                         (seq-doseq (item x)
>                           (iter-yield item))))
>      (setq my-iter (funcall iter-maker '(1 2 3)))
>      (iter-next my-iter)
>
> I get an error "(void-function cps-internal-yield)".

Good question.  `dolist' works.  A rewrite using `mapc' doesn't (same
error).

Michael.

Re: Using `iter-yield` with `seq.el` and mapping functions?

[Michael Heerdegen]

Michael Heerdegen <michael_heerdegen@web.de> writes:

> Good question.  `dolist' works.  A rewrite using `mapc' doesn't (same
> error).

Stefan, do you maybe know whether

#+begin_src emacs-lisp
(iter-next
 (funcall
  (iter-lambda (l)
    (mapc (lambda (y) (iter-yield y))
          l))
  '(1 2 3)))
#+end_src

is expected to error?

A rewrite using `dolist' works as expected:

#+begin_src emacs-lisp
(iter-next
 (funcall
  (iter-lambda (l)
    (dolist (y l) (iter-yield y)))
  '(1 2 3)))
#+end_src


Michael.

Re: Using `iter-yield` with `seq.el` and mapping functions?

[Emanuel Berg]

Michael Heerdegen wrote:

> (iter-next
>  (funcall
>   (iter-lambda (l)
>     (dolist (y l) (iter-yield y)))
>   '(1 2 3)))

Hm, what's the advantage or increased expressibility with
this method?

-- 
underground experts united
https://dataswamp.org/~incal

Re: Using `iter-yield` with `seq.el` and mapping functions?

[Michael Heerdegen]

Emanuel Berg <incal@dataswamp.org> writes:

> Michael Heerdegen wrote:
>
> > (iter-next
> >  (funcall
> >   (iter-lambda (l)
> >     (dolist (y l) (iter-yield y)))
> >   '(1 2 3)))
>
> Hm, what's the advantage or increased expressibility with
> this method?

Do you ask about the purpose of using iterators, or do you ask why the
above call doesn't error like the one having the issue?

Michael.

Re: Using `iter-yield` with `seq.el` and mapping functions?

[Emanuel Berg]

Michael Heerdegen wrote:

>>> (iter-next
>>>  (funcall
>>>   (iter-lambda (l)
>>>     (dolist (y l) (iter-yield y)))
>>>   '(1 2 3)))
>>
>> Hm, what's the advantage or increased expressibility with
>> this method?
>
> Do you ask about the purpose of using iterators

Yes?

-- 
underground experts united
https://dataswamp.org/~incal

Re: Using `iter-yield` with `seq.el` and mapping functions?

[Michael Heerdegen]

Emanuel Berg <incal@dataswamp.org> writes:

> > Do you ask about the purpose of using iterators
>
> Yes?

(info "(elisp) Generators") (though the concept is not really explained
there).

It's mainly a form of abstraction.  If you process data, you model your
algorithm conceptually like

  iterate values --> filter or map values --> accumulate

with different stand-alone modules for each step (each step to be
understood in a broad sense, e.g. the last step could be "pick the
maximum").

An iterator enumerates a sequence of values (a related concept are
streams).  In Elisp, functions creating iterators are called
"generators".

An example: a function returning iterators that would enumerate the
leaves of a tree represented as a list structure could be defined like

(iter-defun iter-tree (list)
  (while list
    (let ((next (pop list)))
      (if (listp next) (iter-yield-from (iter-tree next))
        (iter-yield next)))))

Then

(setq my-iter-my-tree
     (iter-tree '(1 ((2 (3 4) 5) ((6 7) (8))) 9)))

would define a fresh iterator enumerating the leaves of the specified
tree:

(iter-next my-iter-my-tree) yields the values one by one:

(iter-next my-iter-my-tree)  ==> 1
(iter-next my-iter-my-tree)  ==> 2
                ...

Each iterator has its own individual state:

(setq my-iter-my-tree2
     (iter-tree '(1 ((2 (3 4) 5) ((6 7) (8))) 9)))

(iter-next my-iter-my-tree2) ==> 1
(iter-next my-iter-my-tree)  ==> 3

Iterators are (special) closures, they have a specific internal state.
You could say that the iter-defun code is stopped, or frozen, when you
yield, and continued at the exact same position, with the same "future
of computation", as had been left.  This future of computation is called
"continuation".

Continuations are implicit in generator.el: code is rewritten
automatically in a style that allows continuations to be created on the
fly.  `iter-next' just calls the continuation for the given iterator, so
to say.  In Scheme continuations are even first class objects.  You can
do a lot with them (also bad things).

Anyway, being able to return directly to a state in a program you have
just left is a nice thing - even when continuations are (only) implicit.
Allows to implement concurrency for example.  But even if you just want
data processing, the nice thing is that because of the automatic rewrite
(in CPS, "Continuation Passing Style"), you as a programmer are not
forced to write your code in a special style - you are freed from the
task of managing the "state" yourself.


Michael.

Re: Using `iter-yield` with `seq.el` and mapping functions?

[Michael Heerdegen]

Okamsn,

I have opened Bug#59140 "iter-yield from lambda" about this.  Thanks
for bringing this up.

I think one can only work around the issue for now e.g. by using a
`while' loop instead.

Michael.