A few fixes

Author: Mohammad Fawaz

documentation/guides/08_testing.md

@@ -47,7 +47,7 @@ Developers can add multiple `leo` files to the test directory but must ensure th
 
 The `example_program.leo` program contains an entry function which returns the sum of two `u32` inputs.
 
-```Leo
+```leo
 fn simple_addition(public a: u32, b: u32) -> u32 {
     let c: u32 = a + b;
     return c;
@@ -56,7 +56,7 @@ fn simple_addition(public a: u32, b: u32) -> u32 {
 
 The `test_example_program.leo` contains two tests to ensure that the function logic returns a correct output and fails when the output does not match the sum of the input values.
 
-```Leo
+```leo
 @test
 fn test_simple_addition() {
     let result: u32 = example_program.aleo::simple_addition(2u32, 3u32);
@@ -66,7 +66,7 @@ fn test_simple_addition() {
 
 The `@should_fail` annotation should be added after the `@test` annotation for tests that are expected to fail.
 
-```Leo
+```leo
 @test
 @should_fail
 fn test_simple_addition_fail() {
@@ -79,7 +79,7 @@ fn test_simple_addition_fail() {
 
 Developers can test that record and struct fields match their expected values. In `example_program.leo`, a record is minted by an entry function shown here:
 
-```Leo
+```leo
 record Example {
     owner: address,
     x: field,
@@ -95,7 +95,7 @@ fn mint_record(x: field) -> Example {
 
 The corresponding test in `test_example_program.leo` checks that the Record field contains the correct value:
 
-```Leo
+```leo
 @test
 fn test_record_maker() {
     let r: example_program.aleo::Example = example_program.aleo::mint_record(0field);

documentation/language/02_structure.md

@@ -169,7 +169,7 @@ The visibility qualifier may be specified as `constant`, `public`, or `private`.
 
 Record data structures must always contain a component named `owner` of type `address`, as shown below. When passing a record as input to a program function, the `_nonce: group` and `_version: u8` components are also required but do not need to be declared in the Leo program. They are inserted automatically by the compiler.
 
-```aleo showLineNumbers
+```leo showLineNumbers
 record Token {
     // The token owner.
     owner: address,

documentation/language/03_data_types.md

@@ -171,14 +171,17 @@ struct Bar {
 }
 
 // Array of structs
-let arr_of_structs: [Bar; 2] = [Bar { data: 1u8 }, Bar { data: 2u8 }];
+let arr_of_structs: [Bar; 2] = [
+    Bar { data: [1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8] },
+    Bar { data: [2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8] },
+];
 ```
 
 Arrays only support constant accesses. The accessor expression must be a constant expression (known at compile-time).
 
 ```leo
 // Access the field of a struct within an array
-fn foo(a: [Bar; 8]) -> u8 {
+fn foo(a: [Bar; 8]) -> [u8; 8] {
     return a[0u8].data;
 }
 ```
@@ -207,10 +210,10 @@ Leo supports tuples. Tuple types are declared as `(type1, type2, ...)` and canno
 Tuples can contain primitive data types, structs, arrays, or nested tuples. Structs and records can also contain tuples.
 
 ```leo
-// Initialize a boolean array of length 4
+// Initialize a tuple of mixed types
 let tup: (u8,u8,bool) = (1u8,1u8,true);
 
-// Nested array
+// Nested tuple
 let nested: [[bool; 2]; 2] = [[true, false], [true, false]];
 ```
 
@@ -226,7 +229,7 @@ struct Bar {
     data: (u8,u8),
 }
 
-// Tuple of structs
+// Array of structs with tuple fields
 let tup_of_structs: [Bar; 2] = [Bar { data: (1u8,1u8) }, Bar { data: (2u8,2u8) }];
 ```
 
@@ -293,7 +296,7 @@ Records contain component declarations `{visibility} {name}: {type},`. Names of
 
 Record data structures must always contain a component named `owner` of type `address`, as shown below. When passing a record as input to a program function, the `_nonce: group` and `_version: u8` components are also required but do not need to be declared in the Leo program. They are inserted automatically by the compiler.
 
-```aleo showLineNumbers
+```leo showLineNumbers
 record Token {
     // The token owner.
     owner: address,

documentation/language/05_control_flow.md

@@ -6,7 +6,7 @@ sidebar_label: Control Flow
 
 [general tags]: # "loop, conditional, return"
 
-### Conditional Statements
+## Conditional Statements
 
 Conditional statements are declared as `if {condition} { ... } else if {condition} { ... } else { ... }`.
 Conditional statements can be nested.
@@ -30,7 +30,7 @@ let a: u8 = 1u8;
 a = (a == 1u8) ? a + 1u8 : ((a == 2u8) ? a + 2u8 : a + 3u8);
 ```
 
-### Return Statements
+## Return Statements
 
 Return statements are declared as `return {expression};`.
 
@@ -46,7 +46,7 @@ Return statements are declared as `return {expression};`.
     }
 ```
 
-### For Loops
+## For Loops
 
 For loops are declared as `for {variable: type} in {lower bound}..{upper bound}`.
 The loop bounds must be integer constants of the same type. Furthermore, if

documentation/language/08_cheatsheet.md

@@ -398,7 +398,7 @@ let get_or_use_bal: u64 = balances.get_or_use(receiver, 0u64);
 
 // Modifying
 balances.set(receiver, 100u64);
-balances.remove(balances, receiver);
+balances.remove(receiver);
 
 // External mappings (read-only)
 let ext_contains: bool = external_program.aleo::balances.contains(receiver);
@@ -492,7 +492,7 @@ let height: u32 = block.height; // Height of current block
 let now: i64 = block.timestamp; // Timestamp of current block
 let this: address = self.address; // Address of program
 let caller: address = self.caller; // Address of function caller
-let checksum: [u8, 32] = self.checksum; // Checksum of a program
+let checksum: [u8; 32] = self.checksum; // Checksum of a program
 let edition: u16 = self.edition; // Edition of a program
 let owner: address = self.program_owner; // Address that deployed a program
 let signer: address = self.signer; // Address of tx signer (origin)

documentation/language/programs_in_practice/interfaces.md

@@ -59,7 +59,7 @@ interface Transfer {
 
 interface Pausable {
     mapping paused: address => bool;
-    fn pause() -> bool;
+    fn pause() -> (bool, Final);
 }
 
 // my_token.aleo must satisfy both Transfer and Pausable
@@ -75,13 +75,10 @@ program my_token.aleo : Transfer + Pausable {
         return Token { owner: to, balance: input.balance - amount };
     }
 
-    async fn pause() -> (bool, Future) {
-        let f: Future = finalize_pause(self.caller);
-        return (true, f);
-    }
-
-    async function finalize_pause(caller: address) {
-        Mapping::set(paused, caller, true);
+    fn pause() -> (bool, Final) {
+        return (true, final {
+            Mapping::set(paused, self.caller, true);
+        });
     }
 }
 ```
@@ -156,18 +153,17 @@ Dynamic calls allow the callee to be determined at runtime. The caller still kno
 ```leo
 // Dynamic: any program that implements TokenStandard can be called
 fn route_transfer_dynamic(token_program: identifier, to: address, amount: u64) {
-    return token_a.aleo::TokenStandard@(token_program)::transfer_public(to, amount);
+    return TokenStandard@(token_program)::transfer_public(to, amount);
 }
 ```
 
 The syntax is:
 ```
-qualifier.aleo::Interface@(target)::method(args)
+Interface@(target)::method(args)
 ```
 where:
-- `qualifier.aleo` is the imported program that declares (or re-exports) the interface. This must be a static import.
 - `Interface` is the interface name.
-- `target` is an `identifier` value resolved at runtime — the name of the program to call into.
+- `target` is an `identifier` value (or `field`) resolved at runtime — the name of the program to call into.
 - `method` is the function to invoke.
 
 ### The `identifier` Type
@@ -176,15 +172,15 @@ The `identifier` type represents a program name resolved at runtime. An `identif
 
 ```leo
 let target: identifier = 'my_program';
-return token_a.aleo::TokenStandard@(target)::transfer_public(to, amount);
+return TokenStandard@(target)::transfer_public(to, amount);
 ```
 
 By default the target is looked up on the `aleo` network. To specify a different network explicitly, pass a second `identifier` as a second argument:
 
 ```leo
 let target: identifier = 'my_program';
 let network: identifier = 'aleo';
-return token_a.aleo::TokenStandard@(target, network)::transfer_public(to, amount);
+return TokenStandard@(target, network)::transfer_public(to, amount);
 ```
 
 :::note

documentation/language/programs_in_practice/public_storage.md

@@ -74,8 +74,8 @@ program map.aleo {
             let current_value: u64 = balance.get_or_use(addr, 0u64);
             balance.set(addr, current_value + 1u64);
 
-            let next_current_value = balance.get(addr);
-            balance.set(addr, current_value + 1u64);
+            let next_current_value: u64 = balance.get(addr);
+            balance.set(addr, next_current_value + 1u64);
         };
     }
 }