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
|
<!-- # mana
Interpreted Toy Programming Language written in Go -->
# Mana
Mana is a toy programming language written in Go. It is a dynamically typed, interpreted language with a C-like syntax.
> *Note*: The language is still in development and is not yet usable. The documentation below is a work in progress and is subject to change.
## Development Roadmap
| Implementation | Status | Specification | Example | Tests |
| --- | --- | --- | --- | --- |
| `LetStatement` | ✔️ | Let Statements are used to declare variables | `let x = 5;` | ✔️ |
| `ReturnStatement` | ✔️ | Return Statements are used to return values from functions | `return 5;` | ✔️ |
| `ExpressionStatement` | ✔️ | Expression Statements are used to evaluate expressions | `5 + 5;` | ✔️ |
| `IdentifierExpression` | ✔️ | Identifier Expressions are used to reference variables | `x` | ✔️ |
| `IntegerLiteralExpression` | ✔️ | Integer Literal Expressions are used to represent integer values | `5` | ✔️ |
| `PrefixExpression` | ✔️ | Prefix Expressions are used to represent prefix operators | `!true` | ✔️ |
| `InfixExpression` | ✔️ | Infix Expressions are used to represent infix operators | `5 + 5` | ✔️ |
| `BooleanLiteralExpression` | ✔️ | Boolean Literal Expressions are used to represent boolean values | `true` | ✔️ |
| `IfExpression` | ✔️ | If Expressions are used to represent conditional statements | `if (true) { return 5; }` | ✔️ |
| `BlockStatement` | ✔️ | Block Statements are used to represent blocks of code | `{ let x = 5; return x; }` | ✔️ |
| `FunctionLiteralExpression` | ✔️ | Function Literal Expressions are used to represent function definitions | `fn(x) { return x; }` | ✔️ |
| `CallExpression` | NYI | Call Expressions are used to call functions | `add(5, 5)` | NYI |
| `StringLiteralExpression` | NYI | String Literal Expressions are used to represent string values | `"Hello, World!"` | NYI |
| `ArrayLiteralExpression` | NYI | Array Literal Expressions are used to represent array values | `[1, 2, 3]` | NYI |
| `IndexExpression` | NYI | Index Expressions are used to index into arrays | `myArray[0]` | NYI |
| `HashLiteralExpression` | NYI | Hash Literal Expressions are used to represent hash values | `{"key": "value"}` | NYI |
\**NYI = Not Yet Implemented*
## REPL
Mana will come with a REPL (Read-Eval-Print-Loop) that can be used to evaluate Mana code.
> *Note*: The REPL is still in development and is not yet usable. Currently, it can only parse and print the AST of the input code.
## Syntax
Mana has a C-like syntax. The following is an example of a simple program written in Mana:
```rust
let x = 5; // declare a variable named x and assign it the value 5
let y = 10; // declare a variable named y and assign it the value 10
// this is a function that adds two numbers together
let add = fn(x, y) {
return x + y;
};
// this is an alternative way to create a function
fn subtract(x, y) {
return x - y;
}
// this will either add x and y if x is less than y, or return the difference between x and y
let result = if (x < y) {
add(x, y)
} else {
subtract(x, y)
}; // result = 15
```
## Types
Mana is a dynamically typed language. This means that the type of a variable is determined at runtime. The following are the types that Mana supports:
| Type | Description | Example |
| --- | --- | --- |
| `Integer` | A 64-bit signed integer | `5` |
| `Boolean` | A boolean value | `true` |
## Operators
Mana supports the following operators:
| Operator | Description | Example |
| --- | --- | --- |
| `+` | Addition | `5 + 5` |
| `-` | Subtraction | `5 - 5` |
| `*` | Multiplication | `5 * 5` |
| `/` | Division | `5 / 5` |
| `!` | Logical NOT | `!true` |
| `<` | Less Than | `5 < 5` |
| `>` | Greater Than | `5 > 5` |
| `==` | Equal To | `5 == 5` |
| `!=` | Not Equal To | `5 != 5` |
## Functions
Mana supports first-class functions. This means that functions can be passed as arguments to other functions, returned from functions, and assigned to variables. The following is an example of a function definition in Mana.
Functions are defined using the `fn` keyword. The function name is followed by a list of parameters in parentheses. The function body is enclosed in curly braces. The function body is a `BlockStatement`, which means that it is a list of statements enclosed in curly braces. The last statement in the function body is the `return` statement, which is used to return a value from the function. Functions, themselves, are `ExpressionStatements`, which means that they evaluate to a value. The value that a function evaluates to is the value that is returned from the function.
```rust
fn add(x, y) {
return x + y;
}
```
## Conditionals
Mana supports If-Else conditionals. An `IfExpression` in Mana is composed of two parts: the condition and the consequence. The condition is an expression that evaluates to a boolean value. The consequence is a `BlockStatement` that is executed if the condition evaluates to `true`. The consequence is optional. If the condition evaluates to `false` and there is no consequence, then the `IfExpression` evaluates to `null`. If there is a consequence, then the `IfExpression` evaluates to the value of the last statement in the consequence.
```rust
if (x < y) {
x + y;
} else {
x - y;
}
```
## Variables
Variables are declared using the `let` keyword. The variable name is followed by an equals sign and an expression. The expression is evaluated and the result is assigned to the variable.
```rust
let x = 5;
```
## License
This project is licensed under the Apache License 2.0 - see the [LICENSE](LICENSE) file for details.
|
