Commit: f503dd15f787934c19b6092099d4bc39d6cf747b - CCastle2 (hg)

Castle: The best Real-Time/Embedded/HighTech language EVER. Attempt 2

Commit MetaInfo

• Revisión: f503dd15f787934c19b6092099d4bc39d6cf747b (tree)
• Tiempo: 2021-11-28 06:40:49
• Autor: Albert Mietus < albert AT mietus DOT nl >
• Commiter: Albert Mietus < albert AT mietus DOT nl >

Log Message

asis

Cambiar Resumen

• add: .hgignore
• add: Arpeggio/Sequence
• add: Arpeggio/demo1.py
• add: Arpeggio/grammar.py
• add: Arpeggio/pytst/__init__.py
• add: Arpeggio/pytst/grammar.peg
• add: Arpeggio/pytst/test_1_regexp.py
• add: Arpeggio/pytst/test_2_str.py
• add: Arpeggio/pytst/test_3_sequence.py
• add: Arpeggio/pytst/test_4_rule.py
• add: Arpeggio/pytst/test_9_grammar.py
• add: examples/My_ExpressionParser.Castle
• add: examples/My_ExpressionParser.Moat
• add: examples/My_GrammarParser.Castle
• add: examples/My_GrammarParser.Moat
• add: examples/ParserDemo.Moat

Diferencia incremental

diff -r 000000000000 -r f503dd15f787 .hgignore
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/.hgignore	Sat Nov 27 22:40:49 2021 +0100
@@ -0,0 +1,5 @@
+.DS_Store
+__pycache__
+.*\.pyc
+.pytest_cache
+.*\.dot
\ No newline at end of file

diff -r 000000000000 -r f503dd15f787 Arpeggio/grammar.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Arpeggio/grammar.py	Sat Nov 27 22:40:49 2021 +0100
@@ -0,0 +1,50 @@
+from arpeggio import Optional, ZeroOrMore, OneOrMore, EOF
+from arpeggio import RegExMatch as _
+from arpeggio import ParserPython
+
+def peg_grammar(): 	return OneOrMore(rule), EOF
+def rule():		return rule_name, '<-', ordered_choice, ";"
+def ordered_choice():	return sequence, ZeroOrMore('|', sequence)
+def sequence():		return ZeroOrMore(prefix)
+def prefix():           return Optional(['&','!']), suffix
+def suffix():		return expression, Optional([ '?' , '*' , '+' , '#' ])
+def expression():       return [ regex_term, str_term, ('(', ordered_choice, ')'), rule_crossref]
+def rule_crossref():	return rule_name
+def rule_name():	return ID
+def regex_term():	return [\
+                                (RE,   re_no_slash, RE),
+                                (REs3, str_no_s3,   S3),
+                                (REd3, str_no_d3,   D3),
+                                (REs1, str_no_s1,   S1),
+                                (REd1, str_no_d1,   D1)
+                                ]
+def str_term():		return [\
+                                (S3, str_no_s3, S3),
+                                (D3, str_no_d3, D3),
+                                (S1, str_no_s1, S1),
+                                (D1, str_no_d1, D1)
+                                ]
+
+def ID():        	return _(r"[a-zA-Z_]([a-zA-Z_]|[0-9])*")
+
+def re_no_slash():	return _(r"((\\/)|[^\/])*")
+
+def str_no_s1():	return _(r"((\\')|[^'\n])*")                    # Does NOT match multiline -- note 'multiline=False' is not the same
+def str_no_d1():	return _(r'((\\")|[^"\n])*')                    # idem
+def str_no_s3():	return _(r"([^']|('[^'])|(''[^']))*")           # ALLOW multiline
+def str_no_d3():	return _(r'''([^"]|("[^"])|(""[^"]))*''')       # idem
+
+S1 = "'"
+D1 = '"'
+S3 = "'''"
+D3 = '"""'
+RE   = '/'
+REs1 = _(r"[rR]'")
+REd1 = _(r'[rR]"')
+REs3 = _(r"[rR]'''")
+REd3 = _(r'[rR]"""')
+
+
+
+def comment():          return "//", _(".*\n")
+

diff -r 000000000000 -r f503dd15f787 Arpeggio/pytst/grammar.peg
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Arpeggio/pytst/grammar.peg	Sat Nov 27 22:40:49 2021 +0100
@@ -0,0 +1,37 @@
+// This is a fragment from ../examples/My_GrammarParser.Castle
+
+   peg_grammar     <-  rule+ ;
+   rule	           <-  rule_name '<-' ordered_choice ';' ;
+   ordered_choice  <-  sequence  ('|' sequence)* ;
+   sequence	   <-  prefix* ;
+   prefix 	   <- ( AND | NOT )? suffix ;
+   suffix	   <- expression ( '?' | '*' | '+' | '#' )? ;
+   expression	   <- regex_term
+   		   |  rule_crossref
+		   |  '(' ordered_choice ')'
+		   |  str_term
+		   ;
+   rule_crossref   <- rule_name;
+   rule_name	   <- ID ;
+   str_term	   <- "'"    str_no_s1  "'"
+   		   |  '"'    str_no_d1  '"'
+		   |  "'''"  str_no_s3  "'''"
+		   |  '"""'  str_no_d3  '"""'
+                   ;
+   regex_term	   <- '/'     str_no_slash  '/'
+   		   |  "r'"    str_no_s1  "'"
+   		   |  'r"'    str_no_d1  '"'
+		   |  "r'''"  str_no_s3  "'''"
+		   |  'r"""'  str_no_d3  '"""'
+   		   |  "R'"    str_no_s1  "'"
+   		   |  'R"'    str_no_d1  '"'
+		   |  "R'''"  str_no_s3  "'''"
+		   |  'R"""'  str_no_d3  '"""'
+		   ;
+   str_no_slash    <- /((\\/)|[^\/])*/ ;
+   str_no_XXX      <- XXX
+         	   |  ETC
+		   ;
+   AND 		   <- '&' ;
+   NOT 		   <- '!' ;
+

diff -r 000000000000 -r f503dd15f787 Arpeggio/pytst/test_1_regexp.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Arpeggio/pytst/test_1_regexp.py	Sat Nov 27 22:40:49 2021 +0100
@@ -0,0 +1,38 @@
+import pytest
+from grammar import *
+
+import arpeggio
+RE, S = arpeggio.RegExMatch, arpeggio.StrMatch                          # shortcut
+
+show_dot=True
+
+def parse_regex(txt, pattern=None):
+    #print(f'\nXXX >>{txt}<<')
+    parser = ParserPython(regex_term, comment, debug=show_dot)
+    tree = parser.parse(txt)
+    assert tree.position_end == len(txt) , f"Not parsed whole input; Only: >>{txt[tree.position: tree.position_end]}<<; Not: >>{txt[tree.position_end:]}<<."
+
+    assert isinstance(tree.rule, arpeggio.OrderedChoice) and tree.rule_name == "regex_term"
+    assert len(tree) == 3, "regex_term is an Ordered_Choice of always 3 Terminals"
+
+    for e in tree: assert isinstance(e, arpeggio.Terminal)
+    if pattern:
+        for e,T in zip(tree,pattern):
+            if T is not None: assert isinstance(e.rule, T), f"{type(e.rule).__name__}  doesn't match {T.__name__}"
+
+    return tree
+
+def test_slash_simple():	parse_regex(r"/ABC/",   pattern=[S,RE,S])
+def test_slash_slashonly():	parse_regex(r"/\//",    pattern=[S,RE,S])
+def test_slash_withslash_r():   parse_regex(r"/ab\/c/", pattern=[S,RE,S])
+
+def test_Rs1_simple():	parse_regex(r"R'ABC'",   pattern=[RE,RE,S])
+def test_rs2_simple():	parse_regex(r"r'abc'",   pattern=[RE,RE,S])
+def test_Rd1_simple():	parse_regex(r'R"ABC"',   pattern=[RE,RE,S])
+def test_rd2_simple():	parse_regex(r'r"abc"',   pattern=[RE,RE,S])
+
+def test_grammar_re_no_slash(): parse_regex(r"/((\\/)|[^\/])*/")
+def test_grammar_auto_re_no_slash(): parse_regex("/" + re_no_slash().to_match +"/") # Same as above (unless grammar changes
+
+
+

diff -r 000000000000 -r f503dd15f787 Arpeggio/pytst/test_2_str.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Arpeggio/pytst/test_2_str.py	Sat Nov 27 22:40:49 2021 +0100
@@ -0,0 +1,52 @@
+import pytest
+
+from grammar import *
+import arpeggio
+RE, S = arpeggio.RegExMatch, arpeggio.StrMatch                          # shortcut
+
+show_dot=True
+
+def parse_str(str, pattern=[S, RE, S]):
+    #print(f'\nXXX >>{str}<<')
+    parser = ParserPython(str_term, comment, debug=show_dot)
+    tree = parser.parse(str)
+    assert tree.position_end == len(str) , f"Not parsed whole input; Only: >>{str[tree.position: tree.position_end]}<<; Not: >>{str[tree.position_end:]}<<."
+
+    assert isinstance(tree.rule, arpeggio.OrderedChoice) and tree.rule_name == "str_term"
+    assert len(tree) == 3, "regex_term is an Ordered_Choice of always 3 Terminals"
+
+    for e in tree: assert isinstance(e, arpeggio.Terminal)
+    if pattern:
+        for e,T in zip(tree,pattern):
+            if T is not None: assert isinstance(e.rule, T), f"{type(e.rule).__name__}  doesn't match {T.__name__}"
+
+
+    return tree
+
+
+def test_s1():	parse_str("'single 1'")
+def test_d1():	parse_str('"double 1"')
+def test_s3():	parse_str(r"'''single 3 b'''")
+def test_d3():	parse_str('"""double 3"""')
+
+def test_multiline_s(): parse_str("""'''
+line 1
+line 2
+'''""")
+def test_multiline_d(): parse_str('''"""
+line 1
+line 2
+"""''')
+
+def test_multiline_only3():
+    import arpeggio
+    with pytest.raises(arpeggio.NoMatch):
+        parse_str("""'
+        line 1
+        line 2
+        '""")
+    with pytest.raises(arpeggio.NoMatch):
+        parse_str('''"
+        line 1
+        line 2
+        "''')

diff -r 000000000000 -r f503dd15f787 Arpeggio/pytst/test_3_sequence.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Arpeggio/pytst/test_3_sequence.py	Sat Nov 27 22:40:49 2021 +0100
@@ -0,0 +1,49 @@
+import pytest
+from grammar import *
+
+import arpeggio
+
+R, S, X = regex_term.__name__, str_term.__name__, rule_crossref.__name__  # shortcut in grammar
+
+show_dot=True
+def parse_sequence(txt, pattern=None, show=False):
+    parser = ParserPython(sequence, comment, debug=show_dot)
+    tree = parser.parse(txt)
+    if show : print(f'\nPARSE_SEQEUENCE >>{txt}<<\n{tree.tree_str()}')
+
+    assert tree.position_end == len(txt) , f"Not parsed whole input; Only: >>{txt[tree.position: tree.position_end]}<<; Not: >>{txt[tree.position_end:]}<<."
+    assert isinstance(tree.rule, arpeggio.ZeroOrMore) and tree.rule_name == "sequence"
+
+    if pattern: validate_pattern(tree,pattern=pattern, show=show)
+    return tree
+
+def validate_pattern(tree, pattern=None, sub=0, show=False):
+    if show: print(f'\nVALIDATE_PATTERN pattern={pattern} sublevel={sub}\n{tree.tree_str()}')
+    assert len(tree) == len(pattern), f"Not correct number-of-element at sublevel={sub}"
+
+    exs=tree.prefix.suffix.expression
+    #if show: print("EXS", type(exs), "\n"+exs.tree_str())
+    for ex,p in zip(exs, pattern):
+        if p is not None:
+            if not isinstance(p, (tuple, list)):
+                assert ex[0].rule_name == p, f"{ex} doesn't match given {p} sublevel={sub}"
+            else:
+                #print('XXX1\n', ex[1][0].tree_str())
+                validate_pattern(tree=ex[1][0], pattern=p, sub=sub+1, show=show)
+
+
+
+def test_simple_1():	parse_sequence(r"abc",		pattern=[X])
+def test_simple_2():	parse_sequence(r'A  Bc',	pattern=[X, X])
+def test_mix():		parse_sequence(r'/regex/ "string" crossref crossref',	pattern=[R,S, X, X])
+
+def test_sub():		parse_sequence(r'( A  B )',	pattern=[(X, X)])
+def test_mix_nosub():	parse_sequence(r'/regex/ "string" ( A  B ) crossref',	pattern=[R,S, None, X])
+def test_mix_sub():	parse_sequence(r'/regex/ "string" ( A  B ) crossref',	pattern=[R,S, (X, X), X])
+
+def test_sub_sub():	parse_sequence(r'level0 ( level1_1  (level2a level2b ) level1_2) level0', pattern=[X, (X, (X,X), X), X])
+def test_sub_sub2():	parse_sequence(r'level0 ( level1_1  (level2a level2b ) level1_2) level0', pattern=[X, [X, [X,X], X], X]) 
+
+
+
+

diff -r 000000000000 -r f503dd15f787 Arpeggio/pytst/test_4_rule.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Arpeggio/pytst/test_4_rule.py	Sat Nov 27 22:40:49 2021 +0100
@@ -0,0 +1,30 @@
+import pytest
+from grammar import *
+
+import arpeggio
+RE, S = arpeggio.RegExMatch, arpeggio.StrMatch                          # shortcut
+
+show_dot=True
+
+def parse_rule(txt, pattern=None):
+    print(f'\nXXX >>{txt}<<')
+    parser = ParserPython(rule, comment, debug=show_dot)
+    tree = parser.parse(txt)
+    assert tree.position_end == len(txt) , f"Not parsed whole input; Only: >>{txt[tree.position: tree.position_end]}<<; Not: >>{txt[tree.position_end:]}<<."
+
+    print(f'\nTREE\n{tree.tree_str()}')
+
+#    assert len(tree) == 3, "txt_term is an Ordered_Choice of always 3 Terminals"
+#    assert isinstance(tree.txt, arpeggio.OrderedChoice) and tree.txt_name == "rule_term"
+
+
+#    for e in tree: assert isinstance(e, arpeggio.Terminal)
+#    if pattern:
+#        for e,T in zip(tree,pattern):
+#            if T is not None: assert isinstance(e.rule, T), f"{type(e.rule).__name__}  doesn't match {T.__name__}"
+
+    return tree
+
+def test_simple():	parse_rule(r"R <- A  B C ;")
+
+

diff -r 000000000000 -r f503dd15f787 Arpeggio/pytst/test_9_grammar.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Arpeggio/pytst/test_9_grammar.py	Sat Nov 27 22:40:49 2021 +0100
@@ -0,0 +1,17 @@
+import pytest
+
+from grammar import *
+
+show_dot=True
+
+def parse_file(filename, dir="pytst"):
+    with open(dir +"/" + filename) as f:
+        txt = f.read()
+
+    parser = ParserPython(peg_grammar, comment, debug=show_dot)
+    tree = parser.parse(txt)
+
+    assert tree.position_end == len(txt) , f"Not parsed whole input; Only: >>{regex[tree.position: tree.position_end]}<<; Not: >>{regex[tree.position_end:]}<<."
+    return tree
+
+def test_grammar(): parse_file("grammar.peg")

diff -r 000000000000 -r f503dd15f787 examples/My_ExpressionParser.Castle
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/examples/My_ExpressionParser.Castle	Sat Nov 27 22:40:49 2021 +0100
@@ -0,0 +1,81 @@
+/* (C) Albert Mietus. Demo and test */
+
+from My_ExpressionParser import Fixed_ExpressionParser, Init_ExpressionParser, Port_ExpressionParser;
+
+from std.data.grammars import Grammer, Rule, ID;
+from std.algorithms.parser import PEG;
+
+implement ParserDemo.Base_ExpressionParser {
+exp on self.text {
+    """Just call parse the input --using the parser-- and output it."""
+    self.tree := self.parser.parse(exp);
+}
+} //End Base_ExpressionParser
+/*****************************************************************************************************/
+
+
+implement ParserDemo.Fixed_ExpressionParser {
+
+- Grammar: my_expression(){
+  // ToDo: logic expression: (&&,etc
+
+   Rule: expr;
+   Rule: atom_value, unary, exponentiation,  multy_divide, add_minus;
+   Rule: literal_value, literal_number, literal_str;
+   Rule: named_value, variable, funcall parms;
+
+   atom_value      <- literal_value
+              	   |  '(' expr ')'
+	      	   |  named_value
+	      	   ;
+   literal_value   <- literal_number
+   		   | literal_str
+		 //| Booleans etc.
+		   ;
+   literal_number  <- [:digit:]+
+   		 //| ToDo: Float, Complex ect.
+		   ;
+   literal_str 	   <- '"'   ( [^\'\n]* ) '"' // Note: \'==='; but highlighting is better
+   		   |  "'"   ( [^\"\n]* ) "'"
+		   |  '"""' ( [.\n]*? ) '"""'
+		   |  "'''" ( [.\n]*? ) "'''"
+		   ;
+   name_value      <- variable
+   		   |  funcall
+		   ;
+   funcall	   <- ID '(' parms ')';
+   variable	   <- ID;
+   parms	   <- expr (',' expr )* // Is this correct wrt recursion?
+
+   unary	   <- ('+' | '-')? atom_value;
+   exponentiation  <- unary          ('**' expr)?;
+   multy_divide	   <- exponentiation (('*' | '/' | '%') expr)?;
+   add_minus	   <- multy_divide  (('+'|'-') expr)?;
+   expr		   < add_minus;
+
+   return expr;
+}
+
+- init() {
+  Grammar g = self.my_expression()
+  self.parser = PEG(g);
+}
+
+} //End Fixed_ExpressionParser
+/*****************************************************************************************************/
+
+
+implement ParserDemo.Init_ExpressionParser {
+- init(Grammer:g) {
+  self.parser = PEG(g);
+}
+} //End Init_ExpressionParser
+/*****************************************************************************************************/
+
+
+implement ParserDemo.Port_ExpressionParser {
+g on expression
+{
+  self.parser = PEG(g);
+}
+} //End Port_ExpressionParser
\ No newline at end of file

diff -r 000000000000 -r f503dd15f787 examples/My_ExpressionParser.Moat
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/examples/My_ExpressionParser.Moat	Sat Nov 27 22:40:49 2021 +0100
@@ -0,0 +1,23 @@
+/* (C) Albert Mietus. Demo and test */
+
+from ParserDemo import Abstract_Parser, Base_ChunkParser;
+from std.data.grammars import Grammer
+
+
+component Fixed_ExpressionParser : Abstract_Parser, Base_ChunkParser {
+ """The Fixed_ExpressionParser has the grammer build-in; unlike the :ref:`Init_ExpressionParser` and :ref:`Port_ExpressionParser`"""
+}
+
+
+
+component Init_ExpressionParser : Base_ExpressionParser {
+ """The Init_ExpressionParser reads the grammer when it is initialized"""
+- init(Grammer:g)
+}
+
+
+
+component Port_ExpressionParser : Base_ExpressionParser {
+ """The Port_ExpressionParser reads the grammer via a port (unlike the :ref:`Fixed_ExpressionParser`."""
+  port Grammar<in> expression;
+}

diff -r 000000000000 -r f503dd15f787 examples/My_GrammarParser.Castle
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/examples/My_GrammarParser.Castle	Sat Nov 27 22:40:49 2021 +0100
@@ -0,0 +1,67 @@
+/* (C) Albert Mietus. Demo and test */
+
+from My_GrammarParser import GrammarParser;
+from std.data.grammars import Grammer, Rule, ID, STR, REGEXP;
+from std.algorithms.parser import PEG;
+
+implement  GrammerParser{
+- init() {
+  Grammar g = self.my_grammar()
+  self.parser = PEG(g);
+}
+
+- Grammar: my_grammar(){
+   """Design: we use more-or-less the same names for non-terminals as Arpeggio uses.
+
+      .. seealso::
+
+         * http://textx.github.io/Arpeggio/stable/grammars/#grammars-written-in-peg-notations
+      	 * https://github.com/textX/Arpeggio/blob/master/arpeggio/peg.py
+   """
+
+   Rule:  peg_grammar, rule, rule_name, rule_crossref;
+   Rule:  ordered_choice, sequence, prefix, suffix, expression;
+   Rule:  regex, , str_match
+   Rule:  AND, NOT, LEFT_ARROW, ORDERED_CHOICE;
+
+   //  ToDo Comment, str_match;
+   peg_grammar     <-  rule+;
+   rule	           <-  rule_name '<-' ordered_choice ';' ;
+   ordered_choice  <-  sequence  ('|' sequence)* ;
+   sequence	   <-  prefix* ;
+   prefix 	   <- ( AND | NOT )? suffix ;
+   suffix	   <- expression ( '?' | '*' | '+' | '#' )?
+   expression	   <- regex_term
+   		   |  rule_crossref
+		   |  '(' ordered_choice ')'
+		   |  str_term
+		   ;
+   rule_crossref   <- rule_name;
+   rule_name	   <- ID ;
+   regex_term	   <- '/'     str_no_slash  '/'
+   		   |  "r'"    str_no_s1  "'"
+   		   |  'r"'    str_no_d1  '"'
+		   |  "r'''"  str_no_s3  "'''"
+		   |  'r"""'  str_no_d3  '"""'
+   		   |  "R'"    str_no_s1  "'"
+   		   |  'R"'    str_no_d1  '"'
+		   |  "R'''"  str_no_s3  "'''"
+		   |  'R"""'  str_no_d3  '"""'
+		   ;
+   str_term	   <- "'"    str_no_s1  "'"
+   		   |  '"'    str_no_d1  '"'
+		   |  "'''"  str_no_s3  "'''"
+		   |  '"""'  str_no_d3  '"""'
+   str_no_slash    <- /[^/\\]*(?:\\.[^/\\]*)*/ ;
+   str_no_XXX      <- XXX
+         	   |  ETC
+		   ;
+   AND 		   <- '&' ;
+   NOT 		   <- '!' ;
+
+   return peg_grammar;
+
+}
+} //End of GrammerParser
+/*****************************************************************************************************/
+

diff -r 000000000000 -r f503dd15f787 examples/My_GrammarParser.Moat
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/examples/My_GrammarParser.Moat	Sat Nov 27 22:40:49 2021 +0100
@@ -0,0 +1,6 @@
+/* (C) Albert Mietus. Demo and test */
+
+from ParserDemo import Abstract_Parser, Base_ChunkParser;
+
+component GrammerParser : Abstract_Parser, Base_ChunkParser {
+}
\ No newline at end of file

diff -r 000000000000 -r f503dd15f787 examples/ParserDemo.Moat
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/examples/ParserDemo.Moat	Sat Nov 27 22:40:49 2021 +0100
@@ -0,0 +1,43 @@
+/* (C) Albert Mietus. Demo and test */
+
+from std.data.grammars import Grammer;
+
+
+component Abstract_Parser : Component {
+   """A *Parser* parses a string, using a (formal) grammar, and outputs the ParseTree.
+
+      Typically, the string is read via the in-port, which triggers processing, and results in a new ParseTree (or:
+      'concrete syntax tree') dispatched via the output-port.
+
+      The grammar can be *hardcoded* in a final component or passed in via a port or during initialization.
+
+      .. seealso:: Some example components
+
+        * ref:`Fixed_ExpressionParser`
+        * ref:`Init_ExpressionParser`
+        * ref:`Port_ExpressionParser`
+   """
+
+   port str<in>  text;
+   port tree<out> parse_tree;
+}
+
+
+
+component Base_ChunkParser: Abstract_Parser {
+   """A *ChunkParser* typically parses a sub-string of a bigger text; on behalve of the main-parser.
+
+      By example: the main-parser may recognize a expression as a whole, transfer that text to a (Expression)
+      ChunkParser, that parsers the details. The resulting ParseTree (of the expression) is that integrated into the
+      main ParseTree.
+
+      By using a *ChunkParser*, the main parsers does not need to be awaire of details, like precedence and
+      associativity of the operartors. And so, the *main grammar* is easier; there is no need to handle the (typical)
+      `left-recursion <https://en.wikipedia.org/wiki/Left_recursion>`_ of expression, nor or other pitfaills. All that
+      work is for the "chunk".
+   """
+}
+
+
+
+