Factor out literal parsers to shared static constants

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

@@ -8,38 +8,54 @@ import {
   oneOf,
   oneOrMore,
   sequence,
-  zeroOrMore
+  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 atomWithAdditionalQuotationRequirements = (
   additionalQuoteRequiringComponent: Parser<unknown>,
 ) =>
@@ -75,23 +91,19 @@ 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,
 )

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,6 +14,16 @@ 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'
 
@@ -43,7 +52,7 @@ const propertyValue = oneOf([
 ])
 
 const namedProperty = map(
-  sequence([propertyKey, literal(':'), optional(trivia), propertyValue]),
+  sequence([propertyKey, colon, optional(trivia), propertyValue]),
   ([key, _colon, _trivia, value]) => [key, value] as const,
 )
 
@@ -56,17 +65,17 @@ const property = (index: Indexer) =>
   )
 
 const propertyDelimiter = oneOf([
-  sequence([optional(trivia), literal(','), optional(trivia)]),
+  sequence([optional(trivia), comma, optional(trivia)]),
   trivia,
 ])
 
 const argument = map(
   sequence([
-    literal('('),
+    openingParenthesis,
     optional(trivia),
     propertyValue,
     optional(trivia),
-    literal(')'),
+    closingParenthesis,
   ]),
   ([_openingParenthesis, _trivia1, argument, _trivia2, _closingParenthesis]) =>
     argument,
@@ -75,9 +84,9 @@ const argument = map(
 const dottedKeyPathComponent = map(
   sequence([
     optional(trivia),
-    literal('.'),
+    dot,
     optional(trivia),
-    atomWithAdditionalQuotationRequirements(literal('.')),
+    atomWithAdditionalQuotationRequirements(dot),
   ]),
   ([_trivia1, _dot, _trivia2, key]) => key,
 )
@@ -87,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(
@@ -97,7 +106,7 @@ const moleculeAsEntries = (
         ),
       ),
       optional(propertyDelimiter),
-      literal('}'),
+      closingBrace,
     ]),
     ([
       _openingBrace,
@@ -121,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,

src/language/parsing/parentheses.ts

@@ -1,11 +1,11 @@
 import {
-  literal,
   map,
   oneOf,
   sequence,
   zeroOrMore,
   type Parser,
 } from '@matt.kantor/parsing'
+import { closingParenthesis, openingParenthesis } from './literals.js'
 import { trivia } from './trivia.js'
 
 const optionallySurroundedBy = <Output>(
@@ -24,13 +24,13 @@ export const optionallySurroundedByParentheses = <Output>(
   oneOf([
     // This allows `theParser` to greedily consume trivia.
     optionallySurroundedBy(
-      literal('('),
+      openingParenthesis,
       theParser,
-      sequence([zeroOrMore(trivia), literal(')')]),
+      sequence([zeroOrMore(trivia), closingParenthesis]),
     ),
     optionallySurroundedBy(
-      sequence([literal('('), zeroOrMore(trivia)]),
+      sequence([openingParenthesis, zeroOrMore(trivia)]),
       theParser,
-      sequence([zeroOrMore(trivia), literal(')')]),
+      sequence([zeroOrMore(trivia), closingParenthesis]),
     ),
   ])

src/language/parsing/trivia.ts

@@ -1,29 +1,36 @@
 import {
   anySingleCharacter,
   butNot,
-  literal,
   lookaheadNot,
   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+/)