Nessun errore per due caratteri attuare lo stesso metodo

Question

Secondo the docs, Rust dovrebbe lamentarsi se provo a chiamare un metodo fornito da due tratti diversi, come questo:

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(); 
} 

L'esecuzione di questo risultato è la error: multiple applicable methods in scope errore previsto.

Tuttavia non ottengo errore per questo:

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 implementa sia Buf e Read. Entrambi i tratti forniscono un metodo bytes.

Mi aspetterei che Rust si lamenti con lo stesso errore di cui sopra. Invece sceglie silenziosamente l'implementazione "sbagliata" e in seguito lo println si lamenta del tipo sbagliato.

Qualche idea sul motivo per cui non viene visualizzato un errore qui?

Se rimuovo use std::io::Read;, tutto funziona correttamente. Ma con quel tratto di scope all'improvviso all'improvviso viene utilizzata l'implementazione di Read e i byte hanno il tipo "sbagliato".

(sto usando Rust 1.0.0)

Answer 1

@bluss trovato il problema:

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`. 
} 

Se entrambi i tipi di utilizzare un po 'diverso self tipo, Rust li tratta come diverso e chiamando il metodo semplicemente preferisce uno di loro.

Questo è probabilmente un bug in Rust. Per i dettagli dare un'occhiata al corrispondente Rust issue.