Brak błędu na dwie cechy realizacji tego samego sposobu

Question

Według the docs, Rust powinien narzekać jeśli próbuję wywołać metodę dostarczone przez dwóch różnych cech tak:

trait Foo { 
    fn f(&self); 
} 

trait Bar { 
    fn f(&self); 
} 

struct Baz; 

impl Foo for Baz { 
    fn f(&self) { println!("Baz’s impl of Foo"); } 
} 

impl Bar for Baz { 
    fn f(&self) { println!("Baz’s impl of Bar"); } 
} 

fn main(){ 
    let b = Baz; 
    b.f(); 
} 

Running skutkuje oczekiwanym error: multiple applicable methods in scope błędu.

Jednak mam żadnego błędu w tym:

extern crate mio; 
use mio::buf::RingBuf; 
use mio::buf::Buf; 
use std::io::Read; 

fn main() { 
    let buf = RingBuf::new(10); 
    let bytes = buf.bytes(); 
    println!("{:?}", bytes); 
} 

mio::buf::RingBuf realizuje zarówno Buf i Read. Obie cechy zapewniają metodę bytes.

Spodziewałbym się, że Rust złoży skargę z tym samym błędem co powyżej. Zamiast tego po cichu wybiera "niewłaściwą" implementację, a później println narzeka na niewłaściwy typ.

Każdy pomysł, dlaczego nie mam tutaj błędu?

Po usunięciu use std::io::Read; wszystko działa poprawnie. Jednak z tą cechą w zakresie nagle zastosowana jest implementacja Read, a bajty mają "zły" typ.

(Używam Rust 1.0.0)

Answer 1

@bluss znaleźć problem:

struct Type; 

trait A { 
    fn foo(&self) -> bool { false } 
} 

trait B : Sized { 
    fn foo(self) -> bool { true } 
} 

impl A for Type { } 
impl B for Type { } 

fn main() { 
    println!("{}", Type.foo()); // This will call B::foo -- it will prefer `self`. 
} 

Jeśli oba typy użyć nieco inny self typ, Rust traktuje je jako różne i wywołanie metody po prostu preferuje jedną z nich.

To prawdopodobnie błąd w Rust. Aby uzyskać szczegółowe informacje, spójrz na odpowiedni numer Rust issue.