As I understand it right now, that'll easen the implementation of all types of operators which intend to propagate something. For example a caching iterator which automatically caches the outermost iteration call. Even if it's used as the innermost starter. This would work by dispatching on

Iterators.map(f, c::Caching) = cache(f(x) for x in c.iter)

where cache(iter) creates the caching layer.

Now, (f(x) for x in cache(1:10)) would be the same as cache(f(x) for x in 1:10)

Also, it'd allow custom return types which in turn could implement arbitrary traits. Currently, as I understand it, you can only implement that by either not using the generator syntax or by specializing the trait for ::Generator{myf, myiter}

Edit: We'd even be able to explicitly fuse multiple Generator layers (instead of nesting them):

Iterators.map(f, c::Generator) = ((f∘c.f)(x) for x in c.iter)

(Sure that already could be done aswell but it'd fit into the same generic style very well!)

generators should lower to Iterators.map, not Base.Generator #34368

Description

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions

generators should lower to `Iterators.map`, not `Base.Generator` #34368