spy16 / parens Goto Github PK

Namespaces were omitted from the rewrite, but I think we should include this feature in the v1.0 release.

Any thoughts on how this should work with our new architecture?

• Implement Reader with macro-table + dispatch-table. (Mostly take from Sabre)
• Implement New() with functional options to customise all internal tables, number-reader.
• Implement WithMacroTable, WithDispatchTable, WithNumberReader etc.

type Reader interface {
    All() ([]Any, error)
    One() (Any, error)
}

@lthibault I was looking at https://pkg.go.dev/github.com/spy16/parens today and realized it is still showing the old Parens releases which don't exist anymore. Also, after discussion on Gophers slack, I came to know that it's not possible to update that anymore. I don't know what do about this. The cleanest and the right thing to do would be move to a new repository with different name 😔 .. But we have changed this way too many times already. any thoughts?

• Implement BuiltinExpander that expands Seq based macro-invocation forms.

Need to figure out how a symbol/value would be identified as a macro (Clojure uses a ^:macro tag)

• Define Expr and Context contracts (interfaces)
• Implement builtin primitive data types + seq (linked-list) type.
• Implement a concurrent-safe parens.Analyser which can analyse and produce Expr for builtin types.

Note: Vector, Set, Map are out-of-scope for this issue.

• (do <expr>*)
• (if test then else?)
• (def sym value)
• (quote expr)
• (let ( binding* ) expr*)
• (fn name? ( param* ) expr*)

Depends on #12 and #14.

Requirements to be decided.

• Implement a stateless Interpreter that performs macro-expansion, syntax analysis to get Expr and dispatches for Eval.
• Implement Eval that evaluates the Expr in a thread context for results.

@lthibault Another concern is usually VM is not the one doing the syntax-analysis 😅. I would like to use this thread for discussing the design before implementing it.

I am thinking following is the approach we can take:

1. A parens.Interpreter or parens.Instance struct that contains the Analyser, Expander etc.
2. Above type will have a Eval(form Any) (Any, error) method that performs macro-expansion and syntax analysis and dispatches it for eval under a context..
3. It can also house a main-thread context that it uses to execut all forms. A GoExpr (or something equivalent) can create a child from that context and launch the eval further. (just initial thoughts)

type Interpreter struct {
    analyser Analyser
    expander Expander
    mainCtx Context
}
func (i *Interpreter) Eval(form Any) (Any, error) {
     expr, _ := expandAnalyse(form)
     return  expr.Eval(i.mainCtx)
}

I have finished migrating over to Slurp; we should archive this repo to avoid confusion.

RIP parens ... 😢