Merge pull request #51 from samarium-lang/0.6.0

0.6.0

Author: trag1c

.github/workflows/ci.yml

@@ -3,6 +3,4 @@
 __pycache__
 test
 dist/
-site/
-src/*
-!src/samarium/
+site/

.gitignore

@@ -5,6 +5,36 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.6.0] - 2024-06-14
+
+### Added
+- `=>!` now accepts strings
+- Added an exception note for `string.split`
+- Allowed adding notes for `!!!`
+- Command system for the REPL
+- Data classes
+- Function composition
+- Made the semicolon optional for `!`, `!!!`, `*`, `**`
+- `math.max` and `math.min` now work with varargs
+- `String+`
+- `-String`
+- `~Table`
+- The REPL now automatically displays most expressions
+
+### Changed
+- `String ++ -Number` now throws a type error (ambiguous operation)
+
+### Fixed
+- Fixed function conversion when `@export`ing
+- Fixed internal name of `math.round`
+- Fixed `math.sqrt` using an incorrect variable name
+- Fixed multiline string handling in the REPL
+- Fixed REPL quitting on syntax error
+- `math.round` now correctly provides a default value for `ndigits`
+- The transpiler now correctly disallows literals around identifiers
+- `types.Boolean` should now correctly interract with external types
+- Various minor fixes to the transpiler
+
 ## [0.5.3] - 2023-04-21
 
 ### Fixed
@@ -401,4 +431,5 @@ Initial release 🚀
 [0.5.0]: https://github.com/samarium-lang/Samarium/compare/0.4.0...0.5.0
 [0.5.1]: https://github.com/samarium-lang/Samarium/compare/0.5.0...0.5.1
 [0.5.2]: https://github.com/samarium-lang/Samarium/compare/0.5.1...0.5.2
-[0.5.3]: https://github.com/samarium-lang/Samarium/compare/0.5.2...0.5.3
+[0.5.3]: https://github.com/samarium-lang/Samarium/compare/0.5.2...0.5.3
+[0.6.0]: https://github.com/samarium-lang/Samarium/compare/0.5.3...0.6.0

CHANGELOG.md

@@ -31,7 +31,8 @@ If we want to remove duplicates of just one value, we can use `---`:
 
 > `[/\\\, //, //, //\, /\\\, //, /\/] --- //` gives `[/\\\, //, //\, /\\\, /\/]`
 
-Set-like union, interection, and symmetric difference can be obtained by using `|`, `&` and `^`, respectively:
+Set-like union, intersection, and symmetric difference can be obtained by using
+`|`, `&` and `^`, respectively:
 
 ```sm
 primes: [/\, //, /\/, ///, /\//, //\/]!;

docs/arrays.md

@@ -28,17 +28,27 @@ This function will return what it writes to stdout (though not necessarily as
 a string), and can thus be used in an assignment statement for example.
 
 ```sm
-x: //\!;
+x: //\!  == optional semicolon after !
 == the string "6" is written to stdout, and `x` now has the value 6 (number)
 ```
 
 
 ## THROW
 
-Similarly to PRINTLN, objects can be written to standard error using `!!!`.
+Similarly to PRINTLN, some objects can be written to standard error using `!!!`.
 This will throw an error, and exit the program if the error is not caught.
+Only strings and arrays of length 2 can be used for throwing errors.
 
-`"exception raised"!!!` will write `[Error] exception raised` to standard error.
+```sm
+"exception raised"!!!  == optional semicolon after !!!
+== the following is written to stderr:
+== [Error] exception raised
+
+== 2-element arrays can be used for adding notes to exceptions:  
+["invalid date format", "use YYYY-MM-DD format"]!!!
+== [Error] invalid date format
+== [Note] use YYYY-MM-DD format
+```
 
 
 ## EXIT
@@ -48,6 +58,11 @@ If a particular exit code is desired, it may be put after the exclamation mark:
 
 `=>! //` will exit the program with exit code 3.
 
+A string may also be supplied instead of a number, which will first write it to stderr
+and then exit the program with exit code 1.
+
+> `=>! "uh oh";` is equivalent to `"uh oh\n" ~> /\; =>! /;`
+
 
 ## HASH
 

docs/builtins.md

@@ -199,3 +199,56 @@ multiply.outputs!;  == [10, 21, 108]
 [^1]: Note that order will be preserved here — if both class `A` and class `B`
 implement a function `f`, and class `C` inherits them in the order `(A, B)`,
 then `C` will inherit `f` from class `A`, as it is inherited later.
+
+
+## Data Classes
+
+Samarium has a shorthand syntax for defining classes whose main purpose is
+storing data:
+```sm
+@ Person {
+    => name age * {
+        'name: name;
+        'age: age;
+    }
+
+    ! * { * "$0($1, $2)" --- ['?!, 'name, 'age]; }
+    :: other * { * ['name, 'age] :: [other.name, other.age]; }
+    > other * { * ['name, 'age] > [other.name, other.age]; }
+    >: other * { * ['name, 'age] >: [other.name, other.age]; }
+}
+```
+The above definition can be replaced with just
+```sm
+@! Person(name, age);
+```
+If we wish to define additional methods, we can just open a pair of braces after
+we specify the name and the fields like in a regular class:
+```sm
+@! Person(name, age) {
+    birthday * { 'age+:; }
+}
+
+p: Person("Jake", /\\//)!  == Person("Jake", 19)
+p.birthday();
+p!  == Person("Jake", 20)
+```
+If you'd like your dataclass to not have any fields, you can either leave the
+parentheses empty or omit them entirely:
+```sm
+@! Unit(); Unit()!  == Unit()
+@! Unit; Unit()!  == Unit()
+```
+
+By default, all dataclass instances have a special method defined which returns
+its copy:
+```sm
+@! Person(name, age);
+
+p: Person("Bob", /\\//);
+q: p;
+r: p$;
+q.name: "Alice";
+r.name: "Dave";
+p, q, r!  == Person("Alice", 19) Person("Alice", 19) Person("Dave", 19)
+```

docs/classes.md

@@ -7,7 +7,7 @@
 => argv * {
     file: argv<</>>;
     data <~ file;
-    data<<....-/>> ~> file;
+    -data ~> file;
 }
 ```
 

docs/examples.md

@@ -23,6 +23,14 @@ b: /\;
 c: add(a, b);
 ```
 
+If no value is returned, the semicolon after `*` may be omitted:
+
+```sm
+exit code * {
+    ? code {*}
+    "Success"!;
+}
+```
 
 ## Main Function
 
@@ -162,10 +170,62 @@ Primes below 100:
 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
 ```
 
+Just like with `*`, the semicolon after `**` can be omitted if no value is
+yielded:
+```sm
+foo * {**}
+
+[]?!(foo())!  == [null]
+```
+
 Iterators support special `$` and cast `%` methods.
 
 `Iterator%` returns the length of the iterator if available, and null otherwise.
 
 `Iterator$` yields the next value of the iterator.
 
 Iterators are always truthy.
+
+
+## Function Composition
+
+Functions, types, and type aliases in Samarium can be composed together by using
+the `&` operator:
+
+```sm
+(<-math.sqrt & <-operator.add)(//, //\)!  == 3
+(<-types.Boolean & /?!)("1")!  == true
+```
+```sm
+<=math.[abs, max, min];
+arrmap: []?! & <-iter.map;
+arrmap(abs, [/, `/, //\, -/\\, -/\/])!  == [1, 0.5, 6, 4, 5]
+
+high x * { * min([x, /\/]); }
+low x * { * max([x, \]); }
+clamp: high & low;
+
+x: []?!(<<-//../\\/>>)!  == [-3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8]
+arrmap(clamp, x)!  == [0, 0, 0, 0, 1, 2, 3, 4, 5, 5, 5, 5]
+```
+```sm
+compose funcs... * {
+    * <-iter.reduce(<-operator.and, funcs);
+}
+
+repeat_function func times * {
+   * compose(**[func]++times);
+}
+
+foo x * {
+    out: x +++ /?!("0.1")!
+    * out;
+}
+
+repeat_function(foo, /\/)(`/);
+== 0.9330329915368074
+== 0.9930924954370359
+== 0.9993070929904525
+== 0.9999306876841536
+== 0.999993068552217
+```

docs/functions.md

@@ -20,18 +20,4 @@ null:;
 y :: null && null ->? z!;
 ```
 
-The null value is not inserted implicitly for method calls, therefore:
-```sm
-V: .to_bit();
-```
-has to be written as
-```sm
-null:;
-V: null.to_bit();
-```
-or – without introducing any variables – as
-```sm
-V: (||).to_bit();
-```
-
 Converting null to a number yields the value `0`.

docs/null.md

@@ -22,8 +22,8 @@ Function                             | Use
 `is_int(x)`                          | Returns `1` if `x` is an integer, `0` otherwise. Equivalent to `x :: x$`.
 `is_prime(n)`                        | Returns `1` if `n` is prime, `0` otherwise.
 `lcm(a, b)`                          | Returns the least common multiple of `a` and `b`.<br>If any of the arguments is zero,<br> then the returned value is `0`.
-`max(array)`                         | Returns the largest value in `array`.
-`min(array)`                         | Returns the smallest value in `array`.
+`max(array[, values...])`            | Returns the largest value in `array` if only one argument is passed,<br>otherwise returns the largest value in `[array] + values`.
+`min(array[, values...])`            | Returns the smallest value in `array` if only one argument is passed,<br>otherwise returns the smallest value in `[array] + values`.
 `product(array)`                     | Multiplies the items of `array` from left to right and returns the total.<br>The `array`'s items must be numbers.
 `round(x[, ndigits])`                | Returns `x` rounded to `ndigits` precision after the decimal point.<br>Works exactly like Python's [`round()`](https://docs.python.org/3/library/functions.html#round).
 `shl(a, b)`                          | Returns `a` shifted to the left by `b` bits.