refactor

Author: neverRare

dictionary/parser.ts

@@ -68,8 +68,7 @@ const unescapedWord = allAtLeastOnce(
     match(WORDS, "word"),
     backtick
       .with(character)
-      .skip(backtick)
-      .map((character) => character),
+      .skip(backtick),
     comment.map(() => ""),
   ),
 )

src/dictionary.ts

@@ -36,19 +36,19 @@ function update(): void {
   }
   redefineSet(
     contentWordSet,
-    (definition) =>
-      definition.type !== "filler" &&
-      definition.type !== "particle definition",
+    ({ type }) =>
+      type !== "filler" &&
+      type !== "particle definition",
   );
-  redefineSetWithTypes(prepositionSet, "preposition");
+  redefineSetWithType(prepositionSet, "preposition");
   redefineSet(
     preverbSet,
     (definition) =>
       (definition.type === "verb" && definition.predicateType != null) ||
       definition.type === "modal verb",
   );
-  redefineSetWithTypes(fillerSet, "filler");
-  redefineSetWithTypes(numeralSet, "numeral");
+  redefineSetWithType(fillerSet, "filler");
+  redefineSetWithType(numeralSet, "numeral");
   redefineSet(tokiPonaWordSet, () => true);
 }
 function redefineSet(
@@ -62,9 +62,9 @@ function redefineSet(
     }
   }
 }
-function redefineSetWithTypes(
+function redefineSetWithType(
   set: Set<string>,
-  type: Definition["type"],
+  compareType: Definition["type"],
 ): void {
-  redefineSet(set, (definition) => definition.type === type);
+  redefineSet(set, ({ type }) => type === compareType);
 }

src/main.ts

@@ -141,7 +141,7 @@ function main(): void {
       errorDisplay.innerText = errorsFixable(flattenError(error))
         ? DICTIONARY_LOADING_FAILED_FIXABLE_MESSAGE
         : DICTIONARY_LOADING_FAILED_UNFIXABLE_MESSAGE;
-        // deno-lint-ignore no-console
+      // deno-lint-ignore no-console
       console.error(error);
     }
   }

src/parser/composer.ts

@@ -131,7 +131,7 @@ export function multiplePredicates(
     case "associated": {
       return [
         multiplePhrases(predicates.predicates, andParticle),
-        ...nullableAsArray(predicates.objects).map((_) => "e"),
+        ...nullableAsArray(predicates.objects).map(() => "e"),
         ...nullableAsArray(predicates.objects)
           .map((objects) => multiplePhrases(objects, "e")),
         ...predicates.prepositions.map(preposition),

src/parser/filter.ts

@@ -28,34 +28,34 @@ export const WORD_UNIT_RULES: ReadonlyArray<(wordUnit: WordUnit) => boolean> = [
 ];
 export const NANPA_RULES: ReadonlyArray<(nanpa: Nanpa) => boolean> = [
   // disallow "nanpa ala nanpa"
-  (modifier) =>
-    modifier.nanpa.type !== "x ala x" ||
+  ({ nanpa: { type } }) =>
+    type !== "x ala x" ||
     throwError(new UnrecognizedError('"nanpa ala nanpa"')),
 
   // nanpa construction cannot contain preposition
-  (modifier) =>
-    modifier.phrase.type !== "preposition" ||
+  ({ phrase: { type } }) =>
+    type !== "preposition" ||
     throwError(new UnrecognizedError("preposition inside nanpa")),
 
   // nanpa construction cannot contain preverb
-  (modifier) =>
-    modifier.phrase.type !== "preverb" ||
+  ({ phrase: { type } }) =>
+    type !== "preverb" ||
     throwError(new UnrecognizedError("preverb inside nanpa")),
 
   // nanpa construction cannot contain pi
-  (modifier) =>
-    modifier.phrase.type !== "default" ||
-    modifier.phrase.modifiers.every((modifier) => modifier.type !== "pi") ||
+  ({ phrase }) =>
+    phrase.type !== "default" ||
+    phrase.modifiers.every(({ type }) => type !== "pi") ||
     throwError(new UnrecognizedError("pi inside nanpa")),
 
   // nanpa construction cannot contain nanpa
-  (modifier) =>
-    modifier.phrase.type !== "default" ||
-    modifier.phrase.modifiers.every((modifier) => modifier.type !== "nanpa") ||
+  ({ phrase }) =>
+    phrase.type !== "default" ||
+    phrase.modifiers.every(({ type }) => type !== "nanpa") ||
     throwError(new UnrecognizedError("nanpa inside nanpa")),
 
   // nanpa cannot have emphasis particle
-  (modifier) => modifier.phrase.emphasis == null,
+  ({ phrase: { emphasis } }) => emphasis == null,
 ];
 export const MODIFIER_RULES: ReadonlyArray<(modifier: Modifier) => boolean> = [
   // pi cannot contain preposition
@@ -101,18 +101,18 @@ export const MULTIPLE_MODIFIERS_RULES: ReadonlyArray<
 > = [
   // // no multiple pi
   // (modifiers) =>
-  //   modifiers.filter((modifier) => modifier.type === "pi").length <= 1 ||
+  //   modifiers.filter(({type}) => type === "pi").length <= 1 ||
   //   throwError(new UnrecognizedError("multiple pi")),
 
   // no multiple nanpa
   (modifiers) =>
-    modifiers.filter((modifier) => modifier.type === "nanpa").length <= 1 ||
+    modifiers.filter(({ type }) => type === "nanpa").length <= 1 ||
     throwError(new UnrecognizedError("multiple nanpa")),
 
   // no multiple proper words
   (modifiers) =>
     modifiers
-        .filter((modifier) => modifier.type === "proper words")
+        .filter(({ type }) => type === "proper words")
         .length <= 1 ||
     throwError(new UnrecognizedError("multiple proper words")),
 
@@ -188,7 +188,7 @@ export const PHRASE_RULE: ReadonlyArray<(phrase: Phrase) => boolean> = [
     if (
       phrase.emphasis == null ||
       everyWordUnitInPhrase(phrase)
-        .every((wordUnit) => wordUnit.emphasis == null)
+        .every(({ emphasis }) => emphasis == null)
     ) {
       return true;
     } else {
@@ -224,7 +224,7 @@ export const PREPOSITION_RULE: ReadonlyArray<(phrase: Preposition) => boolean> =
     (preposition) =>
       preposition.emphasis == null ||
       everyWordUnitInPreposition(preposition)
-        .every((wordUnit) => wordUnit.emphasis == null) ||
+        .every(({ emphasis }) => emphasis == null) ||
       throwError(new UnrecognizedError("nested emphasis")),
   ];
 export const CLAUSE_RULE: ReadonlyArray<(clause: Clause) => boolean> = [
@@ -320,7 +320,7 @@ export const SENTENCE_RULE: ReadonlyArray<(sentence: Sentence) => boolean> = [
 
   // There can't be more than 1 "x ala x" or "seme"
   (sentence) => {
-    if (sentence.interrogative) {
+    if (sentence.interrogative != null) {
       const interrogative = everyWordUnitInSentence(sentence)
         .filter((wordUnit) => {
           switch (wordUnit.type) {
@@ -347,7 +347,7 @@ export const MULTIPLE_SENTENCES_RULE: ReadonlyArray<
 > = [
   // Only allow at most 2 sentences
   (sentences) =>
-    sentences.filter((sentence) => sentence.type !== "filler").length <= 2 ||
+    sentences.filter(({ type }) => type !== "filler").length <= 2 ||
     throwError(new UnrecognizedError("multiple sentences")),
 ];
 export function filter<T>(

src/parser/lexer.ts

@@ -133,7 +133,7 @@ const cartoucheElement = choiceOnlyOne(
         throw new UnrecognizedError("excess dots");
       }
     }),
-  singleUcsurWord.map((word) => word[0]),
+  singleUcsurWord.map(([letter]) => letter),
   match(/[a-zA-Z]/, "Latin letter")
     .map((letter) => letter.toLowerCase())
     .skip(spaces),
@@ -160,8 +160,7 @@ function longContainer<T>(
 ): Parser<T> {
   return specificSpecialUcsur(left)
     .with(inside)
-    .skip(specificSpecialUcsur(right))
-    .map((inside) => inside);
+    .skip(specificSpecialUcsur(right));
 }
 const longSpaceContainer = longContainer(
   START_OF_LONG_GLYPH,

src/parser/parser.ts

@@ -284,8 +284,7 @@ const pi = choice(
   specificToken("headed long glyph start")
     .filter(({ words }) => filterCombinedGlyphs(words, "pi"))
     .with(phrase)
-    .skip(specificToken("headless long glyph end"))
-    .map((phrase) => phrase),
+    .skip(specificToken("headless long glyph end")),
   specificWord("pi").with(phrase),
 );
 const modifiers = sequence(
@@ -395,23 +394,23 @@ const preposition = choice<Preposition>(
     })),
   sequence(
     specificToken("headed long glyph start")
-      .map((words) => {
-        if (words.words.length > 2) {
+      .map(({ words }) => {
+        if (words.length > 2) {
           throw new UnrecognizedError(
-            `combined glyphs of ${words.words.length} words`,
+            `combined glyphs of ${words.length} words`,
           );
         } else {
-          const word = words.words[0];
+          const [word] = words;
           if (!prepositionSet.has(word)) {
             throw new UnrecognizedError(`"${word}" as preposition`);
           } else {
-            return words.words;
+            return words;
           }
         }
       }),
     phrase,
-    specificToken("headless long glyph end"),
   )
+    .skip(specificToken("headless long glyph end"))
     .map<Preposition>(([words, phrase]) => {
       const modifiers = words
         .slice(1)
@@ -617,16 +616,16 @@ const la = choice(
 );
 const filler = choice<Filler>(
   specificToken("space long glyph")
-    .map((longGlyph) =>
-      longGlyph.words.length === 1
+    .map(({ words, spaceLength }) =>
+      words.length === 1
         ? {
           type: "long word",
-          word: longGlyph.words[0],
-          length: longGlyph.spaceLength,
+          word: words[0],
+          length: spaceLength,
         }
         : throwError(
           new UnexpectedError(
-            describe({ type: "combined glyphs", words: longGlyph.words }),
+            describe({ type: "combined glyphs", words: words }),
             "simple glyph",
           ),
         )
@@ -690,16 +689,15 @@ const sentence = choice<Sentence>(
           interrogative: null,
         };
         const wordUnits = everyWordUnitInSentence(sentence);
-        const interrogative =
-          wordUnits.some((wordUnit) => wordUnit.type === "x ala x")
-            ? "x ala x"
-            : wordUnits.some((wordUnit) =>
-                (wordUnit.type === "default" ||
-                  wordUnit.type === "reduplication") &&
-                wordUnit.word === "seme"
-              )
-            ? "seme"
-            : null;
+        const interrogative = wordUnits.some(({ type }) => type === "x ala x")
+          ? "x ala x"
+          : wordUnits.some((wordUnit) =>
+              (wordUnit.type === "default" ||
+                wordUnit.type === "reduplication") &&
+              wordUnit.word === "seme"
+            )
+          ? "seme"
+          : null;
         return { ...sentence, interrogative };
       },
     )

src/parser/parser_lib.ts

@@ -265,9 +265,9 @@ export function withSource<T>(
   parser: Parser<T>,
 ): Parser<readonly [value: T, source: string]> {
   return new Parser((src) =>
-    parser.unmemoizedParser(src).map((value) => ({
-      value: [value.value, src.slice(0, src.length - value.rest.length)],
-      rest: value.rest,
+    parser.unmemoizedParser(src).map(({ value, rest }) => ({
+      value: [value, src.slice(0, src.length - rest.length)],
+      rest,
     }))
   );
 }

src/settings_frontend.ts

@@ -36,7 +36,7 @@ const REDUNDANCY_UPDATER: Updater<RedundancySettings> = {
       ? value as RedundancySettings
       : null,
   stringify: (value) => value,
-  load: (input) => input.value as RedundancySettings,
+  load: ({ value }) => value as RedundancySettings,
   set: (input, value) => {
     input.value = value;
   },

src/translator/composer.ts

@@ -30,11 +30,11 @@ export function noun(phrases: English.NounPhrase, depth: number): string {
   switch (phrases.type) {
     case "simple": {
       const text = [
-        ...phrases.determiner.map((determiner) => word(determiner.determiner)),
+        ...phrases.determiner.map(({ determiner }) => word(determiner)),
         ...phrases.adjective.map(adjective),
         word(phrases.noun),
         ...nullableAsArray(phrases.postAdjective)
-          .map((adjective) => `${adjective.adjective} ${adjective.name}`),
+          .map(({ adjective, name }) => `${adjective} ${name}`),
         ...phrases.preposition.map(preposition),
       ]
         .join(" ");

src/translator/determiner.ts

@@ -10,21 +10,19 @@ import { word } from "./word.ts";
 function prettyPrintDeterminers(
   determiners: ReadonlyArray<English.Determiner>,
 ): string {
-  return `(${
-    determiners.map((determiner) => determiner.determiner).join(` `)
-  })`;
+  return `(${determiners.map(({ determiner }) => determiner).join(` `)})`;
 }
 function filterKind(
   determiners: ReadonlyArray<English.Determiner>,
   kinds: ReadonlyArray<Dictionary.DeterminerType>,
 ): ReadonlyArray<English.Determiner> {
-  return determiners.filter((determiner) => kinds.includes(determiner.kind));
+  return determiners.filter(({ kind }) => kinds.includes(kind));
 }
 function filterQuantity(
   determiners: ReadonlyArray<English.Determiner>,
-  quantity: Dictionary.Quantity,
+  targetQuantity: Dictionary.Quantity,
 ): ReadonlyArray<English.Determiner> {
-  return determiners.filter((determiner) => determiner.quantity === quantity);
+  return determiners.filter(({ quantity }) => quantity === targetQuantity);
 }
 function check(
   quantities: ReadonlyArray<Dictionary.Quantity>,
@@ -37,7 +35,7 @@ function check(
 export function findNumber(
   determiners: ReadonlyArray<English.Determiner>,
 ): Dictionary.Quantity {
-  const quantities = determiners.map((determiner) => determiner.quantity);
+  const quantities = determiners.map(({ quantity }) => quantity);
   if (quantities.every((quantity) => quantity === `both`)) {
     return "both";
   } else if (check(quantities, "singular", "plural")) {