Update docs

Author: vascocosta

README.md

@@ -16,20 +16,20 @@ io = import("std/io")
 strings = import("std/strings")
 
 fn main() {
-    list = ["Not", "Yet", "Yellow", "World", "But", "Almost"]
+    list = ["Hi", "World!", "Goodbye"]
 
     text = list
-        |> slice(2, len(list) - 2) # Slice the list to get rid of extra words.
-        |> strings.join(" ") # Create a string by joining words from the list.
-        |> strings.replace("Yellow", "Hello") # Fix the typo (Yellow > Hello).
-        |> append("!") # Finally append !, although the + operator also works.
+        |> slice(0, len(list) - 1)
+        |> strings.join(" ")
+        |> strings.replace("Hi", "Hello")
+        |> strings.upper()
 
     io.println(text)
 }
 ```
 
 ```
-Hello World!
+HELLO WORLD!
 ```
 
 ## Philosophy
@@ -40,26 +40,23 @@ The core guiding principle is minimalism, but without making it boringly simple.
 
 ## Features
 
-* Minimalist but ergonomic and consistent syntax
-* Lists (immutable Python-like lists)
-* Records (immutable Javascript-like objects)
-* First-class functions
-* Lambdas
-* Closures
-* Function pipe operator
+* Minimalist, ergonomic and consistent syntax
+* Immutable Python-like lists
+* Immutable JavaScript-like records
+* First-class functions, lambdas and closures
+* Function pipe operator (`|>`)
 * Easy collection iteration
-* Functions that might fail return { "error": Bool, "value": Value }
-* One single way to do things
-* Rich built-in std library
-* Balanced imperative/functional style
-* Ideal for new and experienced programmers
-* Implemented in Rust taking advantage of its ownership model (no GC)
+* Lightweight error propagation with `?=`
+* Rich standard library
+* Balanced imperative and functional style
+* Friendly to both new and experienced programmers
+* Implemented in Rust without a garbage collector
 
 ## Examples
 
 ### Example 1
 
-```Python
+```python
 io = import("std/io")
 
 fn generic_operation(a, b, operation) {
@@ -89,7 +86,7 @@ Output:
 
 ### Example 2
 
-```Python
+```python
 io = import("std/io")
 
 fn even_odd(numbers) {
@@ -126,57 +123,14 @@ Output:
 
 ### Example 3
 
-```Python
-conv = import("std/conv")
-io = import("std/io")
-
-# Define a function that "updates" a user (records are immutable).
-fn birthday(user) {
-    return {
-        name: user.name,
-        age: user.age + 1
-    }
-}
-
-# Create a record.
-user = {
-    name: "Vasco",
-    age: 44
-}
-
-io.println("User:")
-io.println("Name: " + user.name)
-io.println("Age: " + conv.string(user.age))
-
-# Create a new updated record.
-updated = birthday(user)
-
-io.println()
-io.println("After birthday:")
-io.println("Name: " + updated.name)
-io.println("Age: " + conv.string(updated.age))
-```
-
-```
-User:
-Name: Vasco
-Age: 44
-
-After birthday:
-Name: Vasco
-Age: 45
-```
-
-### Example 4
-
-```Python
+```python
 env = import("std/env")
 http = import("std/http")
 io = import("std/io")
 strings = import("std/strings")
 
 fn get_weather(location) {
-    # Get may fail so it returns { "error": Bool, "value": Value }.
+    # Get may fail so it returns { "error": Bool, "value": Any }.
     # The last expression is returned even without the return keyword.
     # A function returns an expression that evaluates to a value and is returned.
     http.get("https://wttr.in/" + location + "?format=3")
@@ -198,7 +152,7 @@ fn main() {
 
     result = get_weather(location)
 
-    # By convention functions that might fail return { "error": Bool, "value": Value }.
+    # By convention functions that might fail return { "error": Bool, "value": Any }.
     # Checking this record for an error is a common pattern in gluonscript.
     # If error is true, value shows its message as a string.
     # Otherwise if error is false, value shows whatever value the function returns.
@@ -216,41 +170,39 @@ Output:
 lisbon: 🌦   +14°C
 ```
 
-## Install
-
-### From binaries
-
-- Fetch the [latest release](https://github.com/vascocosta/gluonscript/releases) for your platform from GitHub.
-
-- Extract the archive into a `.gluonscript` folder at the root of your `HOME` folder.
-
-- Add the location of the `.gluonscript\bin` to your `PATH`.
-
-### From source
+### Example 4
 
-- Fetch the source code from GitHub by cloning the repo with:
+```python
+http = import("std/http")
+io = import("std/io")
+json = import("std/json")
+
+fn fetch(url) {
+    # The ?= operator (error propagation) is similar to Rust's ? operator.
+    # It makes it easy to handle { "error": Bool, "value": Any } return types.
+    # If the value on the right is an error, it propagates the error to the caller.
+    # Otherwise it unwraps value and assigns it to the variable on the left.
+
+    raw_json ?= http.get(url) # Get raw json from server or propagate error.
+    parsed_json ?= json.parse(raw_json) # Parse JSON into a record or propagate error.
+    
+    # Functions using the ?= operator should return { "error": Bool, "value": Any }.
+    # This record is similar to Rust's Result type, but simpler and without generics.
+    { error: false, value: parsed_json }
+}
 
-```
-git clone https://github.com/vascocosta/gluonscript.git
-```
+fn main() {
+    content = fetch("https://catfact.ninja/fact")
 
-- Compile the source code (you need the `Rust toolchain`):
+    if content.error {
+        io.println("There was an error: " + content.value)
+        return 1
+    }
 
+    io.println(content.value.fact)
+}
 ```
-cd gluonscript
-cargo build -r
-```
-
-### Notes
-
-As you can see there is no installer, the interpreter is self-contained and can be executed from anywhere. However, it is strongly recommended that you add the location of the binary to your `PATH` variable so that you can run `gluonscript` from anywhere on the command line.
-
-#### Running a script
-
-- Edit `my_script.gs` on your preferred IDE.
-
-- Run the script from the command line:
 
 ```
-gluonscript my_script.gs
+A cat can jump 5 times as high as it is tall.
 ```

docs/index.md

@@ -18,12 +18,15 @@ io = import("std/io")
 strings = import("std/strings")
 
 fn main() {
-    message =
-        "hello world"
+    list = ["Hi", "World!", "Goodbye"]
+
+    text = list
+        |> slice(0, len(list) - 1)
+        |> strings.join(" ")
+        |> strings.replace("Hi", "Hello")
         |> strings.upper()
-        |> append("!")
 
-    io.println(message)
+    io.println(text)
 }
 ```