Defining Functions

Let's now take a look at the syntax and semantics for defining new functions in Ryna.

Syntax

You can define and use a function using the following syntax:

// Definition
fn funtion_name_1(param_1: Type_1, param_2: Type_2, ...) -> Return_type {

    [...]

    return some_expression;
}

// Usage
let variable: Return_type = funtion_name_1(something_1, something_2);

Of course, you can have as many return statements as you want (or none at all if your function does not return anything), but this is a simple example. Now let's modify this code to create a generic function:

// Definition
fn<T, G> funtion_name_2(param_1: Type_1, param_2: Type_2, ...) -> Return_type {

    [...]

    let variable_1: 'T = something;
    let variable_2: Array<'G> = something;

    [...]

    return some_expression;
}

// Explicit usage
let variable_1: Return_type = funtion_name_2<Type_3, Type_4>(something_1, something_2);

// Type parameter inference (when unambiguous)
let variable_2: Return_type = funtion_name_2(something_1, something_2);

Here you can see that putting <T, G> after the fn keyword in the definition defines the templates T and G inside the function body. They cannot be used outside the function body.

Note: the <T, G> syntax might change to <'T, 'G> in a future release for ease of highlighting and uniformization.

Examples

Let's create some common examples to see how functions work in this language. First off, let's create two factorial functions, a recursive and an iterative one:

fn factorial_recursive(n: Int) -> Int {
    if n == 1 {
        return 1;
    }

    return n * factorial_recursive(n - 1);
}

fn factorial_iterative(n: Int) -> Int {
    let res = 1;

    while n > 1 {
        res = res * n;
        n = n - 1;
    }

    return res.deref();
}

Now let's dive into generics and make a function that counts how many elements in an array are equal to one given as a parameter:

fn<T> count(array: &Array<'T>, elem: &'T) -> Int {
    let res = 0;

    for i in array {
        if i == elem {
            res = res + 1;
        }
    }

    return res.deref();
}