2016-06-10 7 views
1

Ich grabe in Rust, speziell in die anmutige Behandlung von Fehlern, aber ich habe ein paar Probleme mit der Typinferenz.Typ Anmerkung in einem Muster übereinstimmen in Rust?

extern crate mysql; 

use mysql as my; 

fn main() { 
    my_test(); 
} 

fn my_test() -> Result<(), my::Error> { 
    let pool = try!(my::Pool::new("")); 
    let res = try!(pool.prep_exec("select 1 as count",())); 
    for rows in res { 
     let row: my::Row = try!(rows); 
     match row.take("count") { 
      None =>(), 
      Some(i) => println!("{:?}", i), 
     }; 
    } 
    Ok(()) 
} 

was dazu führt,

src/bin/main.rs:86:12: 86:13 error: unable to infer enough type information about _ ; type annotations or generic parameter binding required [E0282]

Leider sind die Dokumente in dieser Kiste verwenden unwrap viel, das hilft mir nicht. In Haskell würde ich so etwas wie println!("{:?}", i :: i32) machen, aber ich kann nicht herausfinden, wie es in Rust geht. Ich habe verschiedene Möglichkeiten ausprobiert row.take zu werfen, aber ich habe kein Glück gehabt. Ich würde gerne eine Vielzahl von Möglichkeiten sehen, wie ich diesen Code strukturiert haben könnte, wenn es eine idiomatische Art und Weise gibt, darüber zu handeln.

+1

Beachten Sie, dass dies nur ein Problem ist, da Sie 'println!' Verwenden, das eine große Bandbreite an Werten verwendet. Wenn Sie den Wert "i" in einem Kontext verwenden, der den Typ einschränkt (z. B. durch Übergabe an eine Funktion), kann der Typ abgeleitet werden. – Shepmaster

Antwort

3

Mit Blick auf Row::take Dokumentation können wir zwei Typen Parameter T und I sehen. Der Typ I ergibt sich aus dem Argument "count", für den Rückgabetyp wird der Typ T verwendet. Wir haben zwei Möglichkeiten, den Rückgabetyp, explicit in dem Methodenaufruf, oder implizit in Typ einer Variablen angeben (wie Sie mit row tat):

fn my_test() -> Result<(), my::Error> { 
    let pool = try!(my::Pool::new("")); 
    let res = try!(pool.prep_exec("select 1 as count",())); 
    for rows in res { 
     let mut row: my::Row = try!(rows); 
     // specify type T explicitly, let type I to be inferred 
     match row.take::<i32, _>("count") { 
      None =>(), 
      Some(i) => println!("{:?}", i), 
     }; 
     // or 
     let s: Option<i32> = row.take("count"); 
    } 
    Ok(()) 
} 

Die type ascription RFC schlägt eine Syntax (ähnlich dem Haskell Beispiel) zum Kommentieren eines Unterausdrucks mit einem Typ.

Verwandte Themen