# Never - Functional Programming Language

Never is a simple functional programming language. Technically it may be classified as syntactically scoped, strongly typed, call by value, functional programming language.

In practise Never offers basic data types, assignment, control flow, arrays, first order functions and some mathematical functions to make it useful to calculate expressions. Also it demonstrates how functions can be compiled, invoked and passed as parameters or results between other functions.

## Introduction

``````func main() -> float
{
100.0 * 1.8 + 32.0
}
``````

A program written in Never language starts in function `main`. `Main` function takes no parameters and returns `int` or `float` value. When embedded in Unix shell or C language `main` can take `int` or `float` parameters. The function may only return value of one expression. In the above example temperature of boiling water given in Celsius degrees is converted to Fahrenheit degrees.

``````func cel2fah(c : float) -> float
{
c * 1.8 + 32.0
}

func main() -> float
{
cel2fah(100.0)
}
``````

In practice, however, one will define a function which will convert any degree. The above listing presents such a function.

In particular, functions may invoke themselves. The Fibonacci function is a classic example:

``````func fib(n : int) -> int
{
(n == 0) ? 1 : (n == 1) ? 1 : fib(n - 1) + fib(n - 2)
}

func main() -> int
{
fib(7)
}
``````

or greatest common divisor:

``````func gcd(x : int, y : int) -> int
{
(y == 0) ? x : gcd(y, x % y)
}

func main() -> int
{
gcd(56, 12)
}
``````

Result of a function is calculated recursively. The above listing also demonstrates conditional expression. Conditional expression takes the form of `condition ? expr true : expr false`. That is when condition is true, value after `?` is returned. When the condition is false, value after `:` is returned.

When last function called is recursive function we call it tail recursion. It lets to substitute function invocations with repetitive calls and improve program execution. In the above examples `gcd` function is recursive. Fibonacci function `fib` may seem tail recursive, however the last function called is addition, thus it is not considered tail recursive.

## First Class Functions

One of most interesting features of functional programming languages is their ability to accept and return functions. The following code demonstrates this feature.

``````func fah2cel(f : float) -> float
{
(f - 32.0) / 1.8
}

func cel2fah(c : float) -> float
{
c * 1.8 + 32.0
}

func dir_deg(d : int) -> (float) -> float
{
d == 0 ? fah2cel : cel2fah
}

func main() -> float
{
dir_deg(1)(100.0)
}
``````

Very interesting is function `dir_deg`. The function either returns function which converts from Celsius degrees to Fahrenheit or from Fahrenheit to Celsius degrees. As Never is strongly typed the function specifies its return type as `(float) -> float` which is the type of degree converting functions.

Functions may also take other functions as arguments.

``````func fah2cel(f : float) -> float
{
(f - 32.0) / 1.8
}

func cel2fah(c : float) -> float
{
c * 1.8 + 32.0
}

func degrees(conv(float) -> float, degree : float) -> float
{
conv(degree)
}

func main() -> float
{
degrees(cel2fah, 100.0)
}
``````

In the above example function `degrees` takes conversion function which then is given passed parameter. In the next step function value is returned. Also its parameter `conv` is strongly typed with function type.

Closures can be used to implement function composition.

``````func compose(f(i : int) -> int, g(i : int) -> int) -> (int) -> int
{
let func (i : int) -> int { f(g(i)) }
}

func dec(i : int) -> int { 10 * i }

func succ(i : int) -> int { i + 1 }

func main() -> int
{
let h = compose(dec, succ);

print(h(1));

0
}
``````

## Syntax Level

Never supports any degree of function nesting. As result it is not needed to define all functions in programs top level.

``````func dir_deg(d : int) -> (float) -> float
{
func fah2cel(f : float) -> float
{
(f - 32) / 1.8
}
func cel2fah(c : float) -> float
{
c * 1.8 + 32
};

d == 0 ? fah2cel : cel2fah
}

func main() -> float
{
dir_deg(0)(100.0)
}
``````

Functions `fah2cel` and `cel2fah` nested inside `dir_deg` are defined within syntactical level of function `dir_deg`. That means that they cannot be invoked from function `main`. Only functions and parameters which are defined above or at the same level in the structure of a program can be used.

``````func dir_deg(d : float, coeff : float) -> (float) -> float
{
func fah2cel(f : float) -> float
{
coeff * ((f - 32.0) / 1.8)
}
func cel2fah(c : float) -> float
{
coeff * (c * 1.8 + 32.0)
};

d == 0 ? cel2fah : fah2cel
}

func main() -> float
{
dir_deg(0, 100.0)(100.0)
}
``````

The above listing demonstrates how parameter `coeff` is accessed from within functions `fah2cel` or `cel2fah`. After `dir_def` is called in `main` parameter `coeff` is bound to `dir_deg` environment. This way `coeff` can be used in functions which convert temperature after `dir_deg` returns.

## Functions as Expressions

Functions in functional programming languages are also expressions. This leads to very interesting syntax which is supported by Never.

``````func degrees(conv(float) -> float, degree : float) -> float
{
conv(degree)
}

func main() -> float
{
degrees(let func rea2cel(d : float) -> float
{
d * 4.0 / 5.0
}, 100.0)
}
``````

The above listing outlines how a function `rea2cel` may be defined as a parameter being passed to function `degrees`. The function converts from Réaumur degrees to Celsius degrees.

The idea of in-lining functions may be taken into extreme...

``````func calc() -> (float) -> float
{
let func fah2cel(f : float) -> float { (f - 32.0) / 1.8 }
}

func main() -> float
{
calc()(212.0)
}
``````

... and a little step further.

``````func dir_deg(d : int) -> (float) -> float
{
d == 0 ? let func fah2cel(f : float) -> float { (f - 32.0) / 1.8 }
: let func cel2fah(c : float) -> float { c * 1.8 + 32.0 }
}

func main() -> float
{
dir_deg(0)(100.0)
}

``````

## Bindings

Functions let to define bindings with local values.

``````func area(a : float, b : float, c : float) -> float
{
let p = (a + b + c) / 2.0;
sqrt(p * (p - a) * (p - b) * (p - c))
}
``````

In comparison to function, though, they cannot be mutually recursive. Thus their values can be declared and used in their order. In the following example variables `q` and `p` are declared in correct order. When reversed compilation error will be displayed.

``````func outer(a : float, b : float) -> float
{
let q = 10.0;
let p = a + q;

p + q
}
``````

Bindings can hold any expressions. Thus the following code is also possible...

``````func outer(to : int) -> () -> int
{
let p = 2 * to;
let f = let func rec() -> int
{
p
};

f
}
``````

... or even

``````func outer(to : int) -> (int) -> int
{
let f = let func rec(start : int) -> int
{
start < to ? rec(print(start) + 1) : 0
};

f
}

func main() -> int
{
outer(10)(0)
}
``````

## Assignments and Flow Control

Writing code using just recursion if very difficult. Never lets to use control flow expressions known from other languages. These are `if`, `if else`, `while`, `do while` and `for` expressions. As these structures are expressions they also return a value. All of them, except for `if else` return `0 -> int` value. Also expression following `if` must return `int` value.

Assignment expression `=` lets to assign value of an expression on the right hand side to a value on the left hand side. Please note, that if the value on the left hand side is a temporary, assignment will be discarded.

The following examples present assignments and flow control.

``````func main() -> int
{
var n = 18;

do
{
print(n % 2);
n = n / 2
} while (n != 0)
}
``````

The above example converts value `18` into binary format.

The following code calculates divisors of a number and outlines `for` and `if` expressions. The following factorizes a number using `for` and `while` expressions.

``````func divisors(n : int) -> int
{
var i = 1;

for (i = 1; i * i <= n; i = i + 1)
{
if (n % i == 0)
{
if (n / i != i)
{
print(n / i);
print(i)
}
else
{
print(i)
}
}
}

}

func main() -> int
{
divisors(60)
}
``````
``````func factorize(n : int) -> int
{
var i = 1;

for (i = 2; i <= n; i = i + 1)
{
while (n % i == 0)
{
print(i);
n = n / i
}
}

}

func main() -> int
{
factorize(2020)
}
``````

## Arrays

Never supports arrays of any dimension. Array are also expressions and may be passed between functions. The following example declares an array and returns value of its element.

``````func f1(a : int) -> [D, D] : int
{
[ [ a, 0, 0, 0 ],
[ 0, a, 0, 0 ],
[ 0, 0, a, 0 ],
[ 0, 0, 0, a ] ] : int
}

func main() -> int
{
f1(11)[0, 0]
}
``````

Arrays may contain elements of any type. In particular these may be other arrays...

``````func call(tab[row] : [D] : int) -> int
{
tab[row - 1]
}

func f1() -> int
{
call([ [ 9, 8, 7, 6, 5 ] : int,
[ 9, 7, 5 ] : int        ] : [_] : int)
}

func main() -> int
{
f1()
}
``````

...or even functions.

``````func f1(a : int, b : int, c : int) -> [D] : () -> int
{
[
let func f1() -> int { a + b + c },
let func f2() -> int { a + b - c }
] : () -> int
}

func main() -> int
{
f1(80, 90, 100)()
}

``````

When arrays are passed to functions their dimensions are also passed as function arguments. This type of array passing type is called conformant arrays.

``````func f1(tab[row, col] : int) -> int
{
row * col
}

func main() -> int
{
f1( [ [10, 20, 30], [30, 40, 50] ] : int )
}
``````

Conformat arrays let to iterate over array elements. The following listing demonstrates how conformant arrays and tail recursion are used to determine lowest element in an array.

``````func tmin( t[elems] : int ) -> int
{
func __tmin( min : int, i : int, t[elems] : int ) -> int
{
i < elems ? __tmin( t[i] < min ? t[i] : min, i + 1, t ) : min
};
__tmin(t, 0, t)
}

func main() -> int
{
tmin( [ 20, 10, 30, 50, 40 ] : int )
}
``````

The following example presents how to pass any function which is executed over all elements of an array. This program uses arrays, first class functions and tail recursion.

``````func add_five(e : int) -> int
{
print(e + 5)
}

func tforeach( t[elems] : int, each(e : int) -> int) -> int
{
func __tforeach( val : int, i : int, t[elems] : int ) -> int
{
i < elems ? __tforeach( each(t[i]), i + 1, t ) : 0
};
__tforeach(t, 0, t)
}

func main() -> int
{
tforeach( [ 10, 20, 50, 30, 40 ] : int, add_five )
}
``````

Arrays may contain other arrays. This feature lets us to define vectors of arrays.

``````func printTab( tab[dim] : int ) -> int
{
func __printTab( val : int, i : int, tab[dim] : int ) -> int
{
i < dim ? __printTab( print(2 * tab[i]), i + 1, tab) : i
};
__printTab(0, 0, tab)
}

func print2Tab( tab[dim] : [D] : int ) -> int
{
func __print2Tab( val : int, i : int, tab[dim] : [D] : int ) -> int
{
i < dim ? __print2Tab( printTab(tab[i]), i + 1, tab ) : i
};
__print2Tab(0, 0, tab)
}

func main() -> int
{
print2Tab( [ [ 1, 2, 3, 4, 5, 6 ] : int,
[ 16, 17, 18 ] : int ] : [D] : int )
}
``````

The above code can be rewritten using `foreach` functions.

``````func twice(e : int) -> int
{
print(2 * e)
}

func foreachTab( tab[dim] : int, each(e : int) -> int ) -> int
{
func __foreachTab( val : int, i : int, tab[dim] : int ) -> int
{
i < dim ? __foreachTab( each(tab[i]), i + 1, tab) : i
};
__foreachTab(0, 0, tab)
}

func foreach2Tab( tab[dim] : [D] : int, eachTab(t[D] : int, (int) -> int) -> int, each(e : int) -> int ) -> int
{
func __foreach2Tab( val : int, i : int, tab[dim] : [D] : int ) -> int
{
i < dim ? __foreach2Tab( eachTab(tab[i], each), i + 1, tab ) : i
};
__foreach2Tab(0, 0, tab)
}

func main() -> int
{
foreach2Tab( [ [ 1, 2, 3, 4, 5, 6 ] : int,
[ 16, 17, 18 ] : int ] : [D] : int,
foreachTab, twice )
}
``````

Arrays can be used to memorize sub-problem results in dynamic programming. The following example solves rod cutting dynamic problem.

``````func max(a : int, b : int) -> int { a > b ? a : b }

func cutrod(price[P] : int, memo[M] : int, len : int) -> int
{
var i = 0;
var max_p = -1;

if (memo[len] != -1)
{
max_p = memo[len]
}
else
{
while (i < len)
{
max_p = max(max_p, price[i] + cutrod(price, memo, len - i - 1));
i = i + 1
}
};

memo[len] = max_p
}

func main() -> int
{
let price = [ 2, 7, 9, 10, 10, 14, 17, 21 ] : int;
let memo = [ 0, -1, -1, -1, -1, -1, -1, -1, -1 ] : int;

cutrod(price, memo, 8)
}
``````

## Array Operators

Never lets to add, subtract and multiply int and float arrays.

``````func main() -> int
{
printtab( 2 * [ 3, 5, 7, 9 ] : int )
}
``````
``````func main() -> int
{
printtab( - [ 1, -2, 3, -4, 5, -6 ] : int )
}
``````
``````func main() -> int
{
printtab( [ 3.5, 5.5, 7.5 ] : float - [ 3.0, 4.0, 7.0 ] : float )
}
``````
``````func main() -> int
{
printtab( [ 1.5, 2.5, 3.5 ] : float + [ 3.0, 4.0, 7.0 ] : float )
}
``````
``````func main() -> int
{
printtab( [ [ 1.0, 2.0, 3.0 ],
[ 3.0, 4.0, 5.0 ] ] : float
*
[ [ 3.0, 4.0, 1.0, 1.0 ],
[ 6.0, 7.0, 1.0, 1.0 ],
[ 8.0, 2.0, 1.0, 1.0 ] ] : float )
}
``````

## Ranges and Slices

Writing loops over arrays requires creating an index which is incremented in every loop iteration. Such code is so common that Never supports syntactic sugar which improves this task.

``````
func pr_range( r[from..to] : range ) -> int
{
prints("[" + from + ".." + to +"]\n");
0
}

func sl_range( r[from..to] : range ) -> int
{
pr_range( r );
pr_range( r[to..from] );
0
}

func main() -> int
{
let r = [ 0 .. 100 ];

sl_range(r);

0
}
``````

Ranges specify continous numers starting from first to including the last index. Ranges can also be multidimensional. The above listing presents a range from 0 to 100. The range is printed in `pr_range` function. Ranges can also be restricted to its subrange. Function `sl_range` restricts range `r` from its last to first value and thus reverses it.

``````func main() -> int
{
let a = [ 1, 2, 3, 4, 5, 6 ] : int;
let s = a[5 .. 1];

for (i in s)
{
print(i)
}
}
``````

Ranges can also be used to specify a slice of an array.

``````func main() -> int
{
let str1 = "Hello World!";
let str2 = "!dlroW olleH";

prints(str1[length(str1) - 1 .. 0] + "\n");

0
}
``````

Slices can also be used to extract a string substring. As slices are Never first class citizens they can be created, passed or returned by functions. Is is also possible to use list comprehension to create them.

``````record R { x : int; y : int; }

func pr( a[D] : R ) -> int
{
for ( i in [ 0 .. D - 1 ] )
{
prints(a[i].x + " " + a[i].y + "\n")
}
}

func main() -> int
{
let a = [ R(x, y) | x in [ 0 .. 5 ]; y in [ 0 .. x ] ] : R;

pr(a);

0
}
``````

Ranges and slices can also be part of records or enumerated records.

``````enum E {
S,
R { x : int; a[D] : int; [from .. to] : range; s [ from_s .. to_s ] : string; }
}

func pr_array( a[D] : int ) -> int
{
for (e in a)
{
print(e)
}
}

func pr_range( [ from .. to ] : range ) -> int
{
print(from);
print(to);

0
}

func pr_R( e : E ) -> int
{
if let (E::R(x, a, r, s) = e)
{
print(x);

pr_array(a);
pr_range(r);

for (e in s)
{
prints(e + "\n")
}
};

0
}

func main() -> int
{
let ai = [ 1, 2, 3, 4 ] : int;
let as = [ "zero", "one", "two", "three", "four", "five", "six" ] : string;
let r = E::R(1, ai, [ 10 .. 200 ], as[ 1 .. 3 ]);

pr_R(r);

0
}
``````

## List Comprehension

Never supports list comprehension. Each list consists of a series of generators and filers and expression which yields list elements.

``````func cl() -> [_] : int
{
[ x * x | x in [10, 20, 30, 40, 50] : int ] : int
}
``````

The following example presents both generators and filters.

``````func cl() -> [_] : int
{
[ x * x | x in [1, 2, 3, 4, 5, 6, 7, 8] : int; (x * x % 2) == 0 ] : int
}
``````

List comprehension may also invoke other functions.

``````func cl() -> [_] : float
{
func grad(d : float) -> float
{
d * 2.0 * 3.14159265 / 360.0
};

[ f(y) | f in [ sin, cos ] : (float) -> float;
}
``````

or even return list of closures.

``````func cl() -> [_] : (float) -> float
{
func grad(d : float) -> float
{
d * 2.0 * 3.14159265 / 360.0
};

[ g | f in [ sin, cos ] : (float) -> float;
g in [ let func(x : float) -> float { f(grad(x)) } ] : (float) -> float ] : (float) -> float
}
``````

The following code snippets present other examples:

``````func decor(str : string) -> string
{
"###" + str + "###\n"
}

func main() -> int
{
var i = 0;
var texts = [ "one", "two", "three" ] : string;
var decors = [ decor(txt) | txt in texts ] : string;

for (i = 0; i < 3; i = i + 1)
{
prints(decors[i])
};

0
}
``````
``````###one###
###two###
###three###
0
``````
``````func main() -> int
{
var i = 0;
var texts = [ "one", "two", "three" ] : string;
var decors = [ let func () -> int
{
prints("###" + txt + "###\n");
0
}
| txt in texts
] : () -> int;

for (i = 0; i < 3; i = i + 1)
{
decors[i]()
};

0
}
``````
``````###one###
###two###
###three###
0
``````
``````func main() -> int
{
var i = 0;
var texts = [ "one", "two", "three" ] : string;
var decors = [ let func (d : string) -> int
{
prints(d + txt + d + "\n");
0
}
| txt in texts
] : (string) -> int;

for (i = 0; i < 3; i = i + 1)
{
decors[i]("#@#")
};

0
}
``````
``````#@#one#@#
#@#two#@#
#@#three#@#
0
``````

## Enums

``````enum EONE { one, two, three, four, five }

enum ETWO { one, two, three, four, five }

func g1() -> EONE
{
EONE::four
}

func e1(a : EONE, b : EONE) -> string
{
if (a == g1())
{
prints("OK\n")
}
else
{
prints("NOK\n")
}
}

func main() -> int
{
prints(e1(EONE::four, EONE::three));

0
}
``````

Enums are first class objects in Never. The above example presents how they can be defined and used. Enums can also be used in match expression to convert their values. Match expression is exhaustive which means that all possibile enum values should be covered.

``````func main() -> int
{
match EONE.five
{
E.one -> 1;
E.two -> 2;
E.three -> 3;
else -> 4;
}
}
``````

Enum values can also be converted to integers, thus they let to define named constants.

``````enum E { ONE = 0,
TWO = E::ONE + 1,
THREE = E::TWO + 1,
FOUR = E::THREE + 1 }

let t = [ 1, 2, 3, 4, 5 ] : int;

func main() -> int
{
assert(t[E::ONE] == 1);
assert(t[E::TWO] == 2);
assert(t[E::THREE] == 3);
assert(t[E::FOUR] == 4);

0
}
``````

## Records

``````record Tree
{
value : int;
left : Tree;
right : Tree;
print(t : Tree) -> int;
}

func print_tree(t : Tree) -> int
{
prints("tree value = " + t.value + "\n");

if (t.left != nil)
{
t.left.print(t.left)
};
if (t.right != nil)
{
t.right.print(t.right)
};

0
}

func main() -> int
{
var t1 = Tree(10, nil, nil, print_tree);
var t2 = Tree(200, nil, nil, print_tree);
var t0 = Tree(100, t1, t2, print_tree);

t0.print(t0);

0
}
``````

Writing programs with only `int` and `float` types may be difficult. More complex data types are needed which can facilitate creation of programs. Never supports `record` type which can hold other types. Both simple such as `int`, `float`, function or table as well as complex data types.

The above example shows `Tree` record which holds value, references to other records and function. In the `main` three records are initialized. and then function `print` is used to recursively print the tree.

## Enumerated Records

Enum type can also hold one of possible record values. Such type lets to define convenient optional values, error codes or recursive data types.

``````enum Optional { Some { value : int; }, None }

func calc() -> Optional
{
Optional::Some(10)
}

func main() -> int
{
match calc()
{
Optional::Some(value) -> print(value);
Optional::None -> print(0);
};

0
}
``````
``````enum Result { Ok { value : int; }, Err { msg : string; } }

func div(n : int, d : int) -> Result
{
if (d != 0)
{
Result::Ok(n / d)
}
else
{
Result::Err("division by zero")
}
}

func main() -> int
{
match div(10, 0)
{
Result::Ok(value) -> print(value);
Result::Err(msg) -> { prints(msg + "\n"); 0 };
};

0
}
``````
``````enum Tree { Node { value : int; left : Tree; right : Tree; }, None }

func printTree(tree : Tree) -> int
{
match (tree)
{
Tree::Node(value, left, right) -> {
printTree(left);
print(value);
printTree(right);
0
};
Tree::None -> 0;
}
}

func main() -> int
{
let tree = Tree::Node(40,
Tree::Node(20, Tree::None,
Tree::Node(30, Tree::None, Tree::None)),
Tree::Node(60, Tree::None, Tree::None));

printTree(tree);

0
}
``````

It may be difficult to enumerate all possible match guards. To check for just one value and assign its value it is useful to use `if let` expression.

``````enum Optional { Some{ value : int; }, Other, None }

func getF(o : Optional) -> () -> int
{
if let ( Optional::Some(value) = o)
{
let func() -> int { value }
}
else
{
let func() -> int { 1000 }
}
}

func main() -> int
{
let o = Optional::Some(10);

getF(o)();

0
}
``````

As `if let` is an expression it can be used to initalize variables.

``````enum Result { Ok { value : int; }, Err { msg : string; } }

func calc() -> Result
{
Result::Ok(1)
}

func main() -> int
{
let i = if let (Result::Ok(value) = calc())
{
value
}
else
{
90
};

print(i);

0
}
``````

Enumerated records can be used to create variant type which accepts values of different types.

``````enum Variant { Int { value : int; },
Float { value : float; },
Char { value : char; },
String { value : string; } }

func printv ( v : Variant ) -> Variant
{
match (v)
{
Variant::Int(value) -> { print(value); v };
Variant::Float(value) -> { printf(value); v };
Variant::Char(value) -> { printc(value); v };
Variant::String(value) -> { prints(value); v };
}
}

func main() -> int
{
let i = 10;
let f = 10.0;
let c = 'A';

printv(Variant::Int(i));
printv(Variant::Float(f));
printv(Variant::Char(c));
printv(Variant::String("ten"));

0
}
``````

## Mathematical Functions

Never supports a few built-in mathematical functions - `sin(x)`, `cos(x)`, `tan(x)`, `exp(x)`, `log(x)`, `sqrt(x)` and `pow(x,y)`. These functions are also first class so they may be passed in between functions as any other function.

``````func deg2rad(deg : float) -> float
{
deg * 3.14159 / 180
}

func get_func() -> (float) -> float
{
cos
}

func main() -> float
{
}
``````

Together with arrays mathematical functions can be used to express and calculate vector rotations. Code snippet included below rotates vector `[[ 10.0, 0.0 ]]` by 0, 45, 90, 180, 270 and 360 degrees.

``````func print_vect(vect[D1, D2] : float) -> int
{
printf(vect[0, 0]);
printf(vect[0, 1]);
0
}

func rotate_matrix(alpha : float) -> [_,_] : float
{
[ [ cos(alpha), -sin(alpha) ],
[ sin(alpha), cos(alpha)  ] ] : float
}

func main() -> int
{
let vect = [[ 10.0, 0.0 ]] : float;

print_vect(vect * rotate_matrix(0.0));
print_vect(vect * rotate_matrix(3.14159 / 4.0));
print_vect(vect * rotate_matrix(3.14159 / 2.0));
print_vect(vect * rotate_matrix(3.14159));
print_vect(vect * rotate_matrix(3.0 * 3.14159 / 2.0));
print_vect(vect * rotate_matrix(2.0 * 3.14159))
}
``````

## Exceptions

During program execution some operations may fail. One well known example of them is division by zero. Another one is dereferencing array out of its bounds. A well written program should handle such situations and respond in another way.

Never can handle internal errors using exceptions handlers specified after every function. Such handlers can execute arbitrary code. If an exception happens inside exception handler it replaces exception being processed.

The following code shows how exception `invalid_domain` raised when negative parameter passed to `sqrt` function is passed.

``````func main() -> int
{
sqrt(-1)
}
catch (invalid_domain)
{
-1
}
``````

Exception need not be processed in the same function where they occurred. They are passed down call stack. First function which defines exception handler is used. Also any exception can be caught by parameterless exception handler.

``````func three(d : int, c : int) -> int
{
var t = [ 1, 2, 3 ] : int;

t = d;
170 / d
}

func two(d : int) -> int
{
three(d, 199)
}
catch (wrong_array_size)
{
0
}
catch (index_out_of_bounds)
{
d + 102
}

func one(d : int) -> int
{
two(d)
}

func main() -> int
{
one(0)
}
catch (division_by_zero)
{
155
}
``````

In the above example exception division by zero is caught by handler defined in function `main`. If index out of bound was raised it would be caught by exception handler defined in function `two`. Please also note that exception handlers can access function parameters. All bindings and nested functions are not accessible.

## Modules

Never programs can be separated into serveral modules. Modules can include all Never declarations - bindings, functions, enums, record, enumerated records.

``````module mone
{
func one() -> int
{
1
}
}
``````
``````module mtwo
{
func two() -> int
{
2
}
}
``````
``````use mone
use mtwo

func main() -> int
{
mone.one() + mtwo.two()
}

``````

Never modules are searched in the `NEVER_PATH` environment variable from the first to the last directory. First found module is used.

``````export NEVER_PATH=.:/usr/local/share/never-lib:/home/smaludzi/never-lib
``````

## Console Output

Never implements simple `print(int x) -> int` and `printf(float x) -> float` functions. The function writes an integer or float parameter `x` (with a new line character) to standard output and returns passed value. By default `printf` uses `"%.2f\n"` formatting.

``````func main() -> float
{
printf(123.456)
}
``````

It is also possible to print string of characters.

``````func main() -> int
{
let txt = "answer is ";
let value = 200;

prints(txt + str(value) + "\n");

0
}
``````

They may be concatenated with integers or floats.

``````func print_vect(vect[D1, D2] : float) -> int
{
prints("[" + vect[0, 0] + "," + vect[0, 1] + "]\n");
0
}
``````

String can also be assigned and compared.

``````func main() -> int
{
var s1 = "string one\n";
var s2 = "text two\n";

prints(s1);
prints(s2);

s2 = s1;

prints(s2);

0
}
``````
``````func main() -> int
{
let s1 = "text equal";
let s2 = "text equal";

assert((if (s1 == s2) { 1 } else { 0 }) == 1);

0
}
``````

## Embedded Never

Never language can be embedded in Unix shell and C code.

### Shell

``````#!/usr/bin/nev

func add(a : int, b : int, c : int) -> int
{
a + b + c
}

func main(a : int, b : int) -> int
{
}

``````

After adding `#!/usr/bin/nev` to the script first line and setting script as executable it is possible to run a program without specifying interpreter name. Then a script is executed from command line with additional parameters.

``````\$ ./sample81.nevs 10 20
result is 31
``````

Also nev can be executed with `-e` parameter followed by program.

### C language

``````#include <stdio.h>
#include <assert.h>
#include "nev.h"

void test_one()
{
int ret = 0;
program * prog = program_new();
const char * prog_str =
"func on_event(x : int, y : int) -> int { 10 * (x + y) }";

ret = nev_compile_str(prog_str, prog);
if (ret == 0)
{
object result = { 0 };
vm * machine = vm_new(DEFAULT_VM_MEM_SIZE, DEFAULT_VM_STACK_SIZE);

ret = nev_prepare(prog, "on_event");
if (ret == 0)
{
prog->params.int_value = 1;
prog->params.int_value = 2;

ret = nev_execute(prog, machine, &result);
if (ret == 0)
{
assert(result.type == OBJECT_INT && result.int_value == 30);
}

prog->params.int_value = 10;
prog->params.int_value = 20;

ret = nev_execute(prog, machine, &result);
if (ret == 0)
{
assert(result.type == OBJECT_INT && result.int_value == 300);
}
}

vm_delete(machine);
}

program_delete(prog);
}
``````

The above code present how Never can be embedded into C code. First `nev.h` header is included. Then a new program `prog` is created and parsed with `nev_compile_str` function. After program is compiled an entry function is chosen with `nev_prepare` function. Usually it is `main` function but in this example `on_event` is used. In the next step, parameters are set to values. Please note that the program can be executed with different input parameters many times. Return value is set in `result` object which then can be used. In this example `assert` function assures that calculations are as expected.

### Foreign Function Interface

Never can also invoke functions in dynamically loaded libraries. The following code snippets demonstrate how to invoke function in math and system libraries. Right now only basic types can be passed.

``````extern "libm.so.6" func sinhf(x : float) -> float
extern "libm.so.6" func coshf(x : float) -> float
extern "libm.so.6" func powf(base : float, exp : float) -> float
extern "libm.so.6" func atanf(x : float) -> float

func main() -> int
{
var v1 = sinhf(1.0);
var v2 = coshf(1.0);
var v3 = powf(10.0, 2.0);
var pi = 4.0 * atanf(1.0);

printf(v1);
printf(v2);
printf(v3);
printf(pi);
printf(sinhf(1.0));

0
}
``````
``````func main() -> int
{
var system = let extern "libc.so.6" func system(cmd : string) -> float;
var v = system("uname -a");

0
}
``````