Rust ha un equivalente idiomatico di typedef F #?

Question

Sto riscrivendo il mio codice esistente in Rust 1.6 e ho trovato molto conveniente nella lingua di origine etichettare un tipo per typedef. Ad esempio, nel mio gioco di carte ho un valore di rango in F # definito come:

type Rank = uint8 

Answer 1

Da The Rust Programming Language sezione intitolata `type` Aliases:

Il type parola chiave consente di dichiarare un alias di un altro tipo:

type Name = String; 

è possibile utilizzare questo tipo, come se fosse un vero e proprio tipo:

type Name = String; 
let x: Name = "Hello".to_string(); 

C'è altro che dovresti leggere, ma questo risponde alla domanda.

---

come un po 'editoriale, non credo che un tipo alias è una grande misura in un sacco di posti che la gente li utilizzano. Supponendo che il tuo tipo Rank rappresenti qualcosa da fare con un mazzo di carte, ti suggerirei uno enum o uno newtype. La ragione è che con un tipo di alias che si può fare qualcosa di simile:

let rank: Rank = 100; 

Che è senza senso per un mazzo di carte tipico. Un enum è un set limitato. Questo significa che non si può mai creare un invalido Rank:

enum Rank { 
    One, Two, Three, Four, Five, 
    Six, Seven, Eight, Nine, Ten, 
    Jack, Queen, King, Ace, 
} 

impl Rank { 
    fn from_value(v: u8) -> Result<Rank,()> { 
     let r = match v { 
      1 => One, 
      2 => Two, 
      // ... 
      _ => return Err(()), 
     }; 
     Ok(r) 
    } 

    fn value(&self) -> u8 { 
     match *self { 
      One => 1, 
      Two => 2, 
      // ... 
     } 
    } 
} 

Un Newtype è solo un tipo di involucro. Non consuma spazio extra rispetto al tipo avvolto, fornisce solo un nuovo tipo effettivo che consente di implementare metodi che possono limitare a valori validi. E 'possibile creare valori non validi, ma solo entro il proprio codice, non tutto il codice del client:

struct Rank(u8); 

impl Rank { 
    fn from_value(v: u8) -> Result<Rank,()> { 
     if v >= 1 && v <= 14 { 
      Ok(Rank(v)) 
     } else { 
      Err(()) 
     } 
    } 

    fn value(&self) -> u8 { 
     self.0 
    } 
} 

tendo a usare gli alias di tipo come segnaposto veloci di tipi. Durante la scrittura gli esempi di cui sopra, ho scritto:

type Error =(); 

E tornato un Result<Rank, Error>, ma poi pensato che sarebbe stato fonte di confusione. :-)

L'altro caso che li uso è quello di accorciare un tipo più grande che non voglio nascondere. Ciò accade con tipi come iteratori o Result s, che è possibile see in the standard library. Qualcosa di simile:

type CardResult<T> = Result<T, Error>; 

fn foo() -> CardResult<String> { 
    // .. 
}