Rust, F # typedefs ile idiomatik bir eşdeğer var mı?

Question

Rust 1.6'daki mevcut kodlarımı yeniden yazıyorum ve bir yazım tipini typedef ile etiketlemek için kaynak dilde çok uygun buldum.

type Rank = uint8 

Answer 1

itibaren The Rust Programming Language bölüm `type` Aliases başlıklı: Örneğin, kartım oyunda ben F # bir sıra değeri tanımladıktan

type anahtar kelime başka türde bir takma ad bildirmek sağlar:

type Name = String; 

gerçek bir tip sanki daha sonra bu türünü kullanabilirsiniz

:

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

Okuması gereken daha çok şey var ama bu soruya cevap veriyor. başyazısında biraz itibariyle

---

, bir tür takma insanlar bunları kullanmak yerlerde bir sürü büyük bir uyum olduğunu düşünmüyorum. Rank türünüzün bir kart destesiyle ilgili bir şey olduğunu varsayarsak, enum veya newtype'u öneririm. Kartların tipik güverte saçmadır

let rank: Rank = 100; 

: nedeni bir tür takma adı ile böyle bir şey yapabiliyor olmasıdır. Bir enum sınırlı bir kümedir. Bu geçersiz bir Rank oluşturmak asla şu anlama gelir:

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, 
      // ... 
     } 
    } 
} 

A newtype sadece sarıcı türüdür. Sarılmış tiple karşılaştırıldığında fazladan alan tüketmez, yalnızca geçerli değerleri kısıtlayabilen yöntemleri uygulamanızı sağlayan gerçek bir yeni tür sağlar. Bu geçersiz değerler oluşturmak mümkündür, ancak sadece kendi kodu içinde, tüm istemci kodu:

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

Ben türlerinin hızlı tutucu olarak tip takma adları kullanma eğilimindedir. Yukarıdaki örnekler yazarken, aslında yazdı:

type Error =(); 

Ve Result<Rank, Error> döndü ama sonra o kafa karıştırıcı olacağını düşündük. :-)

Onları kullandığım diğer durum, saklamak istemediğim daha büyük bir tür kısaltmaktır. Bu, see in the standard library olan yineleyiciler veya Result s türleriyle olur. Şunlar gibi:

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

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