decide if we should do backtracking in impl resolution

[brson]

This is the next thing blocking removal of iter-trait:

trait MyIter<A> {
    fn myeach(&self, blk: fn(v: &A) -> bool);
}
trait ExtendedIter<A> {
    fn myeachi(&self, blk: fn(uint, v: &A) -> bool);
}

impl <A, IA: MyIter<A>> IA: ExtendedIter<A> {
    fn myeachi(&self, blk: fn(uint, v: &A) -> bool) { }
}

impl<A> &[A]: MyIter<A> {
    fn myeach(&self, blk: fn(v: &A) -> bool) { }
}

fn main() {
    let v = ~[0];
    for v.myeachi |_i, _j| { }
}

/home/brian/dev/rust/src/test/run-pass/test.rs:18:8: 18:17 error: failed to find an implementation of trait @MyIter<<V3>> for <V4>
/home/brian/dev/rust/src/test/run-pass/test.rs:18     for v.myeachi |_i, _j| { }

[nikomatsakis]

Fixing this is a bit of a doozy, but it needs to be done anyhow. This basically requires rewriting the impl res. strategy to be "backtracking". That is, in order to decide if the method eachi() is applicable, we need to recurse and decide whether A is implemented for the proposed type. This is tied in with us deciding what limits (if any) we wish to place on impls; I think that @pcwalton and I have generally come to the feeling that we should place very few, and just beef up our resolution algorithminstead.

[catamorphism]

Bumping to 0.7

[catamorphism]

Seems non-critical for 0.7. Nominating for milestone 3, feature-complete.

[nikomatsakis]

cc #5527

[graydon]

accepted as well defined

[emberian]

Triage bump

[erickt]

Still an unfixed as of 2460170. I updated the code to the latest syntax:

trait MyIter<T> {
    fn myeach(&self, blk: &fn(&T) -> bool);
}

trait ExtendedIter<T> {
    fn myeachi(&self, blk: &fn(uint, &T) -> bool);
}

impl<T, IT: MyIter<T>> ExtendedIter<T> for IT {
    fn myeachi(&self, blk: &fn(uint, &T) -> bool) { }
}

impl<'self, T> MyIter<T> for &'self [T] {
    fn myeach(&self, blk: &fn(&T) -> bool) { }
}

fn main() {
    let v = ~[0];
    for v.myeachi |_i, _j| { }
}

[flaper87]

Triage bump. Updated example (kept it close to the original one).

trait MyIter<T> {
    fn myeach(&self, blk: &fn(&T) -> bool);
}

trait ExtendedIter<T> {
    fn myeachi(&self, blk: &fn(uint, &T) -> bool);
}

impl<T, IT: MyIter<T>> ExtendedIter<T> for IT {
    fn myeachi(&self, blk: &fn(uint, &T) -> bool) { }
}

impl<'a, T> MyIter<T> for &'a [T] {
    fn myeach(&self, blk: &fn(&T) -> bool) { }
}

fn main() {
    let v = ~[0];
    let iter = v.myeachi(|b, &a| {false});
}

[nikomatsakis]

This issue is really not relevant anymore. Trait reform implemented backtracking and more.