update examples (#208)

Author: edg-l

README.md

@@ -149,16 +149,22 @@ mod StructExample {
     }
 
     impl Foo {
+        pub fn new(bar: i32, baz: i64) -> Foo {
+            let value: Foo = foo {
+                bar: bar,
+                baz: baz,
+            };
+
+            return value;
+        }
+
         pub fn mul_bar(&mut self, value: i32) {
             self.bar = self.bar * 2;
         }
     }
 
     fn main() -> i32 {
-        let mut foo: Foo = Foo {
-            bar: 2,
-            baz: 3,
-        };
+        let mut foo: Foo = Foo#new(2, 3);
 
         foo.mul_bar(2);
         foo.baz = foo.baz * 5;
@@ -173,33 +179,85 @@ mod StructExample {
 ```
 
 ```rust
-mod Option {
-    pub enum Option<T> {
+mod option {
+    enum Option<T> {
+        Some {
+            value: T,
+        },
         None,
-        Some(T),
     }
 
-    impl<A> Option<A> {
-        pub fn map<A, B>(self, f: A -> B) -> Option<B> {
+    impl<T> Option<T> {
+        pub fn is_some(&self) -> bool {
             match self {
-                None -> None,
-                Some(x) -> Some(f(x)),
+                Option#Some { value } => {
+                    return true;
+                },
+                Option#None => {
+                    return false;
+                }
             }
         }
+
+        pub fn is_none(&self) -> bool {
+            return !self.is_some();
+        }
+    }
+}
+```
+
+Example pseudo allocator using libc:
+
+```rust
+mod alloc {
+    import std.mem.{sizeof};
+
+    pub fn alloc<T>() -> *mut T {
+        return std::libc::malloc(sizeof::<T>()) as *mut T;
+    }
+
+    pub fn realloc<T>(old_ptr: *mut T, size: u64) -> *mut T {
+        return std::libc::realloc(old_ptr as *mut u8, sizeof::<T>() * size) as *mut T;
     }
+
+    pub fn free<T>(ptr: *mut T) {
+        std::libc::free(ptr as *mut u8);
+    }
+}
+```
+
+A basic for loop:
+
+```rust
+fn sum_to(limit: i64) -> i64 {
+    let mut result: i64 = 0;
+
+    for (let mut n: i64 = 1; n <= limit; n = n + 1) {
+        result = result + n;
+    }
+
+    return result;
 }
+```
 
-mod UsesOption {
-    import MyOption.{Option, map};
+Or using a `while`:
 
-    pub fn headOfVectorPlus1(x: [u8]) -> Option<u8> {
-        // head returns an option
-        x.head().map((x: u8) -> x + 1)
+```rust
+fn sum_to(limit: i64) -> i64 {
+    let mut result: i64 = 0;
+
+    let mut n: i64 = 1;
+    while n <= limit {
+        result = result + n;
+        n = n + 1;
     }
 
+    return result;
 }
 ```
 
+Check out the [book](https://lambdaclass.github.io/concrete/) for more examples.
+
 ## Inspiration
 The design was very heavily influenced by all these programming languages:
 - [Erlang](https://www.erlang.org) (Preemptive scheduler, message passing, runtime)

docs/book/src/SUMMARY.md

@@ -9,6 +9,7 @@
     - [Variables](./language/variables.md)
     - [Functions](./language/functions.md)
     - [Structs](./language/structs.md)
+    - [Enums](./language/enums.md)
     - [Control flow](./language/control_flow.md)
 - [Internal Details](./internal/index.md)
     - [The IR](./internal/ir.md)

docs/book/src/language/enums.md

@@ -0,0 +1,63 @@
+# Enums
+
+With the `enum` keyword you can define a enum:
+
+```rust
+mod option {
+    enum Option<T> {
+        Some {
+            value: T,
+        },
+        None,
+    }
+
+    impl<T> Option<T> {
+        pub fn is_some(&self) -> bool {
+            match self {
+                Option#Some { value } => {
+                    return true;
+                },
+                Option#None => {
+                    return false;
+                }
+            }
+        }
+
+        pub fn is_none(&self) -> bool {
+            return !self.is_some();
+        }
+    }
+}
+```
+
+```rust
+mod Enum {
+    enum A {
+        X {
+            a: i32,
+        },
+        Y {
+            b: i32,
+        }
+    }
+
+    fn main() -> i32 {
+        let x: A = A#X {
+            a: 2,
+        };
+
+        let mut result: i32 = 0;
+
+        match x {
+            A#X { a } => {
+                result = a;
+            },
+            A#Y { b } => {
+                result = b;
+            }
+        }
+
+        return result;
+    }
+}
+```