Merge pull request #429 from quyenducngo/patch-10

Update language copy and typos

Author: d0cd

documentation/aleo/03_language.md

@@ -6,26 +6,26 @@ sidebar_label: Language
 
 ### Statically Typed
 
-Aleo instructions is a **statically typed language**, which means we must know the type of each variable before executing a circuit.
+Aleo instructions is a **statically typed language**, which means we must know the type of each register for the code to be valid.
 
 ### Explicit Types Required
 
-There is no `undefined` or `null` value in Aleo instructions. When assigning a new variable, **the type of the value must be explicitly stated**.
+There is no `undefined` or `null` value in Aleo instructions. Every register must have an e**xplicitly stated** or **statically inferred**.
 
 ### Pass by Value
 
-Expressions in Aleo instructions are always **passed by value**, which means their values are always copied when they are used as function inputs or in right sides of assignments.
+Arguments in Aleo instructions are always **passed by value**, which means their values are always copied when they are used as function inputs or in right sides of assignments.
 
 ### Register based
 
 There are no variable names in Aleo instructions.
-All variables are stored in registers denoted `rX` where `X` is a non-negative whole number starting from 0 `r0, r1, r2, etc.`.
+All values are stored in registers denoted `rX` where `X` is a non-negative whole number starting from 0 `r0, r1, r2, etc.`.
 
 ## Data Types and Values
 
 ### Booleans
 
-Aleo instructions supports the traditional `true` or `false` boolean values. The explicit `boolean` type for booleans in statements is required.
+Aleo instructions supports the traditional `true` or `false` boolean values. The explicit `boolean` type for booleans in instructions is required.
 
 ```aleo
 function main:
@@ -59,9 +59,9 @@ function main:
 
 ### Group Elements
 
-The set of affine points on the elliptic curve passed into the Aleo instructions compiler forms a group.
+The set of affine points on the elliptic curve that Aleo instructions are based on forms a group.
 The curve is a Twisted Edwards curve with `a = -1` and `d = 3021`.
-Aleo instructions supports a subgroup of the group, generated by a generator point, as a primitive data type.
+Aleo instructions support a subgroup of the group, generated by a generator point, as a primitive data type.
 A group element is denoted by the x-coordinate of its point; for example,
 `2group` means the point `(2, 5553594316923449299484601589326170487897520766531075014687114064346375156608)`.
 The generator point is `1540945439182663264862696551825005342995406165131907382295858612069623286213group`.
@@ -103,15 +103,14 @@ sign.verify sign069ju4e8s66unu25celqycvsv3k9chdyz4n4sy62tx6wxj0u25vqp58hgu9hwyqc
 ## Layout of an Aleo Program
 
 An Aleo program contains declarations of a [Program ID](#programid), [Imports](#import), [Functions](#function), [Closures](#closure), [Structs](#struct), [Records](#record),
-[Mappings](#mapping), and [Finalize](#finalize). Ordering is only enforced for imports which must be at the top of file.
+[Mappings](#mapping), and [Finalizers](#finalize). Ordering is only enforced for imports which must be at the top of the file.
 Declarations are locally accessible within a program file.
 If you need a declaration from another program file, you must import it.
 
 ### Program ID
 
 A program ID is declared as `{name}.{network}`.
-The first character of a `name` must be lowercase.
-`name` can contain lowercase letters, numbers, and underscores.
+`name` must start with a lowercase letter and only contain lowercase letters, digits, and underscores.
 Currently, `aleo` is the only supported `network` domain.
 
 ```aleo showLineNumbers
@@ -153,7 +152,7 @@ function foo:
 #### Function Inputs
 
 A function input is declared as `input {register} as {type}.{visibility};`.  
-Function inputs must be declared just after the function name declaration.
+Function inputs must be declared just after the function name declaration and before instructions.
 
 ```aleo showLineNumbers
 // The function `foo` takes a single input `r0` with type `field` and visibility `public`.
@@ -175,8 +174,8 @@ Function outputs must be declared at the end of the function definition.
 
 In the Aleo protocol, calling a function creates a transition that can consume and produce records on-chain.
 Use the `aleo run` CLI command to pass inputs to a function and execute the program.  
-In Testnet3, program functions cannot call other internal program functions.
-If you would like to develop "helper functions" that are called internally within a program, try writing a `closure`.
+In Testnet, program functions cannot call other internal program functions.
+If you would like to develop "helper functions" that are called internally within a program, write a `closure`.
 
 #### Call an Imported Function
 
@@ -189,15 +188,22 @@ program bar.aleo;
 
 function call_external:
     input r0 as u64.private;
-    call foo.aleo/baz r0 into r1; // Externally call function `baz` in foo.aleo with argument `r0` and store the result in `r1`.
-    output r1;
+    input r1 as u64.private;
+    
+    // Externally call function `baz` in foo.aleo with arguments `r0` and `r1`,
+    // and store the results in `r2` and `r3`.
+    call foo.aleo/baz r0 r1 into r2 r3;
+
+    output r2;
+    output r3;
 ```
 
 ### Closure
 
 A closure is declared as `closure {name}:`.  
 Closures contain instructions that can compute values.
-Closures are helper functions that cannot be executed directly. Closures may be called by other functions.
+Closures are helper functions that cannot be executed directly from the CLI to create transitions.
+Closures may be called by other functions.
 
 ```aleo showLineNumbers
 closure foo:
@@ -216,8 +222,14 @@ program bar.aleo;
 
 function call_internal:
     input r0 as u64.private;
-    call foo r0 into r1; // Internally call closure `foo` with argument `r0` and store the result in `r1`.
-    output r1;
+    input r1 as u64.private;
+
+    // Internally call closure `foo` with arguments `r0` and `r1`,
+    // and store the results in `r2` and `r3`.
+    call foo r0 r1 into r2 r3;
+
+    output r2;
+    output r3;
 ```
 
 ### Struct
@@ -245,7 +257,7 @@ function new_array3:
 
 ### Array
 
-An array is a data type declared as `[{value}, {value}]`.
+An array is an aggregate value denoated as `[{value}, ..., {value}]`.
 
 ```aleo
 [true, false, true]
@@ -340,7 +352,7 @@ mapping account:
 
 #### Contains
 
-A contains command that checks if a key exists in a mapping, e.g. `contains accounts[r0] into r1;`.
+A contains command checks if a key exists in a mapping and stores the boolean result in the into register. For example: `contains accounts[r0] into r1;`.
 
 #### Get
 
@@ -460,7 +472,7 @@ For example, `await r0;`.
 An `await` command can only be used in a finalize block.
 The operand must be a register containing a Future.
 
-#### Indexing a future.
+#### Indexing a future
 A register containing a future can be indexed using the existing index syntax.
 For example, `r0[0u32]`.
 This would get the input of the future at that specific index.
@@ -530,8 +542,8 @@ finalize add_and_subtract:
 There are a number of rules associated with using these components.
 
 1. If a function has a finalize block, it must have exactly one async instruction.
-2. If a function has a finalize block, it's last output must be a future.
-3. If a function does not have a finalize block, it cannot have an async instruction`.
+2. If a function has a finalize block, its last output must be a future.
+3. If a function does not have a finalize block, it cannot have an async instruction.
 4. All futures created by calls need to be input to the async instruction in the order they were produced.
 5. An async call must reference the same function.
 6. All calls must be made before invoking async.
@@ -620,8 +632,8 @@ Checkout the [Aleo Instructions opcodes](./04_opcodes.md) for a full list of sup
 #### position, branch.eq, branch.neq
 
 The `position` command, e.g. `position exit`, indicates a point to branch execution to.  
-The `branch.eq` command, e.g. `branch.eq r0 r1 to exit`, which branches execution to the position indicated by `exit` if `r0` and `r1` are equal.  
-The `branch.neq` command, e.g. `branch.neq r0 r1 to exit`, which branches execution to the position indicated by `exit` if `r0` and `r1` are not equal.
+The `branch.eq` command, e.g. `branch.eq r0 r1 to exit`, branches execution to the position indicated by `exit` if `r0` and `r1` are equal.  
+The `branch.neq` command, e.g. `branch.neq r0 r1 to exit`, branches execution to the position indicated by `exit` if `r0` and `r1` are not equal.
 
 ** Example **
 The finalize block exits successfully if the input is 0u8 and fails otherwise.
@@ -713,7 +725,7 @@ $ snarkvm execute foo
 
 #### User Callable Program
 
-By `asserting assert.eq self.caller self.signer;` on line 4, a developer can restrict their function such that it can only be called by users.
+By asserting `assert.eq self.caller self.signer;` on line 4, a developer can restrict their function such that it can only be called by users.
 ```aleo showLineNumbers title="./imports/child.aleo"
 program child.aleo;