refactor

Author: neverRare

dictionary/parser.ts

@@ -36,21 +36,30 @@ import {
 const RESERVED_SYMBOLS = "#()*+/:;<=>@[\\]^`{|}~";
 const WORDS = new RegExp(`[^${escapeRegex(RESERVED_SYMBOLS)}]`);
 
+function lex<T>(parser: Parser<T>): Parser<T> {
+  return parser.skip(spaces);
+}
 const comment = match(/#[^\n\r]*/, "comment");
 const spaces = sourceOnly(all(choiceOnlyOne(match(/\s/, "space"), comment)));
-const tokiPonaWord = match(/[a-z][a-zA-Z]*/, "word");
 const backtick = matchString("`", "backtick");
-const openParenthesis = matchString("(", "open parenthesis");
-const closeParenthesis = matchString(")", "close parenthesis");
-const openBracket = matchString("[", "open bracket");
-const closeBracket = matchString("]", "close bracket");
-const comma = matchString(",", "comma");
-const colon = matchString(":", "colon");
+
+const tokiPonaWord = lex(match(/[a-z][a-zA-Z]*/, "word"));
+const openParenthesis = lex(matchString("(", "open parenthesis"));
+const closeParenthesis = lex(matchString(")", "close parenthesis"));
+const openBracket = lex(matchString("[", "open bracket"));
+const closeBracket = lex(matchString("]", "close bracket"));
+const comma = lex(matchString(",", "comma"));
+const colon = lex(matchString(":", "colon"));
 const semicolon = lex(matchString(";", "semicolon"));
+const slash = lex(matchString("/", "slash"));
 
-function lex<T>(parser: Parser<T>): Parser<T> {
-  return parser.skip(spaces);
-}
+const keyword = memoize(<T extends string>(keyword: T): Parser<T> =>
+  lex(match(/[a-z\-]+/, keyword))
+    .filter((that) =>
+      keyword === that ||
+      throwError(new UnexpectedError(`"${that}"`, `"${keyword}"`))
+    ) as Parser<T>
+);
 const unescapedWord = allAtLeastOnce(
   choiceOnlyOne(
     match(WORDS, "word"),
@@ -65,17 +74,8 @@ const unescapedWord = allAtLeastOnce(
     word !== "" || throwError(new ArrayResultError("missing word"))
   );
 const word = unescapedWord.map(escapeHtml);
-const slash = lex(matchString("/", "slash"));
 const forms = sequence(word, all(slash.with(word)))
   .map(([first, rest]) => [first, ...rest]);
-
-const keyword = memoize(<T extends string>(keyword: T): Parser<T> =>
-  lex(match(/[a-z\-]+/, keyword))
-    .filter((that) =>
-      keyword === that ||
-      throwError(new UnexpectedError(`"${that}"`, `"${keyword}"`))
-    ) as Parser<T>
-);
 const number = choiceOnlyOne(keyword("singular"), keyword("plural"));
 const optionalNumber = optionalAll(number);
 const perspective = choiceOnlyOne(
@@ -84,12 +84,10 @@ const perspective = choiceOnlyOne(
   keyword("third"),
 );
 function tag<T>(parser: Parser<T>): Parser<T> {
-  return lex(openParenthesis)
-    .with(parser)
-    .skip(lex(closeParenthesis));
+  return openParenthesis.with(parser).skip(closeParenthesis);
 }
 function template<T>(parser: Parser<T>): Parser<T> {
-  return lex(openBracket).with(parser).skip(lex(closeBracket));
+  return openBracket.with(parser).skip(closeBracket);
 }
 const simpleUnit = memoize((kind: string) => word.skip(tag(keyword(kind))));
 function detectRepetition(
@@ -498,11 +496,7 @@ const definition = choiceOnlyOne<Definition>(
       type: "filler",
     })),
 );
-const singleWord = lex(tokiPonaWord);
-const head = sequence(
-  all(singleWord.skip(lex(comma))),
-  singleWord,
-)
+const head = sequence(all(tokiPonaWord.skip(comma)), tokiPonaWord)
   .skip(colon)
   .map(([init, last]) => [...init, last]);
 const entry = withSource(spaces.with(all(definition)))