refactor

Author: neverRare

dictionary/parser.ts

@@ -20,14 +20,7 @@ import {
   UnexpectedError,
   withSource,
 } from "../src/parser/parser_lib.ts";
-import {
-  Definition,
-  Determiner,
-  Dictionary,
-  Noun,
-  NounForms,
-  VerbForms,
-} from "./type.ts";
+import { Definition, Dictionary, VerbForms } from "./type.ts";
 
 const RESERVED_SYMBOLS = "#()*+/:;<=>@[\\]^`{|}~";
 const WORDS = new RegExp(`[^${escapeRegex(RESERVED_SYMBOLS)}]`);
@@ -117,66 +110,62 @@ const nounOnly = choiceOnlyOne(
         .with(optionalAll(keyword("gerund"))),
     ),
   )
-    .map<NounForms & { gerund: boolean }>(
-      ([noun, gerund]) => {
-        const sentence = nlp(noun);
-        sentence.tag("Noun");
-        const singular = sentence
-          .nouns()
-          .toSingular()
-          .text();
-        const plural = sentence
-          .nouns()
-          .toPlural()
-          .text();
-        if (singular === "" || plural === "") {
-          throw new ArrayResultError(
-            `no singular or plural form found for "${noun}". consider ` +
-              "providing both singular and plural forms instead",
-          );
-        }
-        if (noun !== singular) {
-          throw new ArrayResultError(
-            `conjugation error: "${noun}" is not "${singular}". ` +
-              "consider providing both singular and plural forms instead",
-          );
-        }
-        return {
-          singular: escapeHtml(singular),
-          plural: escapeHtml(plural),
-          gerund: gerund != null,
-        };
-      },
-    ),
+    .map(([noun, gerund]) => {
+      const sentence = nlp(noun);
+      sentence.tag("Noun");
+      const singular = sentence
+        .nouns()
+        .toSingular()
+        .text();
+      const plural = sentence
+        .nouns()
+        .toPlural()
+        .text();
+      if (singular === "" || plural === "") {
+        throw new ArrayResultError(
+          `no singular or plural form found for "${noun}". consider ` +
+            "providing both singular and plural forms instead",
+        );
+      }
+      if (noun !== singular) {
+        throw new ArrayResultError(
+          `conjugation error: "${noun}" is not "${singular}". ` +
+            "consider providing both singular and plural forms instead",
+        );
+      }
+      return {
+        singular: escapeHtml(singular),
+        plural: escapeHtml(plural),
+        gerund: gerund != null,
+      };
+    }),
   sequence(
     word,
     tag(
       keyword("n")
         .with(sequence(optionalAll(keyword("gerund")), number)),
     ),
   )
-    .map<NounForms & { gerund: boolean }>(
-      ([noun, [gerund, number]]) => {
-        let singular: null | string;
-        let plural: null | string;
-        switch (number) {
-          case "singular":
-          case "plural":
-            switch (number) {
-              case "singular":
-                singular = noun;
-                plural = null;
-                break;
-              case "plural":
-                singular = null;
-                plural = noun;
-                break;
-            }
-            break;
-        }
-        return { singular, plural, gerund: gerund != null };
-      },
-    ),
+    .map(([noun, [gerund, number]]) => {
+      let singular: null | string;
+      let plural: null | string;
+      switch (number) {
+        case "singular":
+        case "plural":
+          switch (number) {
+            case "singular":
+              singular = noun;
+              plural = null;
+              break;
+            case "plural":
+              singular = null;
+              plural = noun;
+              break;
+          }
+          break;
+      }
+      return { singular, plural, gerund: gerund != null };
+    }),
   sequence(
     word,
     optionalAll(slash.with(word)),
@@ -185,13 +174,11 @@ const nounOnly = choiceOnlyOne(
         .with(optionalAll(keyword("gerund"))),
     ),
   )
-    .map<NounForms & { gerund: boolean }>(
-      ([singular, plural, gerund]) => ({
-        singular,
-        plural,
-        gerund: gerund != null,
-      }),
-    ),
+    .map(([singular, plural, gerund]) => ({
+      singular,
+      plural,
+      gerund: gerund != null,
+    })),
 );
 const determinerType = choiceOnlyOne(
   keyword("article"),
@@ -208,17 +195,19 @@ const determiner = sequence(
   optionalAll(slash.with(word)),
   tag(keyword("d").with(sequence(determinerType, optionalNumber))),
 )
-  .map<Determiner>(([determiner, plural, [kind, quantity]]) => ({
-    determiner,
-    plural,
-    kind,
-    quantity: quantity ?? "both",
-  }));
+  .map(([determiner, plural, [kind, quantity]]) =>
+    ({
+      determiner,
+      plural,
+      kind,
+      quantity: quantity ?? "both",
+    }) as const
+  );
 const adjectiveKind = choiceOnlyOne(
   keyword("opinion"),
   keyword("size"),
   sequence(keyword("physical"), keyword("quality"))
-    .map<"physical quality">(() => "physical quality"),
+    .map(() => "physical quality" as const),
   keyword("age"),
   keyword("color"),
   keyword("origin"),
@@ -249,17 +238,17 @@ const noun = sequence(
       .skip(tag(sequence(keyword("n"), keyword("proper")))),
   ),
 )
-  .map<Noun>(([determiner, adjective, noun, post]) => {
-    return {
+  .map(([determiner, adjective, noun, post]) =>
+    ({
       ...noun,
       determiner,
       adjective,
       postAdjective: mapNullable(
         post,
         ([adjective, name]) => ({ adjective, name }),
       ),
-    };
-  });
+    }) as const
+  );
 function verbOnly(tagInside: Parser<unknown>): Parser<VerbForms> {
   return choiceOnlyOne(
     sequence(
@@ -437,15 +426,13 @@ const definition = choiceOnlyOne<Definition>(
     ),
   )
     .skip(semicolon)
-    .map((
-      [
-        singularSubject,
-        singularObject,
-        pluralSubject,
-        pluralObject,
-        perspective,
-      ],
-    ) => ({
+    .map(([
+      singularSubject,
+      singularObject,
+      pluralSubject,
+      pluralObject,
+      perspective,
+    ]) => ({
       type: "personal pronoun",
       singular: { subject: singularSubject, object: singularObject },
       plural: { subject: pluralSubject, object: pluralObject },

src/parser/filter.ts

@@ -370,7 +370,7 @@ export function filter<T>(
   rules: ReadonlyArray<(value: T) => boolean>,
 ): (value: T) => boolean {
   return (value) => {
-    const result: ReadonlyArray<null | ReadonlyArray<unknown>> = rules.map(
+    const result = rules.map(
       (rule) => {
         try {
           if (rule(value)) {

src/parser/lexer.ts

@@ -70,7 +70,7 @@ const properWords = allAtLeastOnce(
   match(/[A-Z][a-zA-Z]*/, "proper word").skip(spaces),
 )
   .map((array) => array.join(" "))
-  .map<Token>((words) => ({ type: "proper word", words, kind: "latin" }));
+  .map((words) => ({ type: "proper word", words, kind: "latin" }) as const);
 function specificWord(thatWord: string): Parser<string> {
   return word.filter((thisWord) =>
     thatWord === thisWord ||
@@ -79,20 +79,18 @@ function specificWord(thatWord: string): Parser<string> {
 }
 const multipleA = specificWord("a")
   .with(count(allAtLeastOnce(specificWord("a"))))
-  .map<Token>((count) => ({ type: "multiple a", count: count + 1 }));
+  .map((count) => ({ type: "multiple a", count: count + 1 }) as const);
 const repeatingLetter = match(/[a-zA-Z]/, "latin letter")
   .then((letter) =>
     count(all(matchString(letter)))
-      .map<readonly [letter: string, number: number]>(
-        (count) => [letter, count + 1],
-      )
+      .map((count) => [letter, count + 1] as const)
   );
 const longWord = allAtLeastOnce(repeatingLetter)
   .skip(spaces)
-  .map<Token & { type: "long word" }>((letters) => {
+  .map((letters) => {
     const word = letters.map(([letter]) => letter).join("");
     const length = sumOf(letters, ([_, count]) => count) - word.length + 1;
-    return { type: "long word", word, length };
+    return { type: "long word", word, length } as const;
   })
   .filter(({ word }) => /^[a-z]/.test(word))
   .filter(({ length }) => length > 1);
@@ -102,7 +100,7 @@ const xAlaX = lazy(() =>
       sequence(specificWord("ala"), specificWord(word)).map(() => word)
     )
 )
-  .map<Token>((word) => ({ type: "x ala x", word }));
+  .map((word) => ({ type: "x ala x", word }) as const);
 const punctuation = choiceOnlyOne(
   allAtLeastOnce(
     match(SENTENCE_TERMINATOR, "punctuation")
@@ -112,7 +110,7 @@ const punctuation = choiceOnlyOne(
     .map((punctuation) => punctuation.join("").replaceAll("...", ELLIPSIS)),
   newline.map(() => "."),
 )
-  .map<Token>((punctuation) => ({ type: "punctuation", punctuation }));
+  .map((punctuation) => ({ type: "punctuation", punctuation }) as const);
 const cartoucheElement = choiceOnlyOne(
   singleUcsurWord
     .skip(match(NSK_COLON, "full width colon").skip(spaces)),
@@ -148,11 +146,13 @@ const cartouche = specificSpecialUcsur(START_OF_CARTOUCHE)
   );
 const cartouches = allAtLeastOnce(cartouche)
   .map((words) => words.join(" "))
-  .map<Token>((words) => ({
-    type: "proper word",
-    words,
-    kind: "cartouche",
-  }));
+  .map((words) =>
+    ({
+      type: "proper word",
+      words,
+      kind: "cartouche",
+    }) as const
+  );
 function longContainer<T>(
   left: string,
   right: string,
@@ -172,42 +172,47 @@ const longGlyphHead = choiceOnlyOne(
   combinedGlyphs,
   ucsur.map((word) => [word]),
 );
-const spaceLongGlyph = sequence(longGlyphHead, longSpaceContainer)
-  .map<Token>(([words, spaceLength]) => ({
-    type: "space long glyph",
-    words,
-    spaceLength,
-  }));
+const spaceLongGlyph = sequence(
+  longGlyphHead,
+  longSpaceContainer,
+)
+  .map(([words, spaceLength]) =>
+    ({
+      type: "space long glyph",
+      words,
+      spaceLength,
+    }) as const
+  );
 const headedLongGlyphStart = longGlyphHead
   .skip(specificSpecialUcsur(START_OF_LONG_GLYPH))
   .skip(spaces)
-  .map<Token>((words) => ({ type: "headed long glyph start", words }));
+  .map((words) => ({ type: "headed long glyph start", words }) as const);
 const headlessLongGlyphEnd = specificSpecialUcsur(END_OF_LONG_GLYPH)
   .skip(spaces)
-  .map<Token>(() => ({ type: "headless long glyph end" }));
+  .map(() => ({ type: "headless long glyph end" }) as const);
 const headlessLongGlyphStart = specificSpecialUcsur(START_OF_REVERSE_LONG_GLYPH)
   .skip(spaces)
-  .map<Token>(() => ({ type: "headless long glyph end" }));
+  .map(() => ({ type: "headless long glyph end" }) as const);
 const headedLongGlyphEnd = specificSpecialUcsur(END_OF_REVERSE_LONG_GLYPH)
   .with(longGlyphHead)
   .skip(spaces)
-  .map<Token>((words) => ({ type: "headed long glyph start", words }));
+  .map((words) => ({ type: "headed long glyph start", words }) as const);
 const insideLongGlyph = specificSpecialUcsur(END_OF_REVERSE_LONG_GLYPH)
   .with(longGlyphHead)
   .skip(specificSpecialUcsur(START_OF_LONG_GLYPH))
   .skip(spaces)
-  .map<Token>((words) => ({ type: "inside long glyph", words }));
+  .map((words) => ({ type: "inside long glyph", words }) as const);
 const combinedGlyphsToken = combinedGlyphs
   .skip(spaces)
-  .map<Token>((words) => ({ type: "combined glyphs", words }));
-const wordToken = word.map<Token>((word) => ({ type: "word", word }));
+  .map((words) => ({ type: "combined glyphs", words }) as const);
+const wordToken = word.map((word) => ({ type: "word", word }) as const);
 
 Parser.startCache(cache);
 
-export const token = choiceOnlyOne(
+export const token = choiceOnlyOne<Token>(
   xAlaX,
   multipleA,
-  choice(longWord, wordToken),
+  choice<Token>(longWord, wordToken),
   properWords,
   // UCSUR only
   spaceLongGlyph,