`type` Aliases

The type keyword lets you declare an alias of another type:

fn main() { type Name = String; }

type Name = String;

You can then use this type as if it were a real type:

fn main() { type Name = String; let x: Name = "Hello".to_string(); }

type Name = String;

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

Note, however, that this is an alias, not a new type entirely. In other words, because Rust is strongly typed, you’d expect a comparison between two different types to fail:

fn main() { let x: i32 = 5; let y: i64 = 5; if x == y { // ... } }

let x: i32 = 5;
let y: i64 = 5;

if x == y {
   // ...
}

this gives

error: mismatched types:
 expected `i32`,
    found `i64`
(expected i32,
    found i64) [E0308]
     if x == y {
             ^

But, if we had an alias:

fn main() { type Num = i32; let x: i32 = 5; let y: Num = 5; if x == y { // ... } }

type Num = i32;

let x: i32 = 5;
let y: Num = 5;

if x == y {
   // ...
}

This compiles without error. Values of a Num type are the same as a value of type i32, in every way. You can use tuple struct to really get a new type.

You can also use type aliases with generics:

fn main() { use std::result; enum ConcreteError { Foo, Bar, } type Result<T> = result::Result<T, ConcreteError>; }

use std::result;

enum ConcreteError {
    Foo,
    Bar,
}

type Result<T> = result::Result<T, ConcreteError>;

This creates a specialized version of the Result type, which always has a ConcreteError for the E part of Result<T, E>. This is commonly used in the standard library to create custom errors for each subsection. For example, io::Result.