This chapter explains how to declare and implement functions which transform provided parameters into returned value(s). Here's a simple example of function definition and use:

// Define the 'square' function
fn square(a f32) f32
	return a*a

// Use square to calculate the area of a circle	
area = Float.pi * square(r)

This example shows the key parts of an function definition:

Parameter Declaration

The declaration of a functions's parameters is a comma-separated list of variable names, enclosed in parentheses. Each parameter variable corresponds on a one-to-one basis to the values passed to the function when it is called. They must match in both number and type:

// Define a method that returns the addition of its two parameters
fn add(a i32, b i32) i32
	return a+b

add(2,3)  // returns 5, since a is set to 2 and b to 3
add(2)    // ERROR! add() needs exactly two values, not one or three
add(2.0, 4.0)  // ERROR! add() needs integers, not floating point numbers

For those wondering, this number and type restriction means Cone does not support:

Parameter variables are local variables

Within the statement block, a parameter variable is treated just like a local variable. Indeed, the declaration for each parameter looks very much like a declaration for a local variable, with the value type being specified after the variable's name. In the common case where the permission is omitted, the imm permission is assumed. That restricts the function's logic from changing the value of a passed parameter.

To allow a parameter's value to be changed, precede the name with mut. Unless references (pointers) are involved, mutation of the parameter's value will have no effect on the caller since the parameter's value is a copy of the caller's value. Changes to one value do not affect the other.

fn weird(a i32, mut b i32)
	a = 34    // ERROR! a is immutable and may not be changed
	b = 4     // b may be changed since it is declared 'mut'

number = 3
weird(5, number)
// number is still 3, despite weird() changing b to 4

Parameter Defaults

If desired, default values may be specified for any parameter value using the assignment operator '='. The default value is what we want the parameter to have if the caller provides no value for it. The default value can only be a literal value.

fn next(nbr i32, incr i32 = 1) i32
	return nbr + incr

next(5,2) // returns 7
next(4)   // returns 5 (using incr's default value of 1)
next()    // ERROR! no default value for nbr

Statement Block

The indented statements that follow the function's signature are its statement block. The block consists of a sequence of statements that represents the function's logic. Generally, each statement is performed in order.

Each statement is typically an expression (including an assignment or block expression). A block's statement could also be a local variable declaration, some nested block, or one of a set of special statements supported by Cone. The Block chapter offers detailed information about what you can do with different kinds of blocks.

Return Statement

A return statement may be placed at the end of any block. When encountered, execution of the function ceases and the comma-separated values specified after return are returned to the caller. The number and types of all return values must match the return types declared on the function's signature.

fn ceil(x i32) i32, i32
	if x > 6
		return x, 6
	return x, x

mut a,b = ceil(8)   // returns 8,6
a,b = ceil(3)       // returns 3,3

Implicit returns

A function does not have to specify a return statement at the end of its main block. If the function signature does not declare a return value, the function just returns after the last statement is performed.

If the function signature declares that values must be returned, an attempt is made to matching the values on the last statement or block of the function:

Should the correct number of type-matching return values not be found as described above, a compile error will result.

Recursive Functions

A function may call itself recursively:

fn factorial(x i32, prod i32 = 1)
	return prod if x<=1
	factorial(x-1, prod*x)

If the function returns a single value calculated by any function, this will be "tail-call" optimized. This optimization improves performance and reduces the risk of execution stack overrun with recursive calls.

Related Capabilities

Several other language features, described elsewhere, look and act like functions: