From fbccaea2fa8c82d9540e941920f788c375282f1e Mon Sep 17 00:00:00 2001 From: John Doty Date: Sun, 16 Feb 2025 08:06:10 -0800 Subject: [PATCH] Fix indentation in docs --- README.md | 156 +++++++++++++++++++++++------------------------ dingus/about.md | 158 ++++++++++++++++++++++++------------------------ 2 files changed, 157 insertions(+), 157 deletions(-) diff --git a/README.md b/README.md index 44457ee..c0a12eb 100644 --- a/README.md +++ b/README.md @@ -17,31 +17,31 @@ class. Create one method per non-terminal, decorated with the `rule` decorator. Here's an example: ```python - from parser import * +from parser import * - @rule - def expression(): - return seq(expression, PLUS, term) | term +@rule +def expression(): + return seq(expression, PLUS, term) | term - @rule - def term(): - return seq(LPAREN, expression, RPAREN) | ID +@rule +def term(): + return seq(LPAREN, expression, RPAREN) | ID - PLUS = Terminal('PLUS', '+') - LPAREN = Terminal('LPAREN', '(') - RPAREN = Terminal('RPAREN', ')') - ID = Terminal( - 'ID', - Re.seq( - Re.set(("a", "z"), ("A", "Z"), "_"), - Re.set(("a", "z"), ("A", "Z"), ("0", "9"), "_").star(), - ), - ) +PLUS = Terminal('PLUS', '+') +LPAREN = Terminal('LPAREN', '(') +RPAREN = Terminal('RPAREN', ')') +ID = Terminal( + 'ID', + Re.seq( + Re.set(("a", "z"), ("A", "Z"), "_"), + Re.set(("a", "z"), ("A", "Z"), ("0", "9"), "_").star(), + ), +) - SimpleGrammar = Grammar( - name="Simple", - start=expression, - ) +SimpleGrammar = Grammar( + name="Simple", + start=expression, +) ``` Terminals can be plain strings or regular expressions constructed with @@ -59,17 +59,17 @@ There are no helpers (yet!) for consuming lists, so they need to be constructed in the classic context-free grammar way: ```python - @rule - def list(): - return NUMBER | (list + COMMA + NUMBER) +@rule +def list(): + return NUMBER | (list + COMMA + NUMBER) - NUMBER = Terminal(Re.set(("0", "9")).plus()) - COMMA = Terminal(',') +NUMBER = Terminal(Re.set(("0", "9")).plus()) +COMMA = Terminal(',') - NumberList = Grammar( - name="NumberList", - start=list, - ) +NumberList = Grammar( + name="NumberList", + start=list, +) ``` (Unlike with PEGs, you can write grammars with left or right-recursion, @@ -95,23 +95,23 @@ which means they don't generate nodes in the tree and just dump their contents into the parent node instead. ```python - @rule - def list(): - # The starting rule can't be transparent: there has to be something to - # hold on to! - return transparent_list +@rule +def list(): + # The starting rule can't be transparent: there has to be something to + # hold on to! + return transparent_list - @rule(transparent=True) - def transparent_list() -> Rule: - return NUMBER | (transparent_list + COMMA + NUMBER) +@rule(transparent=True) +def transparent_list() -> Rule: + return NUMBER | (transparent_list + COMMA + NUMBER) - NUMBER = Terminal(Re.set(("0", "9")).plus()) - COMMA = Terminal(',') +NUMBER = Terminal(Re.set(("0", "9")).plus()) +COMMA = Terminal(',') - NumberList = Grammar( - name="NumberList", - start=list, - ) +NumberList = Grammar( + name="NumberList", + start=list, +) ``` This grammar will generate the far more useful tree: @@ -130,23 +130,23 @@ following the lead set by tree-sitter, and so the grammar above is probably better-written as: ```python - @rule - def list(): - # The starting rule can't be transparent: there has to be something to - # hold on to! - return transparent_list +@rule +def list(): + # The starting rule can't be transparent: there has to be something to + # hold on to! + return transparent_list - @rule - def _list() -> Rule: - return NUMBER | (_list + COMMA + NUMBER) +@rule +def _list() -> Rule: + return NUMBER | (_list + COMMA + NUMBER) - NUMBER = Terminal(Re.set(("0", "9")).plus()) - COMMA = Terminal(',') +NUMBER = Terminal(Re.set(("0", "9")).plus()) +COMMA = Terminal(',') - NumberList = Grammar( - name="NumberList", - start=list, - ) +NumberList = Grammar( + name="NumberList", + start=list, +) ``` That will generate the same tree, but a little more succinctly. @@ -155,17 +155,17 @@ Of course, it's a lot of work to write these transparent recursive rules by hand all the time, so there are helpers that do it for you: ```python - @rule - def list(): - return zero_or_more(NUMBER, COMMA) + NUMBER +@rule +def list(): + return zero_or_more(NUMBER, COMMA) + NUMBER - NUMBER = Terminal(Re.set(("0", "9")).plus()) - COMMA = Terminal(',') +NUMBER = Terminal(Re.set(("0", "9")).plus()) +COMMA = Terminal(',') - NumberList = Grammar( - name="NumberList", - start=list, - ) +NumberList = Grammar( + name="NumberList", + start=list, +) ``` Much better. @@ -180,20 +180,20 @@ To allow (and ignore) spaces, newlines, tabs, and carriage-returns in our number lists, we would modify the grammar as follows: ```python - @rule - def list(): - return zero_or_more(NUMBER, COMMA) + NUMBER +@rule +def list(): + return zero_or_more(NUMBER, COMMA) + NUMBER - NUMBER = Terminal(Re.set(("0", "9")).plus()) - COMMA = Terminal(',') +NUMBER = Terminal(Re.set(("0", "9")).plus()) +COMMA = Terminal(',') - BLANKS = Terminal(Re.set(" ", "\t", "\r", "\n").plus()) +BLANKS = Terminal(Re.set(" ", "\t", "\r", "\n").plus()) - NumberList = Grammar( - name="NumberList", - start=list, - trivia=[BLANKS], - ) +NumberList = Grammar( + name="NumberList", + start=list, + trivia=[BLANKS], +) ``` Now we can parse a list with spaces! "1 , 2, 3" will parse happily diff --git a/dingus/about.md b/dingus/about.md index 890eaa4..b677cfc 100644 --- a/dingus/about.md +++ b/dingus/about.md @@ -20,31 +20,31 @@ object. Here's an example: ```python {.numberLines} - from parser import * +from parser import * - @rule - def expression(): - return seq(expression, PLUS, term) | term +@rule +def expression(): + return seq(expression, PLUS, term) | term - @rule - def term(): - return seq(LPAREN, expression, RPAREN) | ID +@rule +def term(): + return seq(LPAREN, expression, RPAREN) | ID - PLUS = Terminal('PLUS', '+') - LPAREN = Terminal('LPAREN', '(') - RPAREN = Terminal('RPAREN', ')') - ID = Terminal( - 'ID', - Re.seq( - Re.set(("a", "z"), ("A", "Z"), "_"), - Re.set(("a", "z"), ("A", "Z"), ("0", "9"), "_").star(), - ), - ) +PLUS = Terminal('PLUS', '+') +LPAREN = Terminal('LPAREN', '(') +RPAREN = Terminal('RPAREN', ')') +ID = Terminal( + 'ID', + Re.seq( + Re.set(("a", "z"), ("A", "Z"), "_"), + Re.set(("a", "z"), ("A", "Z"), ("0", "9"), "_").star(), + ), +) - SimpleGrammar = Grammar( - name="Simple", - start=expression, - ) +SimpleGrammar = Grammar( + name="Simple", + start=expression, +) ``` Terminal patterns can be plain strings or regular expressions @@ -61,17 +61,17 @@ things can be freely nested, as desired. You can make lists in the classic context-free grammar way: ```python {.numberLines} - @rule - def list(): - return NUMBER | (list + COMMA + NUMBER) +@rule +def list(): + return NUMBER | (list + COMMA + NUMBER) - NUMBER = Terminal(Re.set(("0", "9")).plus()) - COMMA = Terminal(',') +NUMBER = Terminal(Re.set(("0", "9")).plus()) +COMMA = Terminal(',') - NumberList = Grammar( - name="NumberList", - start=list, - ) +NumberList = Grammar( + name="NumberList", + start=list, +) ``` (Unlike with PEGs, you can write grammars with left or right-recursion, @@ -97,23 +97,23 @@ which means they don't generate nodes in the tree and just dump their contents into the parent node instead. ```python {.numberLines} - @rule - def list(): - # The starting rule can't be transparent: there has to be something to - # hold on to! - return transparent_list +@rule +def list(): + # The starting rule can't be transparent: there has to be something to + # hold on to! + return transparent_list - @rule(transparent=True) - def transparent_list() -> Rule: - return NUMBER | (transparent_list + COMMA + NUMBER) +@rule(transparent=True) +def transparent_list() -> Rule: + return NUMBER | (transparent_list + COMMA + NUMBER) - NUMBER = Terminal(Re.set(("0", "9")).plus()) - COMMA = Terminal(',') +NUMBER = Terminal(Re.set(("0", "9")).plus()) +COMMA = Terminal(',') - NumberList = Grammar( - name="NumberList", - start=list, - ) +NumberList = Grammar( + name="NumberList", + start=list, +) ``` This grammar will generate the far more useful tree: @@ -132,23 +132,23 @@ following the lead set by tree-sitter, and so the grammar above is probably better-written as: ```python {.numberLines} - @rule - def list(): - # The starting rule can't be transparent: there has to be something to - # hold on to! - return transparent_list +@rule +def list(): + # The starting rule can't be transparent: there has to be something to + # hold on to! + return transparent_list - @rule - def _list() -> Rule: - return NUMBER | (_list + COMMA + NUMBER) +@rule +def _list() -> Rule: + return NUMBER | (_list + COMMA + NUMBER) - NUMBER = Terminal(Re.set(("0", "9")).plus()) - COMMA = Terminal(',') +NUMBER = Terminal(Re.set(("0", "9")).plus()) +COMMA = Terminal(',') - NumberList = Grammar( - name="NumberList", - start=list, - ) +NumberList = Grammar( + name="NumberList", + start=list, +) ``` That will generate the same tree, but a little more succinctly. @@ -157,17 +157,17 @@ Of course, it's a lot of work to write these transparent recursive rules by hand all the time, so there are helpers that do it for you: ```python {.numberLines} - @rule - def list(): - return zero_or_more(NUMBER, COMMA) + NUMBER +@rule +def list(): + return zero_or_more(NUMBER, COMMA) + NUMBER - NUMBER = Terminal(Re.set(("0", "9")).plus()) - COMMA = Terminal(',') +NUMBER = Terminal(Re.set(("0", "9")).plus()) +COMMA = Terminal(',') - NumberList = Grammar( - name="NumberList", - start=list, - ) +NumberList = Grammar( + name="NumberList", + start=list, +) ``` Much better. @@ -182,21 +182,21 @@ To allow (and ignore) spaces, newlines, tabs, and carriage-returns in our number lists, we would modify the grammar as follows: ```python {.numberLines} - @rule - def list(): - return zero_or_more(NUMBER, COMMA) + NUMBER +@rule +def list(): + return zero_or_more(NUMBER, COMMA) + NUMBER - NUMBER = Terminal(Re.set(("0", "9")).plus()) - COMMA = Terminal(',') +NUMBER = Terminal(Re.set(("0", "9")).plus()) +COMMA = Terminal(',') - BLANKS = Terminal(Re.set(" ", "\t", "\r", "\n").plus()) - # ^ and add a new terminal to describe what we're ignoring... +BLANKS = Terminal(Re.set(" ", "\t", "\r", "\n").plus()) +# ^ and add a new terminal to describe what we're ignoring... - NumberList = Grammar( - name="NumberList", - start=list, - trivia=[BLANKS], - ) +NumberList = Grammar( + name="NumberList", + start=list, + trivia=[BLANKS], +) ``` Now we can parse a list with spaces! "1 , 2, 3" will parse happily