iteration library and lightweight bind syntax

[nikomatsakis]

I am working on a nicer iteration library. This requires a lightweight bind syntax. I am working on that too. You can see current status and get a flavor from the cargo package "iter", though the eventual plan is to move that into libcore (or libstd?)

The bind extension is that the bind keyword will no longer be required. So one can write foo(a, b, _) which means precisely the same thing as bind foo(a, b, _) used to, except that I plan to infer whether to use a boxed closure, stack closure, etc. It will also work for receivers, like _.foo(_). The plan is to have the code path in the compiler be very similar to the one used for closures (trans_bind, for example, should go away completely).

[graydon]

Hm. Might make parsing a bit sneaky, but if you can make it work I'm not opposed.

[nikomatsakis]

One issue occurred to me. This is not so much related to the parsing as it is related to my efforts to make bind() and closures follow the same path through the code (right now, bind is different, and hence many things that should work actually don't, e.g., bind v.foo(_)).

The change is that if I write foo(a, _) (here I will use bind-less syntax to indicate the new path through the code), then what I am generating is basically sugar for {|b| foo(a, b)}. But this is not the same as what bind foo(a, _) generated, which was kind of sugar for {let a0 = a; {|b| foo(a0, b)}}.

It's not clear to me that it's a problem, but it's a change. It has some advantages. It allows the syntax to work with movable values, for example, in particular stack closures. That means something like:

list.map({|x| x+2}, _) 

works just fine even if {|x| x+2} becomes a stack closure.

The disadvantage of course is that complex expressions get re-evaluated each time the closure is invoked.

[marijnh]

This is a great idea. I've been talking about getting rid of the bind keyword in favour of such syntax for ages, but never actually did it.

[nikomatsakis]

As a side effect, this fixes an existing bug in bind, which is that it ignored typestate predicates that were attached to the bound function.

[graydon]

I'm ok with such changes. You've done some of this already though, yes?

[graydon]

Further work on this is blocked on traits and regions, so bumping to 0.3.

[nikomatsakis]

iter trait approach is basically there, though traits are needed to make it nice.