Vyxal

_Huge thanks to AMiller42 for pointing out bugs so they can be squashed._

What's New?

- added roots to polynomial element (`∆ṙ`)
- added dictionary compression element (`øD`)
- added split on words (read as: groups of letters) (`øW`)
- revamped the vectorisation system to hopefully work a little better
- added diagonals of a matrix element (`ÞD`)
- multiplying a lambda by a number changes its arity (compare [`3 4λ+;†`](http://lyxal.pythonanywhere.com?flags=&code=3%204%CE%BB%2B%3B%E2%80%A0&inputs=&header=&footer=) with [`3 4λ+;2*†`](http://lyxal.pythonanywhere.com?flags=&code=3%204%CE%BB%2B%3B2*%E2%80%A0&inputs=&header=&footer=))
- The `Ṁ` flag was added. It is equivalent to having both `M` and `m` flags.
- the online interpreter was added to the GEORGE web ring

What's Changed?

- `Ǎ` removed all letters instead of all non-letters (26). It now works like it should. (Thanks AMiller42)
- Vectorisation now turns off implicit output if printing happens (e.g. `v,` now does what you would expect.). (28) (Thanks AMiller42)
- `∑` now vectorises correctly (30)
- `꘍` works properly too (31)
- `Þ×`'s command wasn't assigned properly (34) (thanks AMiller42 for noticing and fixing this)
- `æ` wasn't returning an integer, but rather a `bool` object. This is fixed. (36)
- `Ė ` used to push a 0 after executing a string (utterly useless). It doesn't anymore. (38)

---

There's probably a few other things that I've missed, but this is most of what's happened since v2.0.0a

What's new

- New codepage
- New commands
- Lots of new things

Why is there a new version 2?

Because a lot of bugs have been fixed since the first v2.0.0

You should use this version, as:

- the codepage is assuredly fixed
- some commands that weren't implemented are now implemented properly
- this has the most recent stable version of the online interpreter
- better docs
- changed most characters in vyparse too
- and a whole lot more

_This is the last 1.x.x release before 2.0_

What's New?

- Added an `is_significant()` built-in
- Fixed an issue with splitting on newlines
- There were a few issues with the trig commands.

_And to think I thought I'd not wait until 100 new commits to make a new release..._

What's New

- There was some problems/issues/pain with counted generators. Now there isn't. You're welcome.
- Generator printing should now be objectively better
- Added run length encoding and decoding built-ins
- Added lots of math commands from python's `math` library as two-byte stuff. (Thanks to 2x-1 for the trig commands!)
- `ĸ` now does absolute difference. To get the old functionality (distribute evenly), use `Þĸ`
- `∆K` does the sum of proper divisors ([example](http://lyxal.pythonanywhere.com?flags=&code=12%E2%88%86K&inputs=&header=&footer=))
- Implicit lambda mapping now goes from `[1, n]` instead of `[0, n]`. To make it go `[0, n]`, use `-M` flag
- Fixed the safe evaluation regex on the online interpreter
- Documented a whole bunch of overloads of commands involving functions.
- `¼` no longer divides by 4. It pushes `a[0]` and `a[1:]` to the stack instead.
- Added a Keg Mode flag (for treating input as lists of character codes instead of strings)
- Added `l` flag that uses the length of the top of the stack as implicit output
- Added `g` flag that takes minimum of top of stack as implicit output
- Added `G` flag that takes maximum of top of stack as implicit output
- There's now way more constants. And they're documented in reference.txt/reference.md as well now! So much fun!
- Added a lot more 2 byte commands - so many that it's impractical to list them all here. Go check out reference.txt/reference.md for info.

What's New?

- Fixed an issue where filtering over a number (which creates a range from `[0..n]`) wouldn't actually filter anything.
- Fixed GCD over a list (one-argument GCD)
- Fixed a bug with transpose
- Added the ability to print without a newline
- Removed `time.sleep` built-in (it will be added back soon as a 2 byte built-in)
- Implemented 2 argument GCD
- Fixed taking the GCD of two strings.
- Changed `"` to be a filter lambda and `'` to be a 3-character lambda.
- Moved stack rotation into the two-byte misc. commands.
- Fixed a bug with shifting the stack left
- Improved the performance of counted generators (i.e. made them act a bit more as expected)
- `!` still was implemented with the code from before the re-write (using the custom Stack class I had). That's now fixed, and `!` works again.
- `Ï` now acts as a "collect until no change" generator when one of its arguments is a function. It still acts as normal when no arguments are functions
- Changed the functionality of `Ṛ` to split items rather than choose a random number between `a` and `b`. Simulateable via `⁂℅`.
- Fixed issues where fractionify didn't actually give the simplest representation.
- Added the `-d` flag, which flattens then sums the top of stack before outputting.
- `ſ` still pushes `69` to the stack, but only if the top of the stack is a string or a number. Otherwise, it pushes `top[1:]`
- Fixed a parsing issue with two-character lambdas
- Added two-byte lambdas (probably should have these last two swapped, but, eh)
- Removed confusing information from the documentation for constants.
- There were two copies of `ð` in the codepage (which caused some issues when compressing strings). Now there is only one copy. The new character is `µ` and doesn't have a use yet.
- The online interpreter used to only split input on `\n`. Turns out that was missing the extra `\r` the server puts into the box. Now it splits input on `\n\r`
- Added the `-r` flag which makes everything take arguments in reverse.
- `⧢` now returns a list of strings if the input is a string.
- `r` no longer errors if there isn't a regex match among its arguments
- Added the `-S` flag to join the top of the stack on spaces before outputting
- `ř` also has a new function overload. If any of the first two arguments are functions, it pops a third value and repeatedly applies the first function to the third value while the second function is true. In other words, repeat while condition.
- You can now centralise text in a list. You can also palindromise things without having the middle character repeated.
- You can also centralise text with a flag at the end of execution.