Release 0.29.0

.github/workflows/main.yml

@@ -7,17 +7,18 @@ on:
       - master
 
 jobs:
-  check-tests:
+  check-tests-and-docs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
-      - name: Make dictu and run checkTests
+      - name: Make dictu and run checkTests and orderDocs
         run: |
           sudo apt-get update
           sudo apt-get install -y libcurl4-openssl-dev uuid-dev
           cmake -DCMAKE_BUILD_TYPE=Debug -DDISABLE_HTTP=1 -B ./build
           cmake --build ./build
           ./dictu ops/checkTests.du ci
+          ./dictu ops/orderDocs.du --ci
   test-ubuntu-cmake:
     name: Test on ${{ matrix.os }}
     runs-on: ${{ matrix.os }}

.github/workflows/release.yml

@@ -31,7 +31,7 @@ jobs:
     - name: Release
       uses: SierraSoftworks/gh-releases@v1.0.7
       with:
-        token: ${{ secrets.TOKEN }}
+        token: ${{ secrets.GITHUB_TOKEN }}
         overwrite: 'true'
         files: |
           dictu-linux-x86_64

.gitignore

@@ -27,7 +27,7 @@ CMakeSettings.json
 dictu.ilk
 dictu.pdb
 test1.du
-\.vscode/
+.vscode
 /.env
 /vcpkg_installed
 /Release

docs/_config.yml

@@ -5,7 +5,7 @@ description: >-
 color_scheme: "dictu" # Custom theme
 logo: "/assets/images/dictu-logo/dictu-wordmark.svg"
 
-version: "0.28.0"
+version: "0.29.0"
 github_username:  dictu-lang
 search_enabled: true
 

docs/docs/classes.md

@@ -148,6 +148,39 @@ print(TestOverload().toString()); // 'Testing object'
 
 ```
 
+### toDict() -> Dict
+
+Classes and instances can both be converted to a dictionary using the `toDict()` method. Inherited super classes are included in the dictionary.
+
+```cs
+class A {
+    var afield = 44;
+
+    amethod() {}
+    abethodb() {}
+}
+
+class B < A {
+    const x = 9;
+    const y = 8;
+
+    var fieldA = 1;
+    var fieldB = 2;
+
+    init() {}
+
+    methodA() {}
+    methodB() {}
+
+    private methodC() {}
+    private methodD() {}
+}
+
+const b = B();
+print(b._class.toDict()); // {"public_methods": ["abethodb", "init", "methodA", "amethod", "methodB", "abethodb", "amethod"], "variables": {"afield": 44, "fieldA": 1, "fieldB": 2}, "constants": {"y": 8, "_name": "A", "x": 9}}
+
+```
+
 ### methods() -> List
 
 Sometimes we need to programmatically access methods that are stored within a class, this can be aided through the use of `.methods()`. This
@@ -310,7 +343,7 @@ print(Test()?.unknownMethod()); // Undefined attribute 'unknownMethod'.
 ### _class
 
 `_class` is a special attribute that is added to instances so that a reference to the class is kept on objects. This will be
-useful for things like pulling class annotations from an object where it's class may be unknown until runtime.
+useful for things like pulling class, method, and field annotations from an object where it's class may be unknown until runtime.
 
 ```cs
 class Test {}
@@ -411,7 +444,7 @@ Hello
 
 ## Inheritance
 
-The syntax for class inheritance is as follows: `class DerivedClass < BaseClass`. `super` is a variable that is reference to the class that is being inherited.
+The syntax for class inheritance is as follows: `class DerivedClass < BaseClass`. `super` is a variable that is reference to the class that is being inherited. Class, method, and field annotations are inherited from the super class. If there is a conflict with annotations, favor is given to the child annotation. 
 
 Note: private methods and instance variables are not inherited.
 
@@ -690,7 +723,8 @@ print(AnnotatedClass.classAnnotations); // {"Annotation": nil}
 print(ClassWithMethodAnnotation.methodAnnotations); // {"method": {"MethodAnnotation": nil}}
 ```
 
-Annotations can also be supplied a value, however, the value must be of type: nil, boolean, number or string.
+Annotations can also be supplied a value, however, the value must be of type: dict, list, string, number, boolean or nil.
+Note: Annotation values must be constants as they are created at compile time.
 
 ```cs
 @Annotation("Some extra value!")

docs/docs/collections/lists.md

@@ -222,7 +222,7 @@ print(list2); // [[10, 2]]
 ### Sorting Lists
 #### list.sort()
 
-To sort numeric lists (that is lists that contain only numbers) you can use the method
+To sort numeric lists and string lists (that is lists that contain only numbers or only strings) you can use the method
 sort.
 
 ```cs
@@ -234,6 +234,15 @@ list1.sort();
 print(list1); // [-1, 1, 2, 3, 4, 5, 10]
 ```
 
+```cs
+var list1 = ["zebra", "cat", "dino", "pig"];
+
+print(list1); // ["zebra", "cat", "dino", "pig"]
+list1.sort();
+
+print(list1); // ["cat", "dino", "pig", "zebra"]
+```
+
 ### list.forEach(Func)
 
 To run a function on every element in a list we use `.forEach`. The callback function
@@ -324,3 +333,12 @@ Splice provides a means of changing the contents of a list by removing or replac
 [1, 2, 3, 4, 5].splice(1, 2, [100]); // [1, 100, 4, 5]
 [1, 2, 3, 4, 5].splice(3, 0, [100, 101, 102]); // [1, 2, 3, 100, 101, 102, 4, 5]
 ```
+
+### list.unique() -> List
+
+Unique returns a new list with contianing the contents of the original list deduplicated.
+
+```cs
+const l = [1, 1, 1, 2, 2, 3, 4, 5, 6, 6, 7, 8, 9, 9];
+l.unique(); // [1, 2, 3, 4, 5, 6, 7, 8, 9]
+```

docs/docs/enum.md

@@ -49,4 +49,18 @@ enum HeterogeneousEnum {
     b = "string",
     c = def () => 10
 }
+```
+
+### Enum.values()
+
+To get all values within an Enum you can use the `.values()` method. This will return a dictionary.
+
+```cs
+enum Test {
+    a = 10, // 10
+    b,      // 1
+    c       // 2
+}
+
+print(Test.values()); // {"c": 2, "a": 10, "b": 1}
 ```

docs/docs/error-handling.md

@@ -49,7 +49,7 @@ var result = Error("Some error happened!!");
 print(result.unwrapError()); // 'Some error happened!!'
 ```
 
-### .unwrap() -> value
+### .unwrap() -> Value
 
 As previously explained to get a value out of a Result it needs to be unwrapped.
 If you attempt to unwrap a Result that is of ERROR status a runtime error will be raised.
@@ -80,7 +80,7 @@ Check if a Result type is in a SUCCESS state, returns a boolean.
 "number".toNumber().success(); // false
 ```
 
-### .match(Func: success, Func: error) -> value
+### .match(Func: success, Func: error) -> Value
 
 `.match` takes two callbacks that are ran depending upon the status of the result type. The callbacks passed to
 match must both have one parameter each, on success the unwrapped value is passed as the first argument and on
@@ -125,4 +125,21 @@ print(response); // <Result Suc>
 ```
 
 In the above example we can handle the case that we need to do some data transformation, however, we
-also need to ensure that a Result object is returned in case we hit the error callback.
+also need to ensure that a Result object is returned in case we hit the error callback.
+
+### .matchError(Func: error) -> Value
+
+`.matchError` is similar to `.match` except it only accepts a single callback. If the Result type is 
+in an Error state the callback will be ran, otherwise the Result will be unwrapped and the wrapped value is
+returned. It becomes a shortcut if you do not need any intermediate handling on success unwrapping. 
+
+```cs
+var number = "10".toNumber().matchError(
+    def (error) => {
+        print(error);
+        System.exit(1);
+    }
+);
+
+print(number); // 10
+```

docs/docs/operators.md

@@ -25,6 +25,10 @@ nav_order: 6
 | -            | Subtracts the values on either side of the operator together   | 10 - 10                    |
 | *            | Multiplies the values on either side of the operator together  | 10 * 2                     |
 | /            | Divides the values on either side of the operator together.    | 10 / 3                     |
+| <            | Returns true if the left operand is less than the right operand (for strings this is based on the ASCII value)    | 9 < 10 |
+| >            | Returns true if the left operand is more than the right operand (for strings this is based on the ASCII value)    | 11 > 10 |
+| <=           | Same as < however includes an equality check                   | 9 <= 9                     |
+| >=           | Same as > however includes an equality check                   | 10 >= 10                   |
 | %            | Modulo of values on either side of the operator                | 10 % 2                     |
 | **           | Exponent (power) of the values                                 | 2 ** 2                     |
 | &            | Bitwise AND of the values                                      | 10 & 2                     |

docs/docs/standard-lib/argparse.md

@@ -1,7 +1,7 @@
 ---
 layout: default
 title: Argparse
-nav_order: 19
+nav_order: 1
 parent: Standard Library
 ---
 
@@ -24,12 +24,16 @@ To make use of the Argparse module an import is required.
 from Argparse import Parser;
 ```
 
-### New Parser(String, String, String) -> Parser
+### New Parser(String, String, String -> Optional) -> Parser
 
-To create a new parser instance, call the `Parser` class with the 3 required string arguments; name, description, and user provided usage.
+To create a new parser instance, call the `Parser` class with the 2 required string arguments; name, description.
+
+You can optionally pass in a user generated usage for the Parser
 
 ```cs
-var parser = Parser("prog_name", "Program to do all the things", "");
+const parser = Parser("prog_name", "Program to do all the things");
+// 
+const parser = Parser("prog_name", "Program to do all the things", "User defined usage string");
 ```
 
 ### Parse.addString(String, String, Bool, string -> Optional)
@@ -64,7 +68,24 @@ To add a new list argument, call the method below with at least the 3 required a
 parser.addList("-u", "active users", true, "users");
 ```
 
-### Parser.parse() -> Result\<Dict>
+### Parser.usage() -> String
+
+The Parser class will create a helpful output based on the arguments added to the parser class for you, this can be used to populate a `--help` argument.
+
+```cs
+const parser = Parser("Code!", "Some code");
+parser.addBool("--myOption", "Some useful boolean option", false);
+print(parser.usage());
+
+// Output
+usage: Code!
+    Some code
+
+    --myOption    Some useful boolean option
+
+```
+
+### Parser.parse() -> Result\<Args>
 
 The `parse` method needs to be called to process the given flags against the configured flags. `parse` returns a `Result` value that, on success, will need to be unwrapped to access an instance of the `Args` class.
 
@@ -78,8 +99,23 @@ const args = parser.parse().match(
 );
 ```
 
-The value of type `Args` will be instantiated with fields matching the configured flags or the given metavar names. Below is an example using the list argument example from above.
+The value of type `Args` will be instantiated with fields matching the configured flags or the given metavar names.
+
+If the option was not marked as required and a value for that given argument was not passed then it will have a `nil` value.
 
 ```cs
-print("Users: {}".format(args.users));
+const parser = Parser("Code!", "Some code");
+parser.addString("--option", "Some useful string option", false);
+parser.addString("--option1", "Some useful string option", false);
+const args = parser.parse().unwrap();
+
+print(args.option, args.option1);
+```
+
+CLI Input / Output:
+
+```
+$ dictu argparse.du --option "Hello"
+hello
+nil
 ```

docs/docs/standard-lib/base64.md

@@ -1,7 +1,7 @@
 ---
 layout: default
 title: Base64
-nav_order: 10
+nav_order: 2
 parent: Standard Library
 ---
 
@@ -37,4 +37,4 @@ Base64 decode a given string.
 
 ```cs
 Base64.decode("dGVzdA=="); // 'test'
-```
+```

docs/docs/standard-lib/bigint.md

@@ -1,7 +1,7 @@
 ---
 layout: default
 title: BigInt
-nav_order: 21
+nav_order: 3
 parent: Standard Library
 ---
 

docs/docs/standard-lib/datetime.md

@@ -1,7 +1,7 @@
 ---
 layout: default
 title: Datetime
-nav_order: 2
+nav_order: 4
 parent: Standard Library
 ---
 

docs/docs/standard-lib/env.md

@@ -77,4 +77,4 @@ Env.readFile(); // <Result Suc>
 
 print(Env.get("TEST")); // 10
 print(Env.get("TESTING")); // 100
-```
+```

docs/docs/standard-lib/hashlib.md

@@ -1,7 +1,7 @@
 ---
 layout: default
 title: Hashlib
-nav_order: 11
+nav_order: 6
 parent: Standard Library
 ---
 
@@ -69,4 +69,4 @@ Timing safe hash comparison. This should always be favoured over normal string c
 ```cs
 Hashlib.verify(Hashlib.sha256("Dictu"), "889bb2f43047c331bed74b1a9b309cc66adff6c6d4c3517547813ad67ba8d105"); // true
 Hashlib.verify(Hashlib.sha256("Dictu"), "wrong"); // false
-```
+```