Rust by Example

owner.add_one();

owner.print();

}

הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

See also:

methods

Structs

Annotation of lifetimes in structures are also similar to functions:

// A type `Borrowed` which houses a reference to an

// `i32`. The reference to `i32` must outlive `Borrowed`.

#[derive(Debug)]

struct Borrowed<'a>(&'a i32);

// Similarly, both references here must outlive this structure.

#[derive(Debug)]

struct NamedBorrowed<'a> {

x: &'a i32,

y: &'a i32,

}

// An enum which is either an `i32` or a reference to one.

#[derive(Debug)]

enum Either<'a> {

Num(i32),

Ref(&'a i32),

}

fn main() {

let x = 18;

let y = 15;

let single = Borrowed(&x);

let double = NamedBorrowed { x: &x, y: &y };

let reference = Either::Ref(&x);

let number = Either::Num(y);

println!("x is borrowed in {:?}", single);

println!("x and y are borrowed in {:?}", double);

println!("x is borrowed in {:?}", reference);

println!("y is *not* borrowed in {:?}", number);

}

הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

See also:

structs

Traits

Annotation of lifetimes in trait methods basically are similar to functions. Note that impl may have annotation of lifetimes too.

// A struct with annotation of lifetimes.

#[derive(Debug)]

struct Borrowed<'a> {

x: &'a i32,

}

// Annotate lifetimes to impl.

impl<'a> Default for Borrowed<'a> {

fn default() -> Self {

Self {

x: &10,

}

}

}

fn main() {

let b: Borrowed = Default::default();

println!("b is {:?}", b);

}

הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה