Merge pull request #54 from mkantor/optimize-parsers

Trivially clean up parsers

Author: mkantor

README.md

@@ -51,7 +51,7 @@ data representation implied by the fact that a value is an atom (e.g. the atom
 `2` may be an integer in memory).
 
 Bare words not containing any
-[reserved character sequences](./src/language/parsing/atom.ts#L19-L41) are
+[reserved character sequences](./src/language/parsing/atom.ts#L33-L57) are
 atoms:
 
 ```

src/language/parsing/atom.ts

@@ -3,69 +3,79 @@ import {
   anySingleCharacter,
   as,
   butNot,
-  lazy,
   literal,
   map,
   oneOf,
   oneOrMore,
   sequence,
   zeroOrMore,
 } from '@matt.kantor/parsing'
+import {
+  backslash,
+  closingBlockCommentDelimiter,
+  closingBrace,
+  closingParenthesis,
+  colon,
+  comma,
+  escapedBackslash,
+  escapedQuote,
+  openingBlockCommentDelimiter,
+  openingBrace,
+  openingParenthesis,
+  quote,
+  singleLineCommentDelimiter,
+} from './literals.js'
 import { optionallySurroundedByParentheses } from './parentheses.js'
 import { whitespace } from './trivia.js'
 
 export type Atom = string
 
 const atomComponentsRequiringQuotation = [
+  backslash,
+  closingBlockCommentDelimiter,
+  closingBrace,
+  closingParenthesis,
+  colon,
+  comma,
+  openingBlockCommentDelimiter,
+  openingBrace,
+  openingParenthesis,
+  quote,
+  singleLineCommentDelimiter,
   whitespace,
-  literal('"'),
-  literal('{'),
-  literal('}'),
+
+  // Reserved for future use:
   literal('['),
   literal(']'),
-  literal('('),
-  literal(')'),
   literal('<'),
   literal('>'),
   literal('#'),
   literal('&'),
   literal('|'),
-  literal('\\'),
   literal('='),
-  literal(':'),
   literal(';'),
-  literal(','),
-  literal('//'),
-  literal('/*'),
-  literal('*/'),
 ] as const
 
-export const atomParser: Parser<Atom> = optionallySurroundedByParentheses(
-  lazy(() => oneOf([unquotedAtomParser, quotedAtomParser])),
-)
-
 export const atomWithAdditionalQuotationRequirements = (
   additionalQuoteRequiringComponent: Parser<unknown>,
 ) =>
   optionallySurroundedByParentheses(
-    lazy(() =>
-      oneOf([
-        map(
-          oneOrMore(
-            butNot(
-              anySingleCharacter,
-              oneOf([
-                ...atomComponentsRequiringQuotation,
-                additionalQuoteRequiringComponent,
-              ]),
-              'a character sequence requiring quotation',
-            ),
+    oneOf([
+      map(
+        oneOrMore(
+          butNot(
+            anySingleCharacter,
+            oneOf([
+              ...atomComponentsRequiringQuotation,
+              additionalQuoteRequiringComponent,
+            ]),
+            'a character sequence requiring quotation',
           ),
-          characters => characters.join(''),
         ),
-        quotedAtomParser,
-      ]),
-    ),
+        characters => characters.join(''),
+      ),
+      quotedAtomParser,
+    ]),
   )
 
 export const unquotedAtomParser = map(
@@ -81,23 +91,23 @@ export const unquotedAtomParser = map(
 
 const quotedAtomParser = map(
   sequence([
-    literal('"'),
+    quote,
     map(
       zeroOrMore(
         oneOf([
           // `"` and `\` need to be escaped
-          butNot(
-            anySingleCharacter,
-            oneOf([literal('"'), literal('\\')]),
-            '`"` or `\\`',
-          ),
-          as(literal('\\"'), '"'),
-          as(literal('\\\\'), '\\'),
+          butNot(anySingleCharacter, oneOf([quote, backslash]), '`"` or `\\`'),
+          as(escapedQuote, '"'),
+          as(escapedBackslash, '\\'),
         ]),
       ),
       output => output.join(''),
     ),
-    literal('"'),
+    quote,
   ]),
   ([_1, contents, _2]) => contents,
 )
+
+export const atomParser: Parser<Atom> = optionallySurroundedByParentheses(
+  oneOf([unquotedAtomParser, quotedAtomParser]),
+)

src/language/parsing/literals.ts

@@ -0,0 +1,20 @@
+import { literal } from '@matt.kantor/parsing'
+
+export const arrow = literal('=>')
+export const asterisk = literal('*')
+export const backslash = literal('\\')
+export const closingBlockCommentDelimiter = literal('*/')
+export const closingBrace = literal('}')
+export const closingParenthesis = literal(')')
+export const colon = literal(':')
+export const comma = literal(',')
+export const dot = literal('.')
+export const escapedBackslash = literal('\\\\')
+export const escapedQuote = literal('\\"')
+export const newline = literal('\n')
+export const openingBlockCommentDelimiter = literal('/*')
+export const openingBrace = literal('{')
+export const openingParenthesis = literal('(')
+export const quote = literal('"')
+export const singleLineCommentDelimiter = literal('//')
+export const slash = literal('/')

src/language/parsing/molecule.ts

@@ -1,6 +1,5 @@
 import {
   lazy,
-  literal,
   map,
   nothing,
   oneOf,
@@ -15,15 +14,21 @@ import {
   atomWithAdditionalQuotationRequirements,
   type Atom,
 } from './atom.js'
+import {
+  arrow,
+  closingBrace,
+  closingParenthesis,
+  colon,
+  comma,
+  dot,
+  openingBrace,
+  openingParenthesis,
+} from './literals.js'
 import { optionallySurroundedByParentheses } from './parentheses.js'
-import { trivia } from './trivia.js'
+import { optionalTrivia, trivia } from './trivia.js'
 
 export type Molecule = { readonly [key: Atom]: Molecule | Atom }
 
-export const moleculeParser: Parser<Molecule> = lazy(
-  () => potentiallySugaredMolecule,
-)
-
 // Keyless properties are automatically assigned numeric indexes, which uses some mutable state.
 type Indexer = () => string
 const makeIncrementingIndexer = (): Indexer => {
@@ -47,7 +52,7 @@ const propertyValue = oneOf([
 ])
 
 const namedProperty = map(
-  sequence([propertyKey, literal(':'), optional(trivia), propertyValue]),
+  sequence([propertyKey, colon, optionalTrivia, propertyValue]),
   ([key, _colon, _trivia, value]) => [key, value] as const,
 )
 
@@ -60,28 +65,28 @@ const property = (index: Indexer) =>
   )
 
 const propertyDelimiter = oneOf([
-  sequence([optional(trivia), literal(','), optional(trivia)]),
+  sequence([optionalTrivia, comma, optionalTrivia]),
   trivia,
 ])
 
 const argument = map(
   sequence([
-    literal('('),
-    optional(trivia),
+    openingParenthesis,
+    optionalTrivia,
     propertyValue,
-    optional(trivia),
-    literal(')'),
+    optionalTrivia,
+    closingParenthesis,
   ]),
   ([_openingParenthesis, _trivia1, argument, _trivia2, _closingParenthesis]) =>
     argument,
 )
 
 const dottedKeyPathComponent = map(
   sequence([
-    optional(trivia),
-    literal('.'),
-    optional(trivia),
-    atomWithAdditionalQuotationRequirements(literal('.')),
+    optionalTrivia,
+    dot,
+    optionalTrivia,
+    atomWithAdditionalQuotationRequirements(dot),
   ]),
   ([_trivia1, _dot, _trivia2, key]) => key,
 )
@@ -91,7 +96,7 @@ const moleculeAsEntries = (
 ): Parser<readonly (readonly [string, string | Molecule])[]> =>
   map(
     sequence([
-      literal('{'),
+      openingBrace,
       // Allow initial property not preceded by a delimiter (e.g. `{a b}`).
       optional(property(index)),
       zeroOrMore(
@@ -101,7 +106,7 @@ const moleculeAsEntries = (
         ),
       ),
       optional(propertyDelimiter),
-      literal('}'),
+      closingBrace,
     ]),
     ([
       _openingBrace,
@@ -125,17 +130,17 @@ const sugarFreeMolecule: Parser<Molecule> = optionallySurroundedByParentheses(
 const sugaredLookup: Parser<Molecule> = optionallySurroundedByParentheses(
   map(
     sequence([
-      literal(':'),
+      colon,
       // Reserve `.` so that `:a.b` is parsed as a lookup followed by an index.
-      atomWithAdditionalQuotationRequirements(literal('.')),
+      atomWithAdditionalQuotationRequirements(dot),
     ]),
     ([_colon, key]) => ({ 0: '@lookup', key }),
   ),
 )
 
 const sugaredFunction: Parser<Molecule> = optionallySurroundedByParentheses(
   map(
-    sequence([atomParser, trivia, literal('=>'), trivia, propertyValue]),
+    sequence([atomParser, trivia, arrow, trivia, propertyValue]),
     ([parameter, _trivia1, _arrow, _trivia2, body]) => ({
       0: '@function',
       parameter,
@@ -210,3 +215,5 @@ const potentiallySugaredMolecule: Parser<Molecule> = (() => {
     potentiallySugaredNonApply,
   ])
 })()
+
+export const moleculeParser: Parser<Molecule> = potentiallySugaredMolecule

src/language/parsing/parentheses.ts

@@ -1,12 +1,6 @@
-import {
-  literal,
-  map,
-  oneOf,
-  sequence,
-  zeroOrMore,
-  type Parser,
-} from '@matt.kantor/parsing'
-import { trivia } from './trivia.js'
+import { map, oneOf, sequence, type Parser } from '@matt.kantor/parsing'
+import { closingParenthesis, openingParenthesis } from './literals.js'
+import { optionalTrivia } from './trivia.js'
 
 const optionallySurroundedBy = <Output>(
   parser1: Parser<unknown>,
@@ -21,16 +15,8 @@ const optionallySurroundedBy = <Output>(
 export const optionallySurroundedByParentheses = <Output>(
   theParser: Parser<Output>,
 ): Parser<Output> =>
-  oneOf([
-    // This allows `theParser` to greedily consume trivia.
-    optionallySurroundedBy(
-      literal('('),
-      theParser,
-      sequence([zeroOrMore(trivia), literal(')')]),
-    ),
-    optionallySurroundedBy(
-      sequence([literal('('), zeroOrMore(trivia)]),
-      theParser,
-      sequence([zeroOrMore(trivia), literal(')')]),
-    ),
-  ])
+  optionallySurroundedBy(
+    sequence([openingParenthesis, optionalTrivia]),
+    theParser,
+    sequence([optionalTrivia, closingParenthesis]),
+  )

src/language/parsing/trivia.ts

@@ -1,33 +1,43 @@
 import {
   anySingleCharacter,
   butNot,
-  literal,
   lookaheadNot,
+  nothing,
   oneOf,
   oneOrMore,
   regularExpression,
   sequence,
   zeroOrMore,
 } from '@matt.kantor/parsing'
+import {
+  asterisk,
+  closingBlockCommentDelimiter,
+  newline,
+  openingBlockCommentDelimiter,
+  singleLineCommentDelimiter,
+  slash,
+} from './literals.js'
 
 const blockComment = sequence([
-  literal('/*'),
+  openingBlockCommentDelimiter,
   zeroOrMore(
     oneOf([
-      butNot(anySingleCharacter, literal('*'), '*'),
-      lookaheadNot(literal('*'), literal('/'), '/'),
+      butNot(anySingleCharacter, asterisk, '*'),
+      lookaheadNot(asterisk, slash, '/'),
     ]),
   ),
-  literal('*/'),
+  closingBlockCommentDelimiter,
 ])
 
 const singleLineComment = sequence([
-  literal('//'),
-  zeroOrMore(butNot(anySingleCharacter, literal('\n'), 'newline')),
+  singleLineCommentDelimiter,
+  zeroOrMore(butNot(anySingleCharacter, newline, 'newline')),
 ])
 
-export const whitespace = regularExpression(/\s+/)
+export const whitespace = regularExpression(/^\s+/)
 
 export const trivia = oneOrMore(
   oneOf([whitespace, singleLineComment, blockComment]),
 )
+
+export const optionalTrivia = oneOf([trivia, nothing])