Jon Harrop wrote:
> The moral is: don't try to write idiomatic Python in OCaml.

I think the moral is rather: read the OP's email more carefully. He
doesn't want to translate some Python examples into OCaml by hand, he
wants to implement a Python interpreter in OCaml.

Erik de Castro Lopo wrote:
> Typically the original poster's pow2 generators would be used like:
>
>     for p = pow2 (10):
>         print p
>
> but I really don't see how laziness Python's generators actually
> provide any benefit for this problem over the more obvious Python
> solution to this which is:

We're not discussing (I think) a specific use case for generators, but a
generic way to support them in an interpreter.

> The problem with the above is that generators (and laziness in Ocaml)
> really only make sense for sequences which are effecitvely infinite.

I don't think so: generators provide a simple control operator which is
sometimes useful, even for finite structures, and easier to grasp than
call/cc-like operators. Typically, generators allow their client to be
written in direct style. E.g. using a push XML event parser (SAX-style)
to produce a tree requires you to maintain your own stack accross
invocations of the callbacks. Instead, a pull parser
(generator-style) lets you write a very simple direct code. You can turn
a push parser into a pull parser either with some kind of control
inversion (CPS, generators, ...), or, in this case, by collecting all
the results in a list. But: (1) this works only because the callback
can't have side effects that would change the future events;  (2) you
need to keep all the events in memory, and you cannot stop the parsing
early.

Moreover, I don't really see the connection with the notion of laziness
in OCaml. If you want to turn the generator definition into something
that produces a lazy sequence, you'll also need some kind of control
inversion.


-- Alain