Idea:
separate function-like, closure and function in type.
Then type driven closure conversion

val f: function-like = if xx then g:  function else h: closure

↓

val f: closure = if xx then force-closure(g):  closure else h: closure

,

val f: function-like = if xx then g:  function else h: function

↓

val f: function = if xx then g:  closure else h: function

ast2hir fails to resolve types.
it may require μ operator, or symbol table in hir.

• declaration (decl ; decl)
• expression ((expr; expr)
  • derived let (let ... in expr; ...; expr end)

this needs #21

it should accept 1 statement

Current symbol is pub struct Symbol(pub String);. It is sufficient for representing AST, but after HIR, as they are renamed (alpha converted), they should contain versions too like pub struct Symbol(pub String, pub u64);

#53 (comment)

related to #3. writing GC requires pointer apis as well as intrinsics

need to settle the direction of implementation.

• void * style
• template style

void * style is flexible, but may be buggy.

transparent webassembly api will be usefull

It requires to calculate position in parser

Gather symbol table and ID generator to call it compiler context.

Perform some easy reductions to simplify intermediate representations. It helps debugging.

• (fn x => body) arg -> let val x = arg in body end
• let val y = x ... in ... end -> x -> y
  • let val (var1, ..., varn) = (expr1, .., exprn) in arm end -> let val var1 = expr1 ... val varn = exprn in arm end
  • let val Constructor pat = Constructor arg => arm -> let val pat = arg in arm end
• case expr of pattern => arm -> let val pattern = expr in arm end

primitive != prelude. See #14

nom is hard to handle parse error

easy to implement closure calls, ops

possible envrironments:

• Common WA
  • spec: https://github.com/CommonWA/cwa-spec
  • implementation: https://github.com/cervus-v/cervus

ml!(let val x = 1 in x end) => Expr::{ ty: (),inner: ExprKind::Let { ... }}

open problem: how to embed Rust values?

desugared to val it = expr

document "what this module (pass) do", "what is precondition, invariant, postcondition" for each items.

recursive functions cannot be inferred

each pass may have error and warnings.

implement generic Traverse trait and use it

currently we have only AST, HIR, MIR, LIR. However, AST have non typed phase and typed phase, and HIR has renamed (alpha converted) phase, flat_expr (K Normal) phase, flat_let (A Normal) phase.
Each phases should have its own representations

At present, each captured variables are passed via argument, but it's hard to to compile so let it receive a pointer to the captured variables

Write GC

object representation

Allocate JSValue buffer (assoc array) in JS and refer it via index(pointer).

calling convention

pass indices of JSValue (direct passing of i32, f32, f64 will be future work)

object mapping

JS Value <-> ML record via JSON?

Thougn WASM doesn't have function local stack-like storage, you can make it by allocating some space on the heap. This encourages for garbage collection to scan function local values.

External

• implement pattern match #26
  • in MVP, tuple pattern match
• implement ADT #25

Internal

• treat (user-facing) binops as usual functions in HIR. #27
  • perhaps it requires to prepare user-facing function and internal operators
• write tests and run it on CI
  • parser
  • typecheck
  • exhausitiveness check of patterns
  • compile pass

For debugging, testing and more.
lucet would be a good runtime.

correct: 0.7 3.32E5 3E~7

incorrect: 23 .3 4.E5 1E2.5

say, _import "module" "function" (args) .
Aims to replace print with this feature for now

• nested pattern
• val
• ADT