Traits

Traits in Mist define a set of methods that a type must implement, facilitating polymorphism and shared behavior. Method signatures use the fn keyword with *self for the instance parameter.

Defining a Trait

A trait lists method signatures using fn, with *self as the instance parameter and the return type after the parameter list.

pub trait Drawable {
    fn draw(*self);
    fn metadata(*self) *str;
}

Implementing a Trait

Use impl Trait for Type to provide implementations:

impl Drawable for Task {
    fn draw(*self) {
        println!("Drawing task: {}", self.name);
    }

    fn metadata(*self) *str {
        self.name
    }
}

Default Implementations

Traits can provide default behavior for methods that implementing types may override:

pub trait Identifiable {
    fn get_id(*self) u32;

    fn is_valid(*self) bool {
        self.get_id() > 0
    }
}

Super-traits

A trait can require another trait using the colon : syntax:

pub trait Speak {
    fn speak(*self) String;
}

pub trait Greet : Speak {
    fn greet(*self) String;
}

Key Characteristics

• fn Signatures: Method signatures use fn, consistent with free functions.
• Explicit Context: Methods use *self as the first parameter, mapping directly to Rust's reference rules.
• Default Methods: Traits can provide default implementations.
• Super-traits: Colon syntax for expressing trait requirements.
• Static Dispatch: By default, Mist traits leverage Rust's zero-cost generics and monomorphization.