What do you think about using late final for production rules instead of functions?

[ardera]

Currently the grammars in the examples look like this:

class Grammar {
  Parser<List> myRule() => ref0(otherRule) & ref0(otherRule2);
  Parser<SomeResult> otherRule() => anyOf('abc').map((_) => SomeResult());
  Parser<SomeResult> otherRule2() => ref0(myRule).map((l) => l[0]);
}

With dart 2.12's late final variables, they could look like this:

class Grammar {
  late final myRule = otherRule & otherRule2;
  late final otherRule = anyOf('abc').map((_) => SomeResult());
  late final otherRule2 = ref0(() => myRule).map((l) => l[0]);
}

The cool thing about late final is that:

1. the return type is automatically inferred. When using functions, you have to write out the return type (otherwise dart will assume dynamic AFAICT).
2. the parsers get memoized automatically, and are not constructed again every time the rule is built.

The only thing ugly about it is recursive rules, because ref0(() => myRule) looks ugly. But honestly, ref0(myRule) looks ugly too, and the good thing about using late final variables is that the dart analyzer warns you when you have a cycle in the initializers, so you can just completely omit the ref0's and only put them in place when necessary (which is when the analyzer warns you). That means in total, the code looks much cleaner.

Overriding them works as expected too.

What do you think?

[renggli]

Yeah, this looks pretty nice, though your example doesn't work for me (having the reference within a closure or not doesn't change anything for me):

error: The type of 'myRule' can't be inferred because it depends on itself through the cycle: [otherRule2, myRule]. (top_level_cycle at [petitparser] example/playground.dart:12)
error: The type of 'otherRule2' can't be inferred because it depends on itself through the cycle: [otherRule2, myRule]. (top_level_cycle at [petitparser] example/playground.dart:14)

Other shortcomings (that might not be relevant and can be easily avoided in many cases) are:

• Overrides become pretty complicated and inconsistent.
• You loose the ability to parametrize productions.

That said, I intentionally moved ref0 and friends out of GrammarDefinition so that they can be used more freely. While I like that all the Dart tools work with the grammar definitions, things can get quite verbose. I am definitely very interested in finding new and better ways to define grammars. In the worst case we have to wait until we get macros.