use records to store captured value instead of hashmap

[thautwarm]

A ::= B as b C as c

We could create a type A to perform capturing:

type A = {
     mutable b : B option
     mutable c : C option
}

This might be much more efficient than current implementation.

[thautwarm]

kind of difficult without meta programming..

[ice1000]

Is as a binary operator?

[thautwarm]

@ice1000 It cannot be a binop for F#.
In BNF we can regard it as a valid binop.
A ::= b=B c=C is alternative if you think it not readable.

[ice1000]

Discussed in #1 (seems that we've come up with the same idea! Time to get married)

[thautwarm]

no... I found it difficult for the lack of metaprogramming infrastructures in F#.

[thautwarm]

A feasible solution is, use discriminated union to represented all context type.

bnf:

A ::= b=B c=C

generated:

type A = {
   mutable b : B
   mutable c : C
}

type B = Token
type C = Token

type context = 
| A of  A

the parserc schema:

type 't parser = 
| Bind('t -> unit, 't parser)  # first of which is a setter

[ice1000]

Why metaprogramming? Code generators never need metaprogramming, we can generate hard-coded stuffs. What are you concerning about?

[thautwarm]

@ice1000 I don't want to say anything about this. Actually I have many to complain about code generation.

However, without a definite and specific explanation you might not be satisfied. I don't really refuse this feature but until now there is no feasible design about it and I cannot implement it recently.

Currently we need code generation from BNF to F#, which contains many important functionalities when visiting BNF AST:

• implement auto lexer generation from grammar(this technology is easy to me now for the existed parser analyzer)

• implement module, which requires tremendous and tedious tasks. I have implemented it twice, each of which exactly drives me crazy:

     import std.common.[Indentifier, DoubleDuotedStr, JavaComment]
     import lang.scala.[*] 
     [F#] import MyModule.AST 
  

• find a way to introduce "function"s like what you said in parsing guard as combinator #1 for implementing predicate combinator and rewrite combinator:

  A ::= b=B{predB} c=C{predC} -> A(b, c)
  

If new features are added, I'm afraid that if we could implement it in a near future...
We could hold this issue until there is a feasible design and a clarified workflow about the whole.

[thautwarm]

to implement module, we need

• a mechanism about path resolving and corresponding implementation.
• a scope could handle symbol resolving from separate modules.
• others that I haven't been reminded of yet.

And if we want to generate BNF into separate F# scripts we have to concern about stuffs related to .NET build system(which is not a trivial task)...

So I suggest that we could firstly release a available version and persist adding more interesting features in the future.

[ice1000]

module should be a part of bootstrap. I think I can help with this.

[thautwarm]

check https://github.com/thautwarm/Ruiko.fs/tree/lens

[thautwarm]

I found this prevent dynamic left recursion handling.