Every once in a while I investigate low-level backend options for PL-s, although so far I haven't actually written any such backend for my projects. Recently I've been looking at precise garbage collection in popular backends, and I've been (like on previous occasions) annoyed by limitations and compromises.
I was compelled to think about a system which accommodates precise relocating GC as much as possible. In one extreme configuration, described in this note, there
| -- Minimax and alpha-beta pruning | |
| -- | |
| -- Minimax can trivially be generalized to work on any lattice (@gminimax@). | |
| -- Then alpha-beta is actually an instance of minimax. | |
| -- | |
| -- Contents: | |
| -- 0. Basic definitions: players and games | |
| -- 1. Direct implementations of minimax and alpha-beta | |
| -- 2. Generalized minimax and instantiation to alpha-beta | |
| -- 3. QuickCheck tests |
A traditional table-based DFA implementation looks like this:
uint8_t table[NUM_STATES][256]
uint8_t run(const uint8_t *start, const uint8_t *end, uint8_t state) {
for (const uint8_t *s = start; s != end; s++)
state = table[state][*s];
return state;
}
| // We have five kinds of nodes: literal, negate, not, add, xor. | |
| // In this case we only need 3 bits for the tag but you can use as many as you need. | |
| enum Tag { | |
| LIT, | |
| NEG, | |
| NOT, | |
| ADD, | |
| XOR, | |
| }; |
| {-# OPTIONS --rewriting #-} | |
| module cont-cwf where | |
| open import Agda.Builtin.Sigma | |
| open import Agda.Builtin.Unit | |
| open import Agda.Builtin.Bool | |
| open import Agda.Builtin.Nat | |
| open import Data.Empty | |
| import Relation.Binary.PropositionalEquality as Eq |
I recently happened upon a very interesting implementation of popen() (different API, same idea) called popen-noshell using clone(2), and so I opened an issue requesting use of vfork(2) or posix_spawn() for portability. It turns out that on Linux there's an important advantage to using clone(2). I think I should capture the things I wrote there in a better place. A gist, a blog, whatever.
This is not a paper. I assume reader familiarity with
fork()in particular and Unix in general, though, of course, I link to relevant wiki pages, so if the unfamiliar reader is willing to go down the rabbit hole, they should be able to come ou
The imports for building the various field-oriented optics are pretty minimal. It's not
until you make a Getter or a Fold that you need to look outside of base.
This cookbook only covers the field oriented optics and not the constructor oriented ones.
If you want to build a Prism or an Iso without a lens dependency, you should
copy the definition of lens' prism and iso combinators and add a profunctors dependency
to your project. Those two combinators are quite self-contained.
| install: | |
| - sudo apt-get install texlive-latex-recommended texlive-latex-extra texlive-fonts-recommended | |
| - sudo apt-get install chktex | |
| script: | |
| - make | |
| - chktex -W # Print version information. | |
| - chktex -q -n 6 *.tex chapters.*.tex 2>/dev/null | tee lint.out | |
| # If lint output is non-empty report an error. | |
| - test ! -s lint.out |
The indexed state monad is not the only indexed monad out there; it's not even the only useful one. In this tutorial, we will explore another indexed monad, this time one that encapsulates the full power of delimited continuations: the indexed continuation monad.
The relationship between the indexed and regular state monads holds true as well for the indexed and regular continuation monads, but while the indexed state monad allows us to keep a state while changing its type in a type-safe way, the indexed continuation monad allows us to manipulate delimited continuations while the return type of the continuation block changes arbitrarily. This, unlike the regular continuation monad, allows us the full power of delimited continuations in a dynamic language like Scheme while still remaining completely statically typed.