nessa-language 0.9.1

An extensible programming language with a strong type system
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

Let's now see how you can define operators and operations in Nessa. The process is always to define the operator and then the operations,
so the sections will follow that order. 

## How precedence works


Precedence is an **unique integer** that tells the interpreter the order in which it has to read operators. Let's take this expression for example:

```
let n = 2 + 3 * 4;
```

Is `a` equal to `2 + (3 * 4)` or `(2 + 3) * 4`? In this case it is obvious that the first option is correct, but this might not be as obvious with
other operators. We make the interpreter read that expression properly by setting a **lower** precedence on the `*` operator compared to `+`. This 
idea can also be naturally be extended to every other type of operator supported by Nessa.

## Prefix


You can define a prefix operator using the following syntax:

```
unary prefix op "operator_repr" (precedence);
```

Operations are defined as follows:

```
// Simple
op operator_repr (arg_name: Type) -> Return_type {
    [...]
}

// With generics
op<T> operator_repr (arg_name: Type) -> Return_type {
    [...]
}

// Simple usage
let var_1 = operator_repr expression;

// Generic usage
let var_2 = operator_repr<Type> expression;
``` 

## Postfix


You can define a postfix operator using the following syntax:

```
unary postfix op "operator_repr" (precedence);
```

Operations are defined as follows:

```
// Simple
op (arg_name: Type) operator_repr -> Return_type {
    [...]
}

// With generics
op<T> (arg_name: Type) operator_repr -> Return_type {
    [...]
}

// Simple usage
let var_1 = expression operator_repr;

// Generic usage
let var_2 = expression <Type>operator_repr;
``` 

## Binary


You can define a binary operator using the following syntax:

```
binary op "operator_repr" (precedence);
```

Alternatively, you can create a right-associative operator using the `right` keyword: 

```
binary right op "operator_repr" (precedence);
```

Operations are defined as follows:

```
// Simple
op (arg_name_left: Type_left) operator_repr (arg_name_right: Type_right) -> Return_type {
    [...]
}

// With generics
op<T> (arg_name_left: Type_left) operator_repr (arg_name_right: Type_right) -> Return_type {
    [...]
}

// Simple usage
let var_1 = expression operator_repr expression;

// Generic usage
let var_2 = expression <Type>operator_repr expression;
``` 

## N-ary


You can define a nary operator using the following syntax:

```
nary op from "open_repr" to "close_repr" (precedence);
```

Operations are defined as follows:

```
// Simple
op (arg: Type) open_repr arg_1: Type_1, arg_2: Type_2, ... open_repr -> Return_type {
    [...]
}

// With generics
op<T> (arg: Type) open_repr arg_1: Type_1, arg_2: Type_2, ... open_repr -> Return_type {
    [...]
}

// Simple usage
let var_1 = expression open_repr expression_1, expression_2, ... close_repr;

// Generic usage
let var_2 = expression <Type>open_repr expression_1, expression_2, ... close_repr;
```