impl block

Define methods on a struct with impl.

The impl block

Methods are attached to a type inside an impl block. The first parameter is self and represents the instance the method is called on:

struct Kutu { en: u32, boy: u32 }

impl Kutu {
    fn alan(&self) -> u32 {
        self.en * self.boy
    }
}

let k = Kutu { en: 3, boy: 4 };
println!("{}", k.alan());   // 12

Methods gather the type's behaviour in one place and are called with dot syntax.

Automatic referencing

In the call k.alan(), Rust looks at the method signature and adds &k, &mut k or *k if needed. That's why no separate operator like C++'s -> is needed:

let k = Kutu { en: 3, boy: 4 };
let r = &k;
println!("{} {}", k.alan(), r.alan());   // 12 12
println!("{}", Kutu::alan(&k));            // full path: 12

Exercise Area method

For Kutu { en: u32, boy: u32 }, write the method fn alan(&self) -> u32 in an impl block. Print the result of k.alan() for Kutu { en: 3, boy: 4 }.

Show example solution

struct Kutu {
    en: u32,
    boy: u32,
}

impl Kutu {
    fn alan(&self) -> u32 {
        self.en * self.boy
    }
}

fn main() {
    let k = Kutu { en: 3, boy: 4 };
    println!("{}", k.alan());
}

Test yourself

What is <code>&self</code> short for?
- self: &Self
- self: Self
- self: &mut Self
- this: &Kutu
Show answer

self: &Self — Inside impl Kutu, Self is an alias for the Kutu type; &self is the short way of writing self: &Self.

Attach the method

____ Kutu {
    fn alan(&self) -> u32 {
        self.en * self.boy
    }
}

Show answer

impl Kutu {
    fn alan(&self) -> u32 {
        self.en * self.boy
    }
}

Call and meaning

k.alan()

Method call
Kutu::alan(&k)

Fully qualified call
self.en

The instance's field
Self

Alias for the type

Next lesson: self parameter

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies