Added reference docs

Author: muit

.gitignore

@@ -3,4 +3,5 @@ package-lock.json
 public
 resources
 .netlify
-.hugo_build.lock
+.hugo_build.lock
+package-lock.json

config/_default/menus/menus.en.toml

@@ -50,7 +50,7 @@
 
 [[main]]
   name = "Docs"
-  url = "/docs/prologue/introduction/"
+  url = "/docs/quick-start/introduction/"
   weight = 50
 
 [[main]]

content/docs/reference/_index.md

@@ -0,0 +1,8 @@
+---
+title : "Reference"
+description: ""
+lead: ""
+draft: false
+images: []
+weight: 150
+---

content/docs/reference/binary-operators.md

@@ -0,0 +1,32 @@
+---
+title: "Binary Operators"
+draft: false
+toc: true
+---
+
+Binary operators operate two values to obtain a third one.
+
+| Symbol | Name | Nodes | Code |
+| --- | --- | --- | --- |
+|  |  | 
+| **Mathematic** |  |
+| + | Add | | |
+| - | Subtract |
+| * | Multiply |
+| / | Divide |
+| % | Module |
+|  |  |
+| **Comparisons** |  |
+| == | Equal |
+| != | Not Equal |
+| > | Greater |
+| < | Less |
+| >= ≥ | Greater or Equal |
+| <= ≤ | Less or Equal |
+|  |  |
+| **Logical** |  |
+| && | and |
+| \|\| | or |
+| & | bitwise and |
+| \| | bitwise or |
+| ^ | exclusive or (xor) |

content/docs/reference/classes.md

@@ -0,0 +1,9 @@
+---
+title: "Classes"
+draft: false
+toc: true
+---
+
+A class is a data type that contains [variables](../variables) and [functions](../functions).
+
+A class’s [variables](../variables) and [functions](../functions) must have unique names inside the same class.

content/docs/reference/functions.md

@@ -0,0 +1,98 @@
+---
+title: "Functions"
+draft: false
+toc: true
+---
+
+## Arguments
+
+Functions can have multiple input arguments.
+
+Functions can also have multiple output arguments.
+
+
+## Definitions
+
+<details>
+  <summary>Nodes</summary>
+
+</details>
+
+<details>
+  <summary>Code</summary>
+
+  ```ruby
+  FillZero(U32 color) {} # An argument value
+  FillOne(U32 size, U32 color = 0) {} # Multiple argument values
+  FillTwo() -> Bool {} # A return value
+  FillThree() -> Bool, S32 { # Multiple return values
+   return true, 2;
+  }
+  FillFour() -> Bool valid, S32 count { # Multiple named return values
+   valid = true;
+   count = 2; # All named values without a default must be assigned before return.
+  }
+
+  FillFive(U32 color = 0) {} # Default argument values
+  FillSix(U32 color) -> Bool=false {} # Default return values
+  FillSeven() -> Bool=true, S32=undefined {} # Multiple return values with defaults
+  FillEight() -> Bool valid=true, S32 count {} # Named returns with defaults
+  ```
+</details>
+
+
+## Calls
+
+<details>
+  <summary>Nodes</summary>
+
+</details>
+
+<details>
+  <summary>Code</summary>
+
+  ```ruby
+  FillZero(); # Error, argument must be provided
+  FillZero(0);
+  FillOne(0); # color is set by default to 0
+  FillOne(0, 0);
+  FillOne(size = 1); # Set an argument by name
+  FillOne(0, color = 1);
+  FillOne(size = 1, 0); # ERROR: Named arguments must be at the end of the called function.
+  FillOne(color = 0, size = 1); # Set multiple arguments by name
+
+  Bool result = FillTwo();
+  [Bool result, S32 count] = FillThree(); # Define and assign returns
+
+  Bool result; S32 count;
+  [result, count] = FillThree(); # Assigning a value to existing variables
+  [result, count] = FillFour(); # Named return values are returned in order
+
+  [result, count] = FillThree(); # Named return values are returned in order
+  ```
+</details>
+
+
+## Member Functions
+
+<details>
+  <summary>Nodes</summary>
+
+</details>
+
+<details>
+  <summary>Code</summary>
+
+  ```ruby
+  Type one;
+  one.DoSomething();
+
+  Type* ptr = &one;
+  ptr->DoSomething();
+  ```
+</details>
+
+
+## Properties
+
+Functions can be marked with different properties to change their behavior.

content/docs/reference/modules.md

@@ -0,0 +1,21 @@
+---
+title: "Modules"
+draft: false
+toc: true
+---
+
+A module is constituted by a folder that contains a module file (with *.rift* format).
+
+Any type files (*.rf* format) inside this folder or its subfolders are considered part of that module and will be compiled together.
+
+## Submodules
+If the subfolder of a module contains its own module file, this folder and all its files will be considered its own module.
+
+## Exporting
+By default **functions, types, and variables of a module are exported** for other modules to use.
+
+## Dependencies
+A module can have dependencies to other modules, granting it access to their code. Dependencies can be either Private or Public as it is explained later.
+
+## Target types
+The target type defines if a module will be compiled into an executable, a static library, or a dynamic library.

content/docs/reference/statics.md

@@ -0,0 +1,9 @@
+---
+title: "Statics"
+draft: false
+toc: true
+---
+
+An static type contains one or more static [functions](../functions), an static function being as function that can be called globally without being part of a class.
+
+[Functions](../functions) must have unique names inside the same function library.

content/docs/reference/structs.md

@@ -0,0 +1,11 @@
+---
+title: "Structs"
+draft: false
+toc: true
+---
+
+A struct is a data type that only contains [variables](../variables).
+
+Structs don't have "constructors" but can be initialized with parameter values.
+
+Structs are passed by copy by default.

content/docs/reference/variables.md

@@ -0,0 +1,58 @@
+---
+title: "Variables"
+draft: false
+toc: true
+---
+
+A variable is a block of memory containing an struct, a class, a native type, pointers or function pointers.
+
+## Initialization
+
+Variables are always default-initialized unless marked as **undefined** which keeps the memory as it was before initialization (garbage memory).
+
+<details>
+  <summary>Nodes</summary>
+
+</details>
+
+<details>
+  <summary>Code</summary>
+
+  ```ruby
+  struct Type
+  {
+      Bool alive;
+      Bool running;
+  }
+
+  void main()
+  {
+      Type one; // Default initialized
+      Type two = undefined; // Not initialized (garbage)
+      Type three(true); // 'alive' set to true
+      Type four(running=true); // 'running' set to true
+
+      Type five = four; // Copy four into five
+      Type six := four; // Move four into six
+      Type* seven = &six; // Seven is pointer to four
+  }
+  ```
+</details>
+
+## Member Variables
+<details>
+  <summary>Nodes</summary>
+
+</details>
+
+<details>
+  <summary>Code</summary>
+
+  ```ruby
+  Type one;
+  one.alive = true;
+
+  Type* ptr = &one;
+  ptr->alive = false;
+  ```
+</details>