---
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. 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.

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

## Implementing a Trait

Use `impl Trait for Type` to provide implementations:

```mist
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:

```mist
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:

```mist
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.