Language Reference: Update syntax changes

Author: lumi2021

docs/language/03-language_reference/02-types/02-general.mdx

@@ -8,16 +8,14 @@ numerical values or create type encapsulation.
 
 ---
 ## Booleans
-:::not-implemented
-:::
 
 Booleans are types that can only represent the binary values `true` or `false`.
 These two values are extremely important to handle conditionals or hold simple
 states without messing the values.
 
-| Alias | Size            | Implementation         |
-|-------|:---------------:|:----------------------:|
-| bool  | 1-bit           | [Std.Types.Boolean](#) |
+| Alias | Size            |
+|-------|:---------------:|
+| bool  | 1-bit           |
 
 ```abs
 let bool cake = false
@@ -31,17 +29,15 @@ The cake is a lie!
 
 ---
 ## Strings
-:::not-implemented
-:::
 
 A string is a data structure that is able to store text data. A string can be
 used to store and reproduce text characters easily. \
 In Abstract, every string is encoded in UTF-8, with characters varying from 1-4
 bytes in length.
 
-| Alias  | Size                                            | Implementation         |
-|--------|:-----------------------------------------------:|:----------------------:|
-| string | variable (content is heap/statically-allocated) | [Std.Types.String](#)  |
+| Alias  | Size                                            |
+|--------|:-----------------------------------------------:|
+| string | variable (content is heap/statically-allocated) |
 
 
 ```abs

docs/language/03-language_reference/02-types/04-structures/01-packets.mdx

@@ -16,11 +16,11 @@ have full controll of the layout of all the bits stored on it.
 Packets can be implemented as structs, using the `@packed` attribute as following:
 ```abs
 @packed(8) struct MyDinner {
-	bool hasFork
-	bool hasSpoon
-	bool hasKnife
-	bool hasPlate
-	u4 hungerLevel
+	@public let bool hasFork
+	@public let bool hasSpoon
+	@public let bool hasKnife
+	@public let bool hasPlate
+	@public let u4 hungerLevel
 }
 ```
 

docs/language/03-language_reference/02-types/04-structures/README.md

@@ -38,6 +38,8 @@ to know the type of the structure anywhere during runtime.
 
 ---
 ### Constructors
+:::not-implemented
+:::
 
 Sometimes, is usefull to have a single function to abstract complex initialization of data.
 for instance, take the following structure declaration example:

docs/language/03-language_reference/04-conditionals.mdx

@@ -2,8 +2,6 @@
 
 :::under-construction
 :::
-:::not-implemented
-:::
 
 Conditionals are a important aspect of a program, allowing it to do specific behaviors with specific inputs.
 
@@ -103,6 +101,8 @@ else {
 
 ---
 ## Match
+:::not-implemented
+:::
 
 A easier way to do collections of if - elif's
 
@@ -139,8 +139,10 @@ let i32 by2 = match value {
 
 ---
 ## Switch
+:::not-implemented
+:::
 
-Most complex way of controll of code process \
+Most complex way of controll of process flow \
 switches manipulates groups of cases and conditions
 
 Switches allows any condition evaluation \

docs/language/03-language_reference/05-loops.mdx

@@ -8,40 +8,49 @@ until some condition is reached. Bellow are the loop types that abstract support
 
 ---
 ## While loops
-:::not-implemented
-:::
 
 While loops are the most basic loop types. It while it conditional is valid or
 the code reaches a breakpoint.
 
-This is the structure of a while syntax:
+These are the possibilities for the while statement syntax:
 ```abs
-while <condition> => <instruction>
+while <condition> do <instruction>
+while <condition> : <step> do <instruction>
+while <declaration> : <condition> : <step> do <instruction>
 ```
+`declaration` - Context variables that will be accessible inside the loop
+`condition` - The boolean value that will be tested before each iteration. The loop will continue running while this is true
+`step` - A process to be executed after each loop iteration
+`instruction` - what the loop should do every iteration
 
-While loops do not have iterators, so in this cse we must create our own:
-```abs
-let index = 10
-while index > 0 => {
+While loops are the most common way to do repetitive tasks in Abstract. it behave both like while and for loops in
+the majority of other languages.
+
+```c title="In C"
+for (var i = 0; i < 5; i++) {
+	puts("Hello, Scopped World!")
+}
+puts("Loop break")
+```
+```abs title="In Abstract"
+while let i = 0 : index < 5 : i++ do {
 	Std.Console.log("Hello, Scopped World!")
-	index -= 2
 }
-Std.Console.writeln(index)
+Std.Console.log("Loop break")
 ```
 ```text title="Console Output"
 Hello, Scopped World!
 Hello, Scopped World!
 Hello, Scopped World!
 Hello, Scopped World!
 Hello, Scopped World!
-0
+Loop break
 ```
 
-Using a `break` statement, it is possible to stop the loop before it has reached
-it condition:
+Using a `break` statement, it is possible to stop the loop before its condition fails:
 ```abs
 let index = 10
-while index >= 0 => {
+while index >= 0 do {
 	Std.Console.log("Hello, Scopped World!")
 	index -= 2
 
@@ -62,7 +71,7 @@ after each iteration:
 ```abs
 # Parenthesis are optional, but helps to read!
 let index = 0
-while (index < 10) : (index++) => Std.Console.log("Hello, World!")
+while (index < 10) : (index++) do Std.Console.log("Hello, World!")
 ```
 
 ---
@@ -76,14 +85,14 @@ while (index < 10) : (index++) => Std.Console.log("Hello, World!")
 from Std.Console import
 
 # Looping from 0 to 49
-for i in ..50 => writeln(i)
+for i in ..50 do writeln(i)
 
 # Looping from 0 to 50 in steps of 10
-for i in ..50:10 => writeln(i)
+for i in ..50:10 do writeln(i)
 
 # Looping though each element of a array
 let []byte numbers = [22, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43]
-for v in numbers => {
+for v in numbers do {
 	write("Example of a prime number:")
 	writeln(v)
 }

src/theme/prism-aditional-langs/abs.js

@@ -4,7 +4,7 @@ Prism.languages.abs = {
 		greedy: true
 	},
 
-	'keyword': /\b(import|from|func|struct|typedef|match|switch|case|enum|default|let|const|new|destroy|Flag|as|in|by|for|while|break|if|elif|else|and|or|try|catch|throw|return)\b/,
+	'keyword': /\b(import|from|func|struct|typedef|match|switch|case|enum|default|let|const|new|destroy|Flag|as|in|by|for|while|do|break|if|elif|else|and|or|try|catch|throw|return)\b/,
 	'type': /(\!|\[\d*\]|\*|\?)*([iu](256|25[0-5]|2[0-4][0-9]|1?[0-9]{1,2}|ptr)|byte|f32|f64|float|double|string|char|bool|type|anytype|void|noreturn|fault)\b/,
 
 	'fault': {
@@ -17,7 +17,7 @@ Prism.languages.abs = {
     'property': /@([a-zA-Z_][a-zA-Z0-9_]*)/,
 	'function': /\b[a-zA-Z_][a-zA-Z0-9_]*(?=\()\b/,
 
-	'operator': /(\+\+|\*\*|\?\?|==|>=|<=|\!=|\+=|-=|\*=|\/=|%=|=>|\+|-|\*|\/|%|=|>|<|\.)/,
+	'operator': /(\+\+|\*\*|\?\?|==|>=|<=|\!=|\+=|-=|\*=|\/=|%=|=>|\+|-|\*|\/|%|=|>|<|\.|\&)/,
     'punctuation': /(\[|\]|{|}|\(|\))/,
 
 	// values