62 lines
2.1 KiB
Plaintext
62 lines
2.1 KiB
Plaintext
---
|
||
title: Traits
|
||
description: Defining shared behavior and contracts with Mist's signature ergonomics.
|
||
icon: Sparkles
|
||
---
|
||
|
||
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.
|
||
|
||
```mist
|
||
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.
|
||
|
||
```mist
|
||
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.
|
||
|
||
```mist
|
||
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.
|
||
|
||
```mist
|
||
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.
|