remove unneeded as const

Author: neverRare

dictionary/parser.ts

@@ -193,14 +193,12 @@ const determiner = checkedSequence(
   ),
   sequence(determinerType, optionalNumber.skip(closeParenthesis)),
 )
-  .map(([[determiner, plural], [kind, quantity]]) =>
-    ({
-      determiner,
-      plural,
-      kind,
-      quantity: quantity ?? "both",
-    }) as const
-  );
+  .map(([[determiner, plural], [kind, quantity]]) => ({
+    determiner,
+    plural,
+    kind,
+    quantity: quantity ?? "both",
+  }));
 const adjectiveKind = choiceWithCheck(
   checkedSequence(keyword("physical"), keyword("quality"))
     .map(() => "physical quality" as const),
@@ -244,14 +242,12 @@ const noun = sequence(
       .map(([adjective, name]) => ({ adjective, name })),
   ),
 )
-  .map(([determiner, adjective, noun, postAdjective]) =>
-    ({
-      ...noun,
-      determiner,
-      adjective,
-      postAdjective,
-    }) as const
-  );
+  .map(([determiner, adjective, noun, postAdjective]) => ({
+    ...noun,
+    determiner,
+    adjective,
+    postAdjective,
+  }));
 const checkedNoun = new CheckedParser(
   choiceOnlyOne(
     determiner.check,
@@ -277,28 +273,26 @@ function checkedSimpleUnitWithTemplate(
     .map(([word]) => word);
 }
 const interjectionDefinition = checkedSimpleUnit("i")
-  .map((interjection) => ({ type: "interjection", interjection }) as const);
+  .map((interjection) => ({ type: "interjection", interjection }));
 const particleDefinition = checkedSequence(
   word.skip(openParenthesis).skip(keyword("particle")),
   sequence(keyword("def"), closeParenthesis),
 )
-  .map(([definition]) =>
-    ({ type: "particle definition", definition }) as const
-  );
+  .map(([definition]) => ({ type: "particle definition", definition }));
 const adverbDefinition = checkedSimpleUnit("adv")
-  .map((adverb) => ({ type: "adverb", adverb }) as const);
+  .map((adverb) => ({ type: "adverb", adverb }));
 const prepositionDefinition = checkedSimpleUnitWithTemplate(
   "prep",
   sequence(keyword("indirect"), keyword("object")),
 )
-  .map((preposition) => ({ type: "preposition", preposition }) as const);
+  .map((preposition) => ({ type: "preposition", preposition }));
 const numeralDefinition = checkedSimpleUnit("num")
   .mapWithPositionedError((num) => {
     const numeral = +num;
     if (!Number.isInteger(numeral)) {
       throw `"${num}" is not a number`;
     } else {
-      return { type: "numeral", numeral } as const;
+      return { type: "numeral", numeral };
     }
   });
 const fillerDefinition = checkedSequence(
@@ -320,7 +314,7 @@ const fillerDefinition = checkedSequence(
         before: forms[0],
         repeat: "",
         after: "",
-      } as const;
+      };
     }
     const [first, ...rest] = forms;
     for (let i = 0; i < first.length; i++) {
@@ -332,7 +326,7 @@ const fillerDefinition = checkedSequence(
           test === `${before}${repeatString.repeat(i + 2)}${after}`
         );
       if (passed) {
-        return { type: "filler", before, repeat: repeatString, after } as const;
+        return { type: "filler", before, repeat: repeatString, after };
       }
     }
     throw `"${forms.join("/")}" has no repetition pattern found`;
@@ -349,14 +343,12 @@ const fourFormPersonalPronounDefinition = checkedSequence(
   .map(([
     [singularSubject, singularObject, pluralSubject, pluralObject],
     perspective,
-  ]) =>
-    ({
-      type: "personal pronoun",
-      singular: { subject: singularSubject, object: singularObject },
-      plural: { subject: pluralSubject, object: pluralObject },
-      perspective,
-    }) as const
-  );
+  ]) => ({
+    type: "personal pronoun",
+    singular: { subject: singularSubject, object: singularObject },
+    plural: { subject: pluralSubject, object: pluralObject },
+    perspective,
+  }));
 const twoFormPersonalPronounDefinition = checkedSequence(
   sequence(
     word.skip(slash),
@@ -367,15 +359,13 @@ const twoFormPersonalPronounDefinition = checkedSequence(
     number.skip(closeParenthesis),
   ),
 )
-  .map(([[subject, object], [perspective, number]]) =>
-    ({
-      type: "personal pronoun",
-      singular: null,
-      plural: null,
-      [number]: { subject, object },
-      perspective,
-    }) as const
-  );
+  .map(([[subject, object], [perspective, number]]) => ({
+    type: "personal pronoun",
+    singular: null,
+    plural: null,
+    [number]: { subject, object },
+    perspective,
+  }));
 const nounDefinition = new CheckedParser(
   choiceWithCheck(
     new CheckedParser(
@@ -403,8 +393,8 @@ const nounDefinition = new CheckedParser(
 )
   .map(([noun, preposition]) =>
     preposition == null
-      ? { ...noun, type: "noun" } as const
-      : { type: "noun preposition", noun, preposition } as const
+      ? { ...noun, type: "noun" }
+      : { type: "noun preposition", noun, preposition }
   );
 const compoundAdjectiveDefinition = checkedSequence(
   adjective
@@ -414,7 +404,7 @@ const compoundAdjectiveDefinition = checkedSequence(
     .skip(keyword("c")),
   closeParenthesis.with(adjective.parser),
 )
-  .map((adjective) => ({ type: "compound adjective", adjective }) as const)
+  .map((adjective) => ({ type: "compound adjective", adjective }))
   .filterWithPositionedError(({ adjective }) =>
     adjective.every((adjective) => adjective.adverb.length === 0) ||
     throwError("compound adjective cannot have adverb")
@@ -434,7 +424,7 @@ const verbDefinition = checkedSequence(
       closeBracket
         .with(optionalWithCheck(
           checkedSimpleUnitWith("prep", noun)
-            .map(([preposition, object]) => ({ preposition, object }) as const),
+            .map(([preposition, object]) => ({ preposition, object })),
         ))
         .map(nullableAsArray),
     )
@@ -481,7 +471,7 @@ const verbDefinition = checkedSequence(
                 openBracket,
                 sequence(keyword("object"), closeBracket),
               )
-                .map(() => "template" as const),
+                .map(() => "template"),
               checkedNoun,
             ),
           ),

src/parser/lexer.ts

@@ -66,7 +66,7 @@ const properWords = allAtLeastOnce(
   match(/[A-Z][a-zA-Z]*/, "proper word").skip(spaces),
 )
   .map((array) => array.join(" "))
-  .map((words) => ({ type: "proper word", words, kind: "latin" }) as const);
+  .map((words) => ({ type: "proper word", words, kind: "latin" }) );
 
 const specificWord = memoize((thatWord: string) =>
   word.filter((thisWord) =>
@@ -76,7 +76,7 @@ const specificWord = memoize((thatWord: string) =>
 );
 const multipleA = specificWord("a")
   .with(count(allAtLeastOnce(specificWord("a"))))
-  .map((count) => ({ type: "multiple a", count: count + 1 }) as const);
+  .map((count) => ({ type: "multiple a", count: count + 1 }) );
 const repeatingLetter = match(/[a-zA-Z]/, "latin letter")
   .then(memoize((letter) =>
     count(all(matchString(letter)))
@@ -87,15 +87,15 @@ const longWord = allAtLeastOnce(repeatingLetter)
   .map((letters) => {
     const word = letters.map(([letter]) => letter).join("");
     const length = sumOf(letters, ([_, count]) => count) - word.length + 1;
-    return { type: "long word", word, length } as const;
+    return { type: "long word", word, length } ;
   })
   .filter(({ word, length }) => /^[a-z]/.test(word) && length > 1);
 
 const alaX = memoize((word: string) =>
   sequence(specificWord("ala"), specificWord(word)).map(() => word)
 );
 const xAlaX = lazy(() => settings.xAlaXPartialParsing ? empty : word.then(alaX))
-  .map((word) => ({ type: "x ala x", word }) as const);
+  .map((word) => ({ type: "x ala x", word }) );
 const punctuation = choiceOnlyOne(
   allAtLeastOnce(
     match(SENTENCE_TERMINATOR, "punctuation")
@@ -105,7 +105,7 @@ const punctuation = choiceOnlyOne(
     .map((punctuation) => punctuation.join("").replaceAll("...", ELLIPSIS)),
   newline.map(() => "."),
 )
-  .map((punctuation) => ({ type: "punctuation", punctuation }) as const);
+  .map((punctuation) => ({ type: "punctuation", punctuation }) );
 const cartoucheElement = choiceOnlyOne(
   singleUcsurWord
     .skip(match(NSK_COLON, "full width colon").skip(spaces)),
@@ -146,7 +146,7 @@ const cartouches = allAtLeastOnce(cartouche)
       type: "proper word",
       words,
       kind: "cartouche",
-    }) as const
+    }) 
   );
 const longSpaceContainer = specificSpecialUcsur(START_OF_LONG_GLYPH)
   .with(count(spacesWithoutNewline).filter((length) => length > 0))
@@ -165,31 +165,31 @@ const spaceLongGlyph = sequence(
       type: "space long glyph",
       words,
       spaceLength,
-    }) as const
+    }) 
   );
 const headedLongGlyphStart = longGlyphHead
   .skip(specificSpecialUcsur(START_OF_LONG_GLYPH))
   .skip(spaces)
-  .map((words) => ({ type: "headed long glyph start", words }) as const);
+  .map((words) => ({ type: "headed long glyph start", words }) );
 const headlessLongGlyphEnd = specificSpecialUcsur(END_OF_LONG_GLYPH)
   .skip(spaces)
-  .map(() => ({ type: "headless long glyph end" }) as const);
+  .map(() => ({ type: "headless long glyph end" }) );
 const headlessLongGlyphStart = specificSpecialUcsur(START_OF_REVERSE_LONG_GLYPH)
   .skip(spaces)
-  .map(() => ({ type: "headless long glyph end" }) as const);
+  .map(() => ({ type: "headless long glyph end" }) );
 const headedLongGlyphEnd = specificSpecialUcsur(END_OF_REVERSE_LONG_GLYPH)
   .with(longGlyphHead)
   .skip(spaces)
-  .map((words) => ({ type: "headed long glyph start", words }) as const);
+  .map((words) => ({ type: "headed long glyph start", words }) );
 const insideLongGlyph = specificSpecialUcsur(END_OF_REVERSE_LONG_GLYPH)
   .with(longGlyphHead)
   .skip(specificSpecialUcsur(START_OF_LONG_GLYPH))
   .skip(spaces)
-  .map((words) => ({ type: "inside long glyph", words }) as const);
+  .map((words) => ({ type: "inside long glyph", words }) );
 const combinedGlyphsToken = combinedGlyphs
   .skip(spaces)
-  .map((words) => ({ type: "combined glyphs", words }) as const);
-const wordToken = word.map((word) => ({ type: "word", word }) as const);
+  .map((words) => ({ type: "combined glyphs", words }) );
+const wordToken = word.map((word) => ({ type: "word", word }) );
 
 export const token: Parser<Token> = choiceOnlyOne<Token>(
   xAlaX,

src/parser/parser.ts

@@ -129,11 +129,11 @@ const optionalEmphasis = optional(emphasis);
 const alaXLongGlyph = memoize((word: string) =>
   specificWord(word)
     .skip(specificToken("headless long glyph end"))
-    .map(() => ({ type: "x ala x", word }) as const)
+    .map(() => ({ type: "x ala x", word }))
 );
 const alaX = memoize((word: string) =>
   sequence(specificWord("ala"), specificWord(word))
-    .map(() => ({ type: "x ala x", word }) as const)
+    .map(() => ({ type: "x ala x", word }))
 );
 function xAlaX(useWord: Set<string>, description: string) {
   return choice(
@@ -145,20 +145,18 @@ function xAlaX(useWord: Set<string>, description: string) {
       )
       .then(alaXLongGlyph),
     specificToken("x ala x")
-      .map(({ word }) => ({ type: "x ala x", word }) as const),
+      .map(({ word }) => ({ type: "x ala x", word })),
     word
       .then(alaX),
   );
 }
 const reduplicateRest = memoize((word: string) =>
   count(manyAtLeastOnce(specificWord(word)))
-    .map((count) =>
-      ({
-        type: "reduplication",
-        word,
-        count: count + 1,
-      }) as const
-    )
+    .map((count) => ({
+      type: "reduplication",
+      word,
+      count: count + 1,
+    }))
 );
 function simpleWordUnit(word: Set<string>, description: string) {
   return choice<SimpleHeadedWordUnit>(
@@ -277,25 +275,23 @@ const modifiers = sequence(
   many(
     choice<Modifier>(
       sequence(number, optionalEmphasis)
-        .map(([words, emphasis]) =>
-          ({
-            type: "default",
-            word: { type: "number", words, emphasis },
-          }) as const
-        )
+        .map(([words, emphasis]) => ({
+          type: "default",
+          word: { type: "number", words, emphasis },
+        }))
         .filter(filter(MODIFIER_RULES)),
       wordUnit(contentWordSet, "modifier")
-        .map((word) => ({ type: "default", word }) as const)
+        .map((word) => ({ type: "default", word }))
         .filter(filter(MODIFIER_RULES)),
       properWords
-        .map((words) => ({ type: "proper words", words }) as const)
+        .map((words) => ({ type: "proper words", words }))
         .filter(filter(MODIFIER_RULES)),
     ),
   ),
-  many(nanpa.map((nanpa) => ({ ...nanpa, type: "nanpa" }) as const)),
+  many(nanpa.map((nanpa) => ({ ...nanpa, type: "nanpa" }))),
   many(
     pi
-      .map((phrase) => ({ type: "pi", phrase }) as const)
+      .map((phrase) => ({ type: "pi", phrase }))
       .filter(filter(MODIFIER_RULES)),
   ),
 )
@@ -307,7 +303,7 @@ const modifiers = sequence(
   ])
   .filter(filter(MULTIPLE_MODIFIERS_RULES));
 const singlePhrase = phrase
-  .map((phrase) => ({ type: "single", phrase }) as const);
+  .map((phrase) => ({ type: "single", phrase }));
 const longAnu = sequence(
   specificToken("headless long glyph start").with(phrase),
   manyAtLeastOnce(
@@ -466,14 +462,12 @@ function associatedPredicates(nestingRule: ReadonlyArray<"li" | "o" | "anu">) {
     ),
     many(optionalComma.with(preposition)),
   )
-    .map(([predicates, objects, prepositions]) =>
-      ({
-        type: "associated",
-        predicates,
-        objects,
-        prepositions,
-      }) as const
-    )
+    .map(([predicates, objects, prepositions]) => ({
+      type: "associated",
+      predicates,
+      objects,
+      prepositions,
+    }))
     .filter(({ objects, prepositions }) =>
       objects != null || prepositions.length > 0
     )
@@ -485,7 +479,7 @@ function multiplePredicates(
   if (nestingRule.length === 0) {
     return choice<Predicate>(
       associatedPredicates([]),
-      phrase.map((predicate) => ({ type: "single", predicate }) as const),
+      phrase.map((predicate) => ({ type: "single", predicate })),
     );
   } else {
     const [first, ...rest] = nestingRule;
@@ -684,7 +678,7 @@ const sentence = choice<Sentence>(
           )
         ? "seme"
         : null;
-      return { ...sentence, interrogative } as const;
+      return { ...sentence, interrogative };
     })
     .sortBy(({ anuSeme }) => anuSeme == null ? 1 : 0),
   sequence(filler, optional(punctuation))