Functions

Overview

Echo functions are named, typed, and strict about scope.

Syntax

fn greet(name: str) {
    say("Hello, ${name}!");
}

fn add(a: int, b: int) -> int {
    return a + b;
}

fn square(x: int) -> int => x * x;

Example

fn describe(name: str, age: int) {
    say(name, "is", age);
}

describe(age: 21, name: "Alice");

Output

Alice is 21

Notes

Parameter types

Every parameter needs a type annotation.

Return types

Return type annotations are optional only when the function has no return statements.

If a function contains return, a return type annotation is required.

fn log(msg: str) {
    say(msg);
}

fn add(a: int, b: int) -> int {
    return a + b;
}

return;

Bare return; is allowed.

Keyword arguments

User-defined functions support keyword arguments. Built-ins do not.

Scope inside functions

Outer variables are not automatically visible inside functions. Use:

use x;
use mut x;

Common Mistakes

Reading an outer variable without use

name: str = "Echo";

fn greet() {
    say(name);
}

Writing an outer variable without use mut

count: int = 0;

fn bump() {
    count = count + 1;
}

Returning the wrong type from an annotated function

That raises a runtime type error.

Current Limitation

• No default parameters
• No variadic functions
• No overloads
• No anonymous function values

See Also

• Scope, use, and watch
• Built-in Methods
• Errors and Troubleshooting