The use cases involve user-expandable grammars.
For example, consider the IRC nickname specification.
> They SHOULD NOT contain any dot character ('.', 0x2E).
> Servers MAY have additional implementation-specific nickname restrictions.
To implement this, we can do something along these lines:
```janet
(def nickname @{:main '(some :allowed)
:allowed (! (+ :forbidden/dot :forbidden/user))
# for lax mode, (put nickname :forbidden/dot false)
:forbidden/dot "."
# to add your own requirements
# (put nickname :forbidden/user 'something)
:forbidden/user false})
```
Additionally, it's common in parsing theory to allow matches of the
empty string (epsilon). `true` essentially allows for this.
Note that this does not strictly add new functionality, you could
emulate this previously using `0` and `(! 0)` respectively, but this
should be faster and more intuitive.
The speed improvement primarily comes from `(! 0)` which is now a single
step.
Previously, `*macro-lints*` was set after the `macroexpand1` fiber was
resumed, rather than just before. And, `*macro-lints*` was never
cleared. This behavior was typically fine since the main users of
`compile` pass the same lint array repeatedly, and the first macro
expansion (somewhere in boot.janet) never produces a lint. But, when
compiling with a fresh lint array, if the first macro invocation
produced a lint, the lint was always lost.
When suspended in `ev/give` or `ev/take`, closing the channel should
cause the result of `ev/give` or `ev/take` to be `nil`.
When suspended in `ev/select`, closing the channel should cause the
result of `ev/select` to be `[:close ch]`.
The results were flipped before.
When there is a bad arity function passed in to the fiber
constructor, return NULL so the runtime can choose what to do.
This is not the prettiest API but does work, and gives better error
messages for instance in the compiler.
Coming from commit 77189b6e66, relating
to changes in source mapping debug info, this caused a segfault when
traversing a stack frame where the birth_pc was incredibly large due
to wrap around. This fix prevents the wrap around and does saturating
subtraction to 0.
Chloe Kudryavtsev