build: add `git-chglog`

impl: update `symantic-base` dependency

build: add checks before `upload`

rename {hut => code}.sourcephile.fr

doc: update

doc: registers are now available

tests: rename {test/ => tests/}

tests: accept

copyright: comply with REUSE-3.0

machine: remove horizonStack and experiment with alwaysRaise

rename {catcher => onException}

machine: make failure be minReads=0

change ShowLetName into HideableName

machine: normalOrderReduction at the last moment

machine: fix recursion ending

add registers

Symantic.Parser is now faster than Attoparsec on the Brainfuck benchmarks:

```
$ make benchmarks b=Brainfuck/ByteString/hanoi/'*'

benchmarking Brainfuck/ByteString/hanoi/SymanticParser
time                 11.33 ms   (11.18 ms .. 11.51 ms)
                     0.999 R²   (0.998 R² .. 1.000 R²)
mean                 11.12 ms   (11.03 ms .. 11.20 ms)
std dev              219.9 μs   (164.6 μs .. 301.4 μs)

benchmarking Brainfuck/ByteString/hanoi/Attoparsec
time                 15.38 ms   (15.26 ms .. 15.52 ms)
                     0.999 R²   (0.999 R² .. 1.000 R²)
mean                 15.38 ms   (15.29 ms .. 15.49 ms)
std dev              252.1 μs   (184.3 μs .. 363.2 μs)

benchmarking Brainfuck/ByteString/hanoi/Handrolled
time                 1.608 ms   (1.595 ms .. 1.628 ms)
                     0.999 R²   (0.998 R² .. 1.000 R²)
mean                 1.585 ms   (1.575 ms .. 1.596 ms)
std dev              35.75 μs   (26.53 μs .. 51.66 μs)
variance introduced by outliers: 11% (moderately inflated)
```

deps: bump to symantic-base 0.2

doc: update

doc: fix license and {def => shareable}

doc: fix reference to Symantic.Typed

use symantic-base

rename Output to Unlifted

grammar: fix Ord SomeFailure

cabal: clean up

parsers: commit missing file

bump version

grammar: add precedence to showCode

machine: optimize ifThenElse on constant

clean warnings

machine: add another joinNext optimization when Jump is next

rename Symantic.{Univariant => Typed}

remove useless benchmarks

replace ValueCode by Production

doc: improve a bit the ReadMe.md

TemplateHaskell: why is PprSplice much faster than DumpSplice?

$ make benchmarks/prof-time b=Brainfuck/ByteString/hanoi/SymanticParser.PprSplice
benchmarking Brainfuck/ByteString/hanoi/SymanticParser.PprSplice
time                 71.19 ms   (69.66 ms .. 72.58 ms)
                     0.999 R²   (0.999 R² .. 1.000 R²)
mean                 71.91 ms   (71.10 ms .. 73.18 ms)
std dev              1.755 ms   (973.5 μs .. 2.766 ms)

$ make benchmarks/prof-time b=Brainfuck/ByteString/hanoi/SymanticParser.DumpSplice
benchmarking Brainfuck/ByteString/hanoi/SymanticParser.DumpSplice
time                 170.5 ms   (169.7 ms .. 171.0 ms)
                     1.000 R²   (1.000 R² .. 1.000 R²)
mean                 169.4 ms   (168.3 ms .. 169.9 ms)
std dev              1.046 ms   (375.5 μs .. 1.650 ms)
variance introduced by outliers: 12% (moderately inflated)

add benchmarks

nix: cleanup

test: update

machine: improve comments

machine: fix view and output

machine: fix factorize out raiseException

machine: fix mayRaise analysis of catch

more on failures

grammar: sort symantics by name

test: dump splices using TH.runQ instead of calling ghc

fix: use a global polyfix for defLet and defRef

bug: a ref outside its def must be supported

test: add goldens for TH splices

nix: update nixpkgs to use cabal-install 3.4

machine: renames trying to clarify

machine: map exceptionStack by label

doc: polish

change license to AGPL-3.0-or-later

doc: update ToDo

test: mute unused-* warnings in TH splices

machine: simplify a bit the horizon checking

test: hide unique names for reproductibility

test: sync

Rename Machine.{Build => Program}

Reorganize Comb and Instr optimizations

doc: update the ReadMe and ChangeLog

grammar: open the Comb data-type

machine: open the Instr data-type

test: unique names changed again

prepare testing splices, but cabal-install-3.4 does not build yet

Document a bit more the horizon checks

stick to ParsleyHaskell's optimizations, except on pattern-matching at the Haskell.Term level

test: save

test: save

test: save

machine: rename InstrPure{Haskell => }

test: add Nandlang parser

test: add string

grammar: rename Parser.{Haskell => Grammar.Pure}

machine: add horizon optimization

add missing golden tests in cabal tarball

move doc in *.md files

polishing before first publising

rename cabal flag dump-splice{ => s}

improve make upload

add more Nix conveniencies

fix required GHC version

add make clean

remove unneeded dependency

ignore result*

ignore dump-core/

set cabal category to Parsing (like megaparsec)

fix make tag

rename Parser.{Staging => Haskell}

clean up Nix code

comment-out unstable golden tests

prepare cabal metadata for hackage upload

fix cabal metadata

add cabal flag 'dump-core'

rename Machine.{Gen => Generate}

add join-points

move runParser to Parser

rename Machine.{Eval => Gen}

remove Hints draft

rename {Automaton => Machine}