Functions

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.

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.

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.

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.

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.

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.

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