---
title: Functions
description: Defining execution blocks with C-style ergonomics and Rust-powered safety.
icon: SquareFunction
---

Functions are the primary unit of execution in Mist, declared with the `fn` keyword. Parameters follow the `name Type` convention and the return type is placed after the parameter list.

## Basic Syntax

A standard function begins with `fn`, followed by its name, parameters, and an optional return type. The last expression in a block is implicitly returned.

```mist
fn add(a i32, b i32) i32 {
    a + b
}

fn greet() {
    println!("Hello!");
}
```

## Visibility & Exports

Functions are private to their module by default. The `pub` modifier exports the function for cross-module access.

```mist
pub fn get_version() i32 {
    1
}

pub(crate) fn internal_use() i32 {
    0
}
```

## Mutable Parameters

Use `mut` on a parameter to allow reassignment within the function body.

```mist
fn update_score(mut current_score i32, bonus i32) i32 {
    current_score = current_score + bonus;
    current_score
}
```

## Generics & Lifetimes

Generics and lifetimes are declared in angle brackets after the function name. Lifetimes are placed before the `*` in reference types.

```mist
fn choose_longer<'a>(s1 *'a str, s2 *'a str) *'a str {
    if (s1.len() > s2.len()) { s1 } else { s2 }
}
```

## Closures

Closures are anonymous functions defined with the `fn` keyword followed by parameters, an optional return type, and a body or expression.

```mist
let add = fn(a, b) -> a + b;
add(2, 3);

// With a block body
let greet = fn(name *str) {
    println!("Hello {}", name);
};
```

## Attributes & Metadata

Metadata is applied via the `#[attr]` syntax directly above the declaration.

```mist
#[inline]
pub fn is_active(id u32) bool {
    id > 0
}
```

## Key Characteristics

- **`fn` Keyword**: Every function starts with `fn`, making declarations instantly recognizable.
- **Implicit Returns**: The final expression in a block is automatically returned.
- **Unified Abstraction**: Lifetimes and type constraints are declared in one location.
- **Closure Support**: Anonymous functions with optional return type annotations.
- **Zero-Cost Mapping**: Every function maps directly to a Rust `fn`.