todo.txt

TODO

* parse: SLoop(block) may be an arry of Expr or single MissingBlock() !
* parse: test VecPattern

* diagnostics: Trace Value (GUI)
     Display UI for values in context of the expression that generates them
   - Design
      Breakdown = rendering of an AST node and its sub-expression values.
      ValueBox = rendering of a value; default = Brief
      ResultBox = component that toggles between ValueBox & Breakdown
      ErrorDialog = view that shows assertion failure *at* `assert` in text
      - Breakdowns for all AST expression nodes
      - ValueBox for all V...
      - ErrorDialog & its interaction with text view
      - "jump" feature, ResultDialog anchored to expression?
      - stack view
      - ValueBox: toggling between
      - Other navigation? Step?
  - Impl simple ErrorDialog
  - Add ValueBox and Breakdown to ErrorDialog
  - ResultBox: Allow toggling of sub-expressions
  - ResultDialog: jump to anchored result
* diagnostics: Breakpoint/Step Execution?

* check arity

* Unimplemented language features:
  - eval VFUN: fall back to "call" method for non-functions
  - methods: {NAME: FUN, ...}
  - enums
  - match function-like patterns  F(a) => THEN --> F.match(V, (a) -> THEN, E)
  - Class.extend()
  - rest/spread varargs
  - arrays (in patterns)
  - dictionaries (in patterns)
  - recursive definitions (forward declarations)
  - type constructors
  - `where`
  - For
  - destructuring assignment with "else:" clause
  - Act
  - short-circuiting `or` & `and`
  - Vector & record equality
  - String syntax: `\xXX` and `\u{X...}`
  - `'` suffixes in variable names (shadowing avoidance)
  - dictionaries/hashmaps
  - named & positional arguments & defaults
  - f("...") == f"...";  f({...}) == f{...}  [?]
  - `true`, `false` as keywords (not manifest vars)
  - disallow re-binding `true`, `false`, `break`, `repeat`
     a) trap at parse time?
     b) use an IErr "wrapper" of the Fn expression?
  - treat `match` as a statement (no match => rest of block)
  - `match VALUE in ENUM: Foo => A` --> `match VALUE: ENUM.Foo => A`
  - allow match cases to `break`, `repeat`, and re-bind loop vars

* Visualize execution
  - collect execution trace
  - capture start & end of elements

* riodoc: concepts.txt --> concepts.md
  1. [[a b c]]  -->  [a b c](#a-b-c)
  2. Broken link detection
  3. "See also: ..."
  4. Index
  5. Comments


################################################################

---- Long-term

 * "P1" (Phase 1) language definition
 * P1 "bootstrap" interpreter (JavaScript)
    - parse & walk AST
    - minimal set of OS bindings
 * P2 interpreter/compiler (written in Rio P1, supports P2 superset)
    - compiles to Wasm
    - obsoletes bootstrap
    - may leak memory: okay for self-hosting, target programs
      are faster than when interpreted by P1.
 * P3 interpreter/compiler (built using P2)
    - more than self-hosting: non-leaking, clean semantics
 * Choose native VM: Wasmtime, Wasmer, ?
 * OS (WASI?) bindings
 * Web Server
 * P3+: Richer data structuring, lazy/parallel/etc., ...
 * IDE
   - display values (or `pending...`) [computed in parallel VM]