Functions

Mux functions use the func keyword with explicit parameter types and return type declarations in the form of:
func <function_name>(<parameter_types> <parameters>) returns <return_type> { ... }

Basic Function Definition

functions.mux

Keyword func declares a function
Parameter list with explicit types (no type inference with auto allowed)
returns clause specifies return type (explicit, no inference)
Body enclosed in {...} with no semicolons
Local variables within functions can use auto inference

Default Parameters

default_params.mux

Return Types

All functions must explicitly declare their return type:

return_types.mux

Unused Parameters

Use _ for parameters you don't need:

unused_params.mux

This is useful when implementing interfaces or callbacks that require specific signatures.

Lambdas and Closures

Mux supports anonymous functions (lambdas) using block syntax:

lambdas.mux

Using Lambdas with Collections

lambda_collections.mux

Generic Functions

Functions can be generic (see generics and interfaces) over type parameters:

generic_functions.mux

Built-in Functions

Mux provides essential built-in functions available without imports:

Output

print(string message) -> void - Outputs to stdout with newline:

print_example.mux

Input

read_line() -> string - Reads a UTF-8 line from stdin. Input is bounded to 16 MiB; an oversized or invalid-UTF-8 line fails the read:

read_line_example.mux

Utility

range(int start, int end) -> list<int> - Creates a list of integers, inclusive of start and exclusive of end:

range_example.mux

Design Note: range() is the primary way to create numeric sequences, as Mux does not support C-style for (int i = 0; i < n; i++) loops.

Function Calling

function_calls.mux

Wrapping a Long Argument List

An argument list may span lines, because a newline inside an open parenthesis continues the expression (see the lexical structure reference). A trailing comma before the closing parenthesis is allowed, so adding an argument is a one-line change.

wrapped_call.mux

Argument Count

A call must pass exactly as many arguments as the function declares (after accounting for any defaults). Passing too few or too many arguments is a compile-time error, not a runtime one.

argument_count.mux

To call a function with fewer explicit arguments, give the trailing parameters default values (see Default Parameters above); parameters without defaults are always required.

Calling `main()` Explicitly

Mux allows explicit calls to main() from user code.

main_call.mux

The startup entrypoint still calls main() once automatically. If user code also calls main(), it will execute multiple times.

Best Practices

Explicit types for parameters and return values - Makes function signatures clear
Use auto for local variables - Reduces verbosity when types are obvious
Return result<T, E> for fallible operations - Better than panicking
Return optional<T> for nullable values - Explicit absence handling
Use _ for truly unused parameters - But prefer descriptive names when helpful
Keep functions small and focused - Single responsibility

Basic Function Definition​

Default Parameters​

Return Types​

Unused Parameters​

Lambdas and Closures​

Using Lambdas with Collections​

Generic Functions​

Built-in Functions​

Output​

Input​

Utility​

Function Calling​

Wrapping a Long Argument List​

Argument Count​

Calling main() Explicitly​

Best Practices​

See Also​