Merge pull request #8 from xch-dev/multi-file-update

Multi file update

Author: Rigidity

docs/bindings.md

@@ -42,3 +42,40 @@ This should be used sparingly, since it can come with either a performance hit,
 :::tip
 The compiler will automatically inline `let` bindings if they are only referenced a single time.
 :::
+
+## Destructuring
+
+You can destructure values (including `let` bindings and function parameters) into multiple bindings at once.
+
+For example, if you have a pair, you can destructure the first and rest values into separate bindings:
+
+```rue
+let (first, rest) = (100, 200);
+```
+
+This also works for lists (as long as the values are known to not be nil):
+
+```rue
+let [a, b, c] = [100, 200, 300];
+```
+
+If you have a struct, you can destructure the fields:
+
+```rue
+struct Point {
+    x: Int,
+    y: Int,
+}
+
+let { x, y } = Point { x: 100, y: 200 };
+```
+
+These destructuring patterns can be combined arbitrarily:
+
+```rue
+let ([a, b, c], { x, y }) = ([100, 200, 300], Point { x: 400, y: 500 });
+```
+
+:::note
+When you destructure a value, it's first assigned to a temporary binding, and then that binding is referenced by each of the bindings in the destructuring pattern. Thus, if you're destructuring a non-inline variable, it's best to mark the destructured bindings as `inline` to reduce the size of the compiled program.
+:::

docs/builtins.md

@@ -13,17 +13,18 @@ You can click on each of these types to go to their corresponding page and learn
 1. [**Atom**](/docs/type-system/atoms.md#atom)
 2. [**Bytes**](/docs/type-system/atoms.md#bytes)
 3. [**Bytes32**](/docs/type-system/atoms.md#bytes32)
-4. [**PublicKey**](/docs/type-system/atoms.md#publickey)
-5. [**Signature**](/docs/type-system/atoms.md#signature)
-6. [**K1PublicKey**](/docs/type-system/atoms.md#k1publickey)
-7. [**K1Signature**](/docs/type-system/atoms.md#k1signature)
-8. [**R1PublicKey**](/docs/type-system/atoms.md#r1publickey)
-9. [**R1Signature**](/docs/type-system/atoms.md#r1signature)
-10. [**Int**](/docs/type-system/atoms.md#int)
-11. [**Bool**](/docs/type-system/atoms.md#bool)
-12. [**Any**](/docs/type-system/pairs.md#any)
-13. [**List**](/docs/type-system/pairs.md#lists)
-14. [**AlternatingList**](/docs/type-system/pairs.md#alternating-lists)
+4. [**String**](/docs/type-system/atoms.md#string)
+5. [**PublicKey**](/docs/type-system/atoms.md#publickey)
+6. [**Signature**](/docs/type-system/atoms.md#signature)
+7. [**K1PublicKey**](/docs/type-system/atoms.md#k1publickey)
+8. [**K1Signature**](/docs/type-system/atoms.md#k1signature)
+9. [**R1PublicKey**](/docs/type-system/atoms.md#r1publickey)
+10. [**R1Signature**](/docs/type-system/atoms.md#r1signature)
+11. [**Int**](/docs/type-system/atoms.md#int)
+12. [**Bool**](/docs/type-system/atoms.md#bool)
+13. [**Any**](/docs/type-system/pairs.md#any)
+14. [**List**](/docs/type-system/pairs.md#lists)
+15. [**AlternatingList**](/docs/type-system/pairs.md#alternating-lists)
 
 ## Functions
 

docs/constants.md

@@ -11,9 +11,9 @@ They are similar to [Bindings](/docs/bindings.md), which the primary difference
 As a simple example, you might want to reuse a string multiple times:
 
 ```rue
-const GREET: Bytes = "Hello, ";
+const GREET: String = "Hello, ";
 
-fn main(person_a: Bytes, person_b: Bytes) -> (Bytes, Bytes) {
+fn main(person_a: String, person_b: String) -> (String, String) {
     (GREET + person_a, GREET + person_b)
 }
 ```
@@ -25,9 +25,9 @@ You can mark a constant as `inline`, which forces its value to be inserted every
 As an example, this will behave the same as if you had written the string multiple times:
 
 ```rue
-inline const GREET: Bytes = "Hello, ";
+inline const GREET: String = "Hello, ";
 
-fn main(person_a: Bytes, person_b: Bytes) -> (Bytes, Bytes) {
+fn main(person_a: String, person_b: String) -> (String, String) {
     (GREET + person_a, GREET + person_b)
 }
 ```

docs/installation.md

@@ -7,8 +7,8 @@ import TabItem from '@theme/TabItem';
 
 # Installation
 
-:::warning
-Rue is currently in alpha. Please use it with caution and report any bugs you find in doing so.
+:::note
+Rue is still in active development. If you run into any issues, please report them in [GitHub issues](https://github.com/xch-dev/rue/issues).
 :::
 
 First, you will need to install the [Rust toolchain](https://rustup.rs).
@@ -66,20 +66,26 @@ Any editor that supports Open VSX and VSCode extensions will likely support this
 
 ## Hello World
 
-The simplest example of a program in Rue is the classic hello world example.
+The simplest program in Rue is the classic "hello world" example.
 
-Write the following program in a file named `hello.rue`:
+You can run the following command to setup a new project:
 
-```rue title="hello.rue"
-fn main() -> Bytes {
-    "Hello, world!"
-}
+```bash
+rue init
 ```
 
-Now, run the following command to run the file:
+And then you can build it:
 
 ```bash
-rue build hello.rue
+rue build
+```
+
+The `puzzles/main.rue` file should contain something like this:
+
+```rue
+fn main() -> String {
+    "Hello, world!"
+}
 ```
 
-The output should be `(q . "Hello, world!)"`, which when run with CLVM outputs the string on its own.
+And the CLVM output when compiling it is `(q . "Hello, world!)"`.

docs/modules.md

@@ -0,0 +1,81 @@
+# Modules
+
+Modules are a way to organize your code into separate files.
+
+## File Structure
+
+As long as you have a `main.rue` file in the root of your project, the compiler will automatically include all of the `.rue` files adjacent to it (including subdirectories) in the compilation.
+
+All files are modules and can reference each other by name:
+
+1. Each file includes every other adjacent file or directory in its scope.
+2. Each directory's module automatically exports all of its children.
+3. Each file has access to the parent directory's module with `super`.
+
+If there is no `main.rue` file, then each file ending in `.rue` will be compiled completely independently, rather than as a single program.
+
+## Paths
+
+You can reference exported symbols and types from other modules by using the module name followed by the path to the symbol or type.
+
+```rue
+fn main() -> String {
+    utils::greet("Alice")
+}
+```
+
+In this case, we are referencing the `greet` function from the `utils` module.
+
+## Imports
+
+Instead of referencing by path every time, you can import symbols and types from other modules into the current scope so that they can be referenced directly.
+
+```rue
+import utils::greet;
+
+fn main() -> String {
+    greet("Alice")
+}
+```
+
+You can import multiple paths:
+
+```rue
+import utils::{greet, exclaim};
+
+fn main() -> String {
+    exclaim(greet("Alice"))
+}
+```
+
+You can also import all symbols and types from a module by using the `*` wildcard:
+
+```rue
+import utils::*;
+
+fn main() -> String {
+    exclaim(greet("Alice"))
+}
+```
+
+Finally, it's possible to re-export things that you import:
+
+```rue
+export utils::*;
+```
+
+## Module Block
+
+You can create a module by using the `mod` keyword followed by the name of the module. This is here for completeness more than anything, since most of the time you'll want to use multiple files instead.
+
+```rue
+mod utils {
+    export fn add(a: Int, b: Int) -> Int {
+        a + b
+    }
+}
+
+fn main() -> Int {
+    utils::add(42, 34)
+}
+```