utkrisht 0.1.0 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "utkrisht",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "A unified language for the web.",
   "homepage": "https://github.com/LadyBeGood/utkrisht#readme",
   "bugs": {

package/readme.md

@@ -20,35 +20,15 @@
 
 
 ## Installation
-> [!WARNING]
-> Do not install this now, everything is broken and has errors.
-
-
-### Prerequisites
-[Install Nim](https://nim-lang.org/install.html)
-
-### Steps
-Clone this repository
-```
-git clone https://github.com/LadyBeGood/utkrisht.git
-```
-
-Compile the compiler
 
 ```bash
-nim c --d:release --opt:speed --passC:-flto --out:uki --verbosity:0 ./utkrisht/compiler/uki.nim
+npm install -g utkrisht
 ```
-
-(Optional) Clean up the repository after successful compilation:
-```bash
-rm -rf utkrisht
-```
-
 ### Example usage
 Compile a input.uki file to output.js file:
 
 ```bash
-./uki input.uki output.js
+uki input.uki output.js
 ```
 
 ## Tutorial
@@ -76,7 +56,7 @@ You can document a variable by directly placing comments above it. These comment
 # Divide 2 numbers
 # - `a`: Numerator
 # - `b`: Denominator
-divide a, b: {
+divide a, b ~ {
     exit a / b
 }
 ```
@@ -90,20 +70,48 @@ divide a, b: {
 
 
 ### Data types
-Utkrisht has 5 data types.
+Utkrisht has **5 data types**.
 
-| Data Type | Passed by | Clonable | iterable | Mutable | Callable |
-|-----------|-----------|----------|----------|---------|----------|
-| String    | Value     | Yes      | Yes      | No      | No       |
-| Number    | Value     | Yes      | No       | No      | No       |
-| Boolean   | Value     | Yes      | No       | No      | No       |
-| Procedure | Reference | No       | No       | No      | Yes      |
-| Structure | Reference | Yes      | Yes      | Yes     | No       |
+| Data Type     | Passed by | Clonable | iterable | Mutable | Callable | Hashable          |
+|---------------|-----------|----------|----------|---------|----------|-------------------|
+| **String**    | Value     | Yes      | Yes      | No      | No       | Yes               |
+| **Number**    | Value     | Yes      | No       | No      | No       | Yes<sup>[1]</sup> |
+| **Boolean**   | Value     | Yes      | No       | No      | No       | Yes               |
+| **Procedure** | Reference | No       | No       | No      | Yes      | Yes               |
+| **Structure** | Reference | Yes      | Yes      | Yes     | No       | Yes               |
 
+> [!NOTE]
+> [1] All numbers including `nan` are hashable and can be used as keys. 
+> Structure uses the algorithm [SameValueZero](https://tc39.github.io/ecma262/#sec-samevaluezero) to test keys for equivalnce. 
+> So `nan` is considered equal to `nan`.
 
 #### String
-A string represents a sequence of UTF-16 code units, identical to JavaScript strings.
+Strings are used to store textual data. 
+
+Strings can be created using double quotes:
+```
+# Single line strings
+"This is a single line string."
 
+# Multi line string
+"
+    This is a multiline string.
+    * These strings are allowed to span multiple lines.
+    * They need to be properly indented.
+    * Leading spaces, spaces and newline after starting quote and newline after ending quote are all trimmed off.
+"
+```
+
+Special characters
+| Character | Description     |
+|-----------|-----------------|
+| `\n`      | New Line        |
+| `\r`      | Carriage Return |
+| `\"`      | Quote           |
+| `\\`      | Backslash       |
+| `\t`      | Tab             |
+
+A string is represented internally a sequence of UTF-16 code units, identical to JavaScript strings, and thus share the same quirks.
 ```
 write length "😼"       #> 2
 write "😼".1            #> \ud83d
@@ -137,23 +145,23 @@ nan            # stands for "not a number", but this is also a number
 ```
 
 ```
-write 123 = 123.0             #> right
+(123 = 123.0)             #-> right
 
-write 0 = 0                   #> right
-write -0 = -0                 #> right
-write 0 = -0                  #> right
+(0 = 0)                   #-> right
+(-0 = -0)                 #-> right
+(0 = -0)                  #-> right
 
-write infinity = infinity     #> right
-write infinity = -infinity    #> wrong
-write -infinity = -infinity   #> right
+(infinity = infinity)     #-> right
+(infinity = -infinity)    #-> wrong
+(-infinity = -infinity)   #-> right
 
-write nan = nan               #> wrong (This is not a typo)
-write nan != nan              #> right (This is also not a typo)
+(nan = nan)                #-> wrong (This is not a typo)
+(nan != nan)               #-> right (This is also not a typo)
 
-write is-finite 123           #> right
-write is-finite infinity      #> wrong
-write is-finite -infinity     #> wrong
-write is-nan nan              #> right
+is-finite 123             #-> right
+is-finite infinity        #-> wrong
+is-finite -infinity       #-> wrong
+is-nan nan                #-> right
 ```
 
 ```
@@ -178,16 +186,16 @@ Boolean literals are represented by the keywords `right` and `wrong`. There are
 
 Keywords are predefined words used by the language to perform internal operations or represent built-in behavior. 
 
-Utkrisht has **13 keywords**. None of them are reserved and may also be used as [identifiers](#identifiers).
+Utkrisht has **14 keywords**. None of them are reserved and may also be used as [identifiers](#identifiers).
 
-| Keywords                          | Description                                   |
-|-----------------------------------|-----------------------------------------------|
-| `right`, `wrong`                  | Boolean literals                              |
-| `when`, `else`                    | Conditional branching                         |
-| `loop`, `with`, `stop`, `skip`    | Looping and loop control                      |
-| `try`, `fix`                      | Error handling                                |
-| `exit`                            | Exiting from a procedure                      |
-| `import`, `export`                | Module import and export                      |
+| Keywords                    | Description              |
+|-----------------------------|--------------------------|
+| `right` `wrong`             | Boolean literals         |
+| `when` `else`               | Conditional branching    |
+| `loop` `with` `stop` `skip` | Looping and loop control |
+| `try` `fix`                 | Error handling           |
+| `exit` `give`               | Exiting from a procedure |
+| `import` `export`           | Module import and export |
 
 
 
@@ -209,11 +217,11 @@ Operators are symbols used to perform operations on values.
 |---------------------------------------|-------------------------------------------|---------------------------------------------------------|
 | `:` `=`                               | Infix                                     | Variable declaration and reassignment                   |
 | `+` `-` `*` `/`                       | Infix                                     | Arithmetic operations                                   |
-| `=` `<` `>` `!=` `!<` `!>`            | Infix                                     | Comparison operations                                   |
-| `&`, `\|`, `!`                        | Infix (except `!`, which is prefix)       | Logical operations                                      |
+| `=` `<` `>` <br />`!=` `!<` `!>`      | Infix                                     | Comparison operations                                   |
+| `&` `\|` `!`                          | Infix (except `!`, which is prefix)       | Logical operations                                      |
 | `_`                                   | Infix                                     | Range construction                                      |
 | `.`                                   | Infix                                     | Access operator                                         |
-| `;`                                   | Postfix                                   | Procedure call                                          |
+| `!`                                   | Postfix                                   | Procedure call                                          |
 | `/`                                   | Prefix                                    | Module access operator                                  |
 | `@`                                   | Prefix                                    | Async operator                                          |
 | `$`                                   | Prefix                                    | Reactivity operator                                     |
@@ -229,8 +237,8 @@ Separators are symbols used to divide syntactic elements without performing an o
 | Separator | Separates                                                    |
 |-----------|--------------------------------------------------------------|
 | `,`       | Arguments, Parameters, Properties                            |
-| `~,`      | Arguments  (use default value for the parameter)             |
-| Newline   | Arguments, Parameters, Properties (non-terminating contexts) |
+| `!,`      | Arguments  (use default value for the parameter)             |
+| NewLine   | Arguments, Parameters, Properties (non-terminating contexts) |
 
 
 
@@ -255,7 +263,7 @@ Terminators mark the end of a statement or declaration.
 
 | Terminator | Terminates                                  |
 |------------|---------------------------------------------|
-| Newline    | Statements, Comments (terminating contexts) |
+| NewLine    | Statements, Comments (terminating contexts) |
 | EndOfFile  | Statements, Comments                        |
 
 
@@ -265,7 +273,7 @@ Identifiers are names given to different entities in Utkrisht to uniquely identi
 
 ```
 # variables
-message: "hi"
+message ~ "hi"
 
 # structure keys
 [name = "Uki"]
@@ -307,13 +315,13 @@ Variables are identifiers used to store data. All variables are mutable and can
 
 
 
-Declare a variable using `:`
+Declare a variable using `~`
 ```
-message: "Hello World"
+message ~ "Hello World"
 ```
 Reassign a value using `=`
 ```
-quantity: 34
+quantity ~ 34
 
 quantity = 65
 quantity = "high" # Data type of the value does not matter
@@ -323,24 +331,33 @@ quantity = "high" # Data type of the value does not matter
 Control flow determines how execution proceeds through a program.  
 
 #### Conditionals
-Conditionals control which procedure will be invoked based on a **condition**. The condition must be a boolean value, Utkrisht does not have truthy or falsy values. 
+Conditionals control which block will be executed based on a **condition**. The condition must be a boolean value, Utkrisht does not have truthy or falsy values. 
 ```
-# Statement conditionals
-when age > 18
-    write "You're an adult"
-else age < 18
+# Conditional statement
+when age < 13 
     write "You're a child"
+else age > 19
+    write "You're an adult"
 else
-    write "You're no longer a child, you became an adult!"
+    write "You're a teen"
 
 
-# Expression conditionals
-status: when age < 18 "minor" else "adult"
+# Multiline conditional expression
+status ~ 
+    when age < 13 
+        "child"
+    else age > 19
+        "adult"
+    else
+        "teen"
+    
+# Singleline conditional expression
+status ~ when (age < 13) "child" else (age > 19) "adult" else "teen"
 ```
 #### Loops
 Loop is a data type sensitive construct. Therefore the behaviour of the loop depends upon the data type of the data following it.
 ```
-# loop keyword followed directly by a procedure
+# loop keyword not followed by any data type
 # loops infinitely
 loop
     write "hello"
@@ -363,7 +380,7 @@ loop 5 # loops 5 times
 
 # loop keyword followed by a string or structure
 # loops `length iterable` times 
-loop "uki" # loops 3 times because there are 2 characters in "uki": "u", "k" and "i"
+loop "uki" # loops 3 times because there are 3 characters in "uki": "u", "k" and "i"
     write "hello"
 
 loop [id = 567, right, "orange"] # loops 3 times
@@ -477,15 +494,14 @@ A module can be imported using the `import` keyword followed by its path:
 import utilities 
 import components/footer
 import ../assets/icons
-import routes/[home, notifications, profile]
 ```
 When you write an import like `import abc`, the compiler looks for:
 - a file named `abc.uki`, or
 - a folder named `abc` that contains a file named `abc.uki`.
 
 #### Export
-Use the `export` keyword available to other modules:
+Use the `export` keyword to make the variable available to other modules that import it:
 ```
-export message: "hi"
+export message ~ "hi"
 ```