|
|
// Struct
|
|
|
struct Point {
|
|
|
x: i32,
|
|
|
y: i32,
|
|
|
}
|
|
|
let origin: Point = Point { x: 0, y: 0 };
|
|
|
|
|
|
// A struct with unnamed fields, called a ‘tuple struct’
|
|
|
struct Point2(i32, i32);
|
|
|
let origin2 = Point2(0, 0);
|
|
|
|
|
|
// Basic C-like enum
|
|
|
enum Direction {
|
|
|
Left,
|
|
|
Right,
|
|
|
Up,
|
|
|
Down,
|
|
|
}
|
|
|
let up = Direction::Up;
|
|
|
|
|
|
// Enum with fields
|
|
|
enum OptionalI32 {
|
|
|
AnI32(i32),
|
|
|
Nothing,
|
|
|
}
|
|
|
let two: OptionalI32 = OptionalI32::AnI32(2);
|
|
|
let nothing = OptionalI32::Nothing;
|
|
|
|
|
|
// Generics //
|
|
|
struct Foo<T> { bar: T }
|
|
|
//
|
|
|
// This is defined in the standard library as `Option`
|
|
|
enum Optional<T> {
|
|
|
SomeVal(T),
|
|
|
NoVal,
|
|
|
}
|
|
|
|
|
|
// Methods //
|
|
|
impl<T> Foo<T> {
|
|
|
// Instance methods take an explicit `self` parameter.
|
|
|
// Using `self` on its own will consume the caller, while
|
|
|
// `&self` or `&mut self` will create immutable and mutable
|
|
|
// references, respectively.
|
|
|
fn get_bar(self) -> T {
|
|
|
self.bar
|
|
|
}
|
|
|
// Static methods don't take a `self` parameter, but can still
|
|
|
// use the generic `T` type.
|
|
|
fn do_baz(msg: &str, baz: T) -> T {
|
|
|
println!("{}", msg);
|
|
|
baz
|
|
|
}
|
|
|
}
|
|
|
// Here `T` is inferred to be some integer type
|
|
|
let a_foo = Foo { bar: 1 };
|
|
|
println!("{}", a_foo.get_bar()); // 1
|
|
|
|
|
|
// `T` can be whatever you want, using "turbofish" syntax
|
|
|
// The statement below prints "Hello" and sets `result` to 24
|
|
|
let result: i32 = Foo::<i32>::do_baz("Hello", 24);
|
|
|
|
|
|
// Traits (known as interfaces or typeclasses in other languages) //
|
|
|
trait Frobnicate<T> {
|
|
|
fn frobnicate(self) -> Option<T>;
|
|
|
}
|
|
|
impl<T> Frobnicate<T> for Foo<T> {
|
|
|
fn frobnicate(self) -> Option<T> {
|
|
|
Some(self.bar)
|
|
|
}
|
|
|
}
|
|
|
let another_foo = Foo { bar: 1 };
|
|
|
println!("{:?}", another_foo.frobnicate()); // Some(1)
|