TODO
====
### C implementation ###
* implement buffers in C in libtamsin
* implement pattern match in send in C compiler
### higher-priority ###
* allow switching the kind of buffer that is used when `@` is used:
* `rule @ %stdin` is the default; it is implied when no `@`
* `rule @ %mmap` to use an MmapBuffer
* `rule @ %line` to use a LineEditorBuffer
* `rule @ $:open('file.txt')` ?
* `$:add`, `$:sub`, `$:mul`, `$:div`, `$:rem`, for atoms which look like
integers: `["-"] & {$:digit}`.
* `$:tell` and `$:seek` the implicit buffer — for VM's etc — although
note, this may have scary consequences when combined with backtracking
* `(foo → S | ok)` & print S ... should set S to error if foo failed?
or `(foo |→ S ok)` ? This is necessary for the meta-circular
interpreter: to implement `A | B` we want to interpret `A` and see
if it failed or not. i.e. We want to be able to reify errors...
### medium-priority ###
* Starting with knowns about `$` builtins, an analysis to determine, for Rule:
- may consume input, never consumes input
- may fail, always fails
- may succeed, always succeeds... (may_backtrack?)
* production values
* `$:fold(^production, nil, cons)`
* `$:fold(^($:alnum & " "), '', ^L+','+R)`
* codegen and emitter phases in compiler. take current compiler phase,
make it construct a low-level representation instead (codegen), then
have a phase that writes out C code from that low-level repr (emitter)
* non-backtracking versions of `|` and `{}`: `|!` and `{}!`
### testing ###
* test for `''('')`, `'\x00'('\x00')`
* document how prod scanners do EOF
* tests that `'V'` is not a variable
* tests for failing when utf8 scanner hits badly-encoded utf8
* tests for invalid escape codes
* test for mismatched # of formals in prod branches
* document the modules. in own document. plus tests.
### lower-priority ###
* `ctype` module, with `alpha` and `digit` and etc.
* `list` module: `deep_reverse`
* use Tamsin repr in error messages
* __str__ should be Tamsin repr()?
* regex-like shortcuts: `\w` for "word", `\s` for "whitespace", etc.
* have compiler replace calls to `list` functions
by "more efficient" versions written in C -- if they really are...
* and maybe even garbage-collect terms in libtamsin
* figure out why reading a 4M file in a compiled program TAKES DOWN UBUNTU
* make it possible to recover from more errors using `|` (don't throw
exceptions so often)
* stronger tests for scanner, parser: dump all falderal testbodies to files
* option for ref interp to not output result (or by default, don't)
* "mini" interpreter that handles variables (ouch)
* error handling: skip to next sentinel and report more errors
* module-level updatable variables. or globals. or "process dictionary"
`$:store()` and `$:fetch()`. or database.
* figure out good way to do aliases with the Tamsin-parser-in-Tamsin
(dynamic grammar is really more of a Zz thing...)
* should be able to import ("open") other modules into your own namespace.
* `@` a la Haskell in pattern-match:
* `walk(T@tree(L,R)) = ...`
* maps, implemented as hash tables.
* `Table ← {} & fields → F@fields(H,T) & Table[H] ← T`
* pretty-print AST for error messages
### symbol fun ###
* `~` (Lua) for not and `!` (Prolog) for non-backtracking?
* lowercase greek letters are variables too!
* use `←` instead of `@`, why not?
* I'm always typing `prod() → rule` instead of `=`, so why not?
* `A;B` — like `&` except assert (statically) that `A` always succeeds
* be generous and allow `"xyz"` in term context position?
* denotational semantics sugar! something like...
⟦add α β⟧ = $:add(⟦α⟧, ⟦β⟧).
and/or
⟦add α β⟧(σ) = $:add(⟦α⟧(σ), ⟦β⟧(σ)).
⟦var α⟧(σ) = fetch(σ, α).
of course, DS is a bit fast-and-loose about actual parsing...
but the syntax looks mighty fine.
### wild ideas ###
* term-rewriting library; a la Treacle; should make desugarer almost trivial
* algebraically cool version of `|`, perhaps as a worked example
(implement Bakerloo in Tamsin)
* EOF and nil are the same? it would make sense... call it `end`? (do we?)
* productions with names with arbitrary characters in them.
* something like «foo» but foo is the name of a *non*terminal — symbolic
production references (like Perl's horrible globs as a cheap substitute
for actual function references or lambdas.)
* turn system library back into built-in keywords (esp. if : can be used)
* Tamsin scanner: more liberal (every non-alphanum+_ symbol scans as itself,
incl. ones that have no meaning currently like `*` and `?`)
* auto-generate terms from productions, like Rooibos does
* token classes... somehow. (then numeric is just a special token class?)
a token class is just the "call stack" of productions at the time it
was scanned
* «» could be an alias w/right sym (`,,`, `„`)
(still need to scan it specially though)
* special form that consumes rest of input from the Tamsin source --
maybe not such a gimmick since micro-tamsin does this
* feature-testing: `$.exists(module) | do_without_module`
* ternary: `foo ? bar : baz` — if foo succeeded, do bar, else do baz.
I don't think this is very necessary because you can usually just say
`(foo & bar) | baz` — but only if `bar` always succeeds, which it
usually does (to return something)