Traits

Traits in Mist define a set of methods that a type must implement, facilitating polymorphism and shared behavior. While they mirror the logic of Rust traits, they utilize Mist’s type-first declaration style for method signatures.

Defining a Trait

A trait definition lists method signatures that implementing types must satisfy. Like functions, these signatures place the return type before the method name.

public trait Drawable {
    void draw(self*);
    str* metadata(self*);
}

Implementing a Trait

To implement a trait for a specific type, use the impl keyword followed by the trait name and the target type. This block must contain all required methods defined in the trait.

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

    str* metadata(self*) {
        return self.name;
    }
}

Default Implementations

Traits can provide default behavior for methods. Types implementing the trait can choose to override these defaults or use the provided implementation.

public trait Identifiable {
    u32 get_id(self*);

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

Super-traits

Traits can build upon other traits. If a trait requires another trait to be implemented first, use the colon : syntax.

public trait Animated : Drawable {
    void animate(self*, f32 delta_time);
}

Key Characteristics

• Consistent Signatures: Method signatures within traits follow the language-wide return_type name(params) convention.
• Explicit Context: Methods use self* or self mut* as the first parameter to define how the instance is accessed, mapping directly to Rust's reference rules.
• Static Dispatch: By default, Mist traits leverage Rust's zero-cost generics and monomorphization, ensuring high performance.
• Predictable Contracts: Traits act as strict blueprints; the Mist compiler ensures every implementation perfectly matches the interface before generating the corresponding Rust code.