Dynamic dispatch through traits requires a managed pointer

[zeux]

I'm trying to write a function that reads 4 bytes from the reader using Reader trait and dynamic dispatch. This code:

fn readbytes(reader: &std::io::Reader) -> ~[u8] { reader.read_bytes(4) }

results in this error:

<anon>:5:59: 5:81 error: failed to find an implementation of trait std::io::Reader for &std::io::Reader<no-bounds>

The error message is confusing; nevertheless, replacing borrowed pointer with a managed one makes the code compile:

fn readbytes(reader: @std::io::Reader) -> ~[u8] { reader.read_bytes(4) }

However, requiring a managed pointer for dynamic dispatch seems excessive. Is this a bug?

[alexcrichton]

This may not be so much of a bug with dynamic dispatch, but rather with how std::io is designed. Inside of that module, you'll find:

impl Reader for @Reader { ... }
impl<T: Reader> ReaderUtil for T { ... }

I think what's happening here is that there's no impl of Reader for &Reader (which is a bit odd), so that's why @Reader is explicitly working. There's a few things to note about this though:

1. std::io is going to be removed soon
2. ReaderUtil should probably be implemented as default methods (now that they work) instead of a helper trait.
3. The method lookup should probably actually work in this case.

As an example, I think that this code should compile:

trait A {}
trait B { fn foo(&self); }

impl<T: A> B for T {
    fn foo(&self) {}
}

fn foo(a: &A) {
    a.foo();
}

fn main() {}

Basically, if you ignore all the ways in which I think std::io should change, I think that this small code sample should compile regardless.

[thestinger]

Note that std::io is being replaced with std::rt::io.

[nikomatsakis]

As @alexcrichton said, this is a bug with io (which is a known problem). Regarding the later example he gave, that snippet does not compile and should not compile because the object type &A does not automatically implement the trait A. The reason for this is that, to implement a trait, a type must implement ALL of the trait methods, but some traits have methods that are not usable with various object types (as a simple example, consider an @self method -- how could you invoke that on an &A object?). Closing since there is no bug to be fixed except for io, and work there is in progress.