implemet separate fixer

Author: neverRare

src/translator/adjective.ts

@@ -82,35 +82,6 @@ export function compoundAdjective(
     ]);
   }
 }
-function rankAdjective(kind: Dictionary.AdjectiveType) {
-  return [
-    "opinion",
-    "size",
-    "physical quality",
-    "age",
-    "color",
-    "origin",
-    "material",
-    "qualifier",
-  ]
-    .indexOf(kind);
-}
-export function fixAdjective(
-  adjective: ReadonlyArray<English.AdjectivePhrase>,
-): ReadonlyArray<English.AdjectivePhrase> {
-  return adjective
-    .flatMap((adjective) => {
-      switch (adjective.type) {
-        case "simple":
-          return [adjective];
-        case "compound":
-          return adjective.adjective as ReadonlyArray<
-            English.AdjectivePhrase & { type: "simple" }
-          >;
-      }
-    })
-    .sort((a, b) => rankAdjective(a.kind) - rankAdjective(b.kind));
-}
 export function extractNegativeFromAdjective(
   adjective: English.AdjectivePhrase,
 ): null | English.AdjectivePhrase {

src/translator/adverb.ts

@@ -1,18 +1,8 @@
 import * as English from "./ast.ts";
-import { FilteredError } from "./error.ts";
 import { noEmphasis } from "./word.ts";
 
 export const NOT = { adverb: noEmphasis("not"), negative: true };
 
-export function fixAdverb(
-  adverb: ReadonlyArray<English.Adverb>,
-): ReadonlyArray<English.Adverb> {
-  if (adverb.length > 1) {
-    throw new FilteredError("multiple adverbs");
-  } else {
-    return adverb;
-  }
-}
 export function extractNegativeFromAdverbs(
   adverb: ReadonlyArray<English.Adverb>,
 ): null | ReadonlyArray<English.Adverb> {

src/translator/ast.ts

@@ -1,5 +1,7 @@
 import * as Dictionary from "../../dictionary/type.ts";
 
+// When editing, update `./fixer.ts` as well
+
 export type Word = Readonly<{
   word: string;
   emphasis: boolean;

src/translator/determiner.ts

@@ -6,12 +6,6 @@ import { FilteredError } from "./error.ts";
 import { simpleNounForms } from "./noun.ts";
 import { word } from "./word.ts";
 
-function filterKind(
-  determiners: ReadonlyArray<English.Determiner>,
-  kinds: ReadonlyArray<Dictionary.DeterminerType>,
-) {
-  return determiners.filter(({ kind }) => kinds.includes(kind));
-}
 function filterQuantity(
   determiners: ReadonlyArray<English.Determiner>,
   targetQuantity: Dictionary.Quantity,
@@ -61,78 +55,6 @@ export function determiner(
       determiner: word({ ...options, word: determiner }),
     }));
 }
-export function fixDeterminer(
-  determiner: ReadonlyArray<English.Determiner>,
-): ReadonlyArray<English.Determiner> {
-  const negative = filterKind(determiner, ["negative"]);
-  const first = filterKind(determiner, [
-    "article",
-    "demonstrative",
-    "possessive",
-  ]);
-  const article = filterKind(determiner, ["article"]);
-  const demonstrative = filterKind(determiner, ["demonstrative"]);
-  const possessive = filterKind(determiner, ["possessive"]);
-  const distributive = filterKind(determiner, ["distributive"]);
-  const interrogative = filterKind(determiner, ["interrogative"]);
-  const quantitative = filterKind(determiner, ["numeral", "quantifier"]);
-  const errors = filterSet([
-    [
-      negative.length > 1,
-      encodeDeterminer`multiple negative determiners ${negative}`,
-    ],
-    [article.length > 1, encodeDeterminer`multiple articles ${article}`],
-    [
-      demonstrative.length > 1,
-      encodeDeterminer`multiple demonstrative determiners ${demonstrative}`,
-    ],
-    [
-      possessive.length > 1,
-      encodeDeterminer`multiple possessive determiners ${possessive}`,
-    ],
-    [
-      distributive.length > 1,
-      encodeDeterminer`multiple distributive determiners ${distributive}`,
-    ],
-    [
-      interrogative.length > 1,
-      encodeDeterminer`multiple interrogative determiners ${interrogative}`,
-    ],
-    [
-      quantitative.length > 1,
-      encodeDeterminer`multiple quantitative determiners ${quantitative}`,
-    ],
-    [
-      article.length > 0 && demonstrative.length > 0,
-      encodeDeterminer`article ${article} with demonstrative determiner ${demonstrative}`,
-    ],
-    [
-      article.length > 0 && possessive.length > 0,
-      encodeDeterminer`article ${article} with possessive determiner ${possessive}`,
-    ],
-    [
-      demonstrative.length > 0 && possessive.length > 0,
-      encodeDeterminer`demonstrative determiner ${demonstrative} with possessive determiner ${possessive}`,
-    ],
-    [
-      negative.length > 0 && interrogative.length > 0,
-      encodeDeterminer`negative determiner ${negative} with interrogative determiner ${interrogative}`,
-    ],
-  ]);
-  if (errors.length === 0) {
-    return [
-      ...negative,
-      ...first,
-      ...distributive,
-      ...interrogative,
-      ...quantitative,
-    ];
-  } else {
-    throw new AggregateError(
-      errors.map((element) => new FilteredError(element())),
-    );
-  }
-}
 export function extractNegativeFromDeterminers(
   determiner: ReadonlyArray<English.Determiner>,
 ): null | ReadonlyArray<English.Determiner> {
@@ -145,10 +67,10 @@ export function extractNegativeFromDeterminers(
     return spliced;
   }
 }
-function encodeDeterminer(
+export function encodeDeterminer(
   strings: TemplateStringsArray,
   ...determiners: ReadonlyArray<ReadonlyArray<English.Determiner>>
-) {
+): () => string {
   return () =>
     zip(strings, [
       ...determiners
@@ -160,8 +82,3 @@ function encodeDeterminer(
       .flat()
       .join("");
 }
-function filterSet<const T>(
-  set: ReadonlyArray<readonly [condition: boolean, value: T]>,
-) {
-  return set.filter(([condition]) => condition).map(([_, value]) => value);
-}