refactor

Author: neverRare

src/parser/ast.ts

@@ -3,7 +3,7 @@ export type Emphasis =
   | Readonly<{ type: "long word"; word: string; length: number }>;
 export type Filler =
   | Emphasis
-  | Readonly<{ type: "multiple a"; count: number }>;
+  | Readonly<{ type: "reduplicated a"; count: number }>;
 export type SimpleHeadedWordUnit =
   | Readonly<{ type: "simple"; word: string }>
   | Readonly<{ type: "x ala x"; word: string }>
@@ -20,7 +20,7 @@ export type WordUnit =
 export type Nanpa = Readonly<{ nanpa: WordUnit; phrase: Phrase }>;
 export type Modifier =
   | Readonly<{ type: "simple"; word: WordUnit }>
-  | Readonly<{ type: "proper words"; words: string }>
+  | Readonly<{ type: "name"; words: string }>
   | Readonly<{ type: "pi"; phrase: Phrase }>
   | (Readonly<{ type: "nanpa" }> & Nanpa);
 export type Phrase =
@@ -39,27 +39,27 @@ export type Phrase =
   }>
   | (Readonly<{ type: "preposition" }> & Preposition);
 export type MultiplePhrases =
-  | Readonly<{ type: "single"; phrase: Phrase }>
+  | Readonly<{ type: "simple"; phrase: Phrase }>
   | Readonly<{
-    type: "and conjunction";
+    type: "and";
     phrases: ReadonlyArray<MultiplePhrases>;
   }>
   | Readonly<{ type: "anu"; phrases: ReadonlyArray<MultiplePhrases> }>;
 export type Preposition = Readonly<{
   preposition: HeadedWordUnit;
   modifiers: ReadonlyArray<Modifier>;
-  phrases: Readonly<{ type: "single" | "anu" }> & MultiplePhrases;
+  phrases: Readonly<{ type: "simple" | "anu" }> & MultiplePhrases;
   emphasis: null | Emphasis;
 }>;
 export type Predicate =
-  | Readonly<{ type: "single"; predicate: Phrase }>
+  | Readonly<{ type: "simple"; predicate: Phrase }>
   | Readonly<{
     type: "associated";
     predicates: MultiplePhrases;
     objects: null | MultiplePhrases;
     prepositions: ReadonlyArray<Preposition>;
   }>
-  | Readonly<{ type: "and conjunction"; predicates: ReadonlyArray<Predicate> }>
+  | Readonly<{ type: "and"; predicates: ReadonlyArray<Predicate> }>
   | Readonly<{ type: "anu"; predicates: ReadonlyArray<Predicate> }>;
 export type Clause =
   | Readonly<{ type: "phrases"; phrases: MultiplePhrases }>

src/parser/composer.ts

@@ -26,7 +26,7 @@ export function emphasis(emphasis: Emphasis): string {
 }
 export function filler(filler: Filler): string {
   switch (filler.type) {
-    case "multiple a":
+    case "reduplicated a":
       return repeatWithSpace("a", filler.count);
     default:
       return emphasis(filler);
@@ -61,7 +61,7 @@ export function modifier(modifier: Modifier): string {
   switch (modifier.type) {
     case "simple":
       return wordUnit(modifier.word);
-    case "proper words":
+    case "name":
       return modifier.words;
     case "pi":
       return `pi ${phrase(modifier.phrase)}`;
@@ -90,8 +90,8 @@ export function phrase(value: Phrase): string {
       return preposition(value);
   }
 }
-function particle(type: "and conjunction" | "anu", particle: null | string) {
-  if (type === "and conjunction") {
+function particle(type: "and" | "anu", particle: null | string) {
+  if (type === "and") {
     return particle!;
   } else {
     return "anu;";
@@ -102,9 +102,9 @@ export function multiplePhrases(
   andParticle: null | string,
 ): string {
   switch (phrases.type) {
-    case "single":
+    case "simple":
       return phrase(phrases.phrase);
-    case "and conjunction":
+    case "and":
     case "anu": {
       return phrases.phrases
         .map((phrases) => multiplePhrases(phrases, andParticle))
@@ -126,7 +126,7 @@ export function multiplePredicates(
   andParticle: string,
 ): string {
   switch (predicates.type) {
-    case "single":
+    case "simple":
       return phrase(predicates.predicate);
     case "associated": {
       return [
@@ -138,7 +138,7 @@ export function multiplePredicates(
       ]
         .join(" ");
     }
-    case "and conjunction":
+    case "and":
     case "anu":
       return predicates.predicates
         .map((predicates) => multiplePredicates(predicates, andParticle))

src/parser/extract.ts

@@ -25,7 +25,7 @@ export function everyWordUnitInModifier(
       return everyWordUnitInPhrase(modifier.phrase);
     case "nanpa":
       return everyWordUnitInNanpa(modifier);
-    case "proper words":
+    case "name":
       return [];
   }
 }
@@ -64,7 +64,7 @@ export function everyWordUnitInMultiplePredicates(
   predicate: Predicate,
 ): ReadonlyArray<WordUnit> {
   switch (predicate.type) {
-    case "single":
+    case "simple":
       return everyWordUnitInPhrase(predicate.predicate);
     case "associated":
       return [
@@ -73,7 +73,7 @@ export function everyWordUnitInMultiplePredicates(
           .flatMap(everyWordUnitInMultiplePhrases),
         ...predicate.prepositions.flatMap(everyWordUnitInPreposition),
       ];
-    case "and conjunction":
+    case "and":
     case "anu":
       return predicate.predicates.flatMap(everyWordUnitInMultiplePredicates);
   }
@@ -150,9 +150,9 @@ export function everyPhraseInMultiplePhrases(
   phrases: MultiplePhrases,
 ): ReadonlyArray<Phrase> {
   switch (phrases.type) {
-    case "single":
+    case "simple":
       return [phrases.phrase];
-    case "and conjunction":
+    case "and":
     case "anu":
       return phrases.phrases.flatMap(everyPhraseInMultiplePhrases);
   }
@@ -161,12 +161,12 @@ export function everyObjectInMultiplePredicates(
   predicates: Predicate,
 ): ReadonlyArray<Phrase> {
   switch (predicates.type) {
-    case "single":
+    case "simple":
       return [];
     case "associated":
       return nullableAsArray(predicates.objects)
         .flatMap(everyPhraseInMultiplePhrases);
-    case "and conjunction":
+    case "and":
     case "anu":
       return predicates.predicates.flatMap(everyObjectInMultiplePredicates);
   }

src/parser/filter.ts

@@ -79,7 +79,7 @@ export const MODIFIER_RULES: ReadonlyArray<(modifier: Modifier) => boolean> = [
   //   const checker = (modifier: Modifier) => {
   //     switch (modifier.type) {
   //       case "simple":
-  //       case "proper words":
+  //       case "name":
   //       case "nanpa":
   //         return everyModifierInPhrase(modifier.phrase).some(checker);
   //       case "pi":
@@ -113,7 +113,7 @@ export const MULTIPLE_MODIFIERS_RULES: ReadonlyArray<
   // disallow multiple proper words
   (modifiers) =>
     modifiers
-        .filter(({ type }) => type === "proper words")
+        .filter(({ type }) => type === "name")
         .length <= 1 ||
     throwError(new UnrecognizedError("multiple proper words")),
 
@@ -144,7 +144,7 @@ export const MULTIPLE_MODIFIERS_RULES: ReadonlyArray<
             } else {
               return [];
             }
-          case "proper words":
+          case "name":
           case "nanpa":
             return [];
         }
@@ -221,7 +221,7 @@ export const PREPOSITION_RULES: ReadonlyArray<
 
   // inner phrase must not have emphasis particle
   (preposition) =>
-    preposition.phrases.type !== "single" ||
+    preposition.phrases.type !== "simple" ||
     !phraseHasTopLevelEmphasis(preposition.phrases.phrase),
 
   // emphasis must not be nested
@@ -290,7 +290,7 @@ export const CLAUSE_RULES: ReadonlyArray<(clause: Clause) => boolean> = [
     if (
       clause.type === "li clause" &&
       clause.explicitLi &&
-      clause.subjects.type === "single"
+      clause.subjects.type === "simple"
     ) {
       const { subjects: { phrase } } = clause;
       if (

src/parser/lexer.ts

@@ -63,10 +63,10 @@ const combinedGlyphs = sequence(ucsur, allAtLeastOnce(joiner.with(ucsur)))
   .map(([first, rest]) => [first, ...rest]);
 const word = choiceOnlyOne(latinWord, singleUcsurWord);
 const properWords = allAtLeastOnce(
-  match(/[A-Z][a-zA-Z]*/, "proper word").skip(spaces),
+  match(/[A-Z][a-zA-Z]*/, "name").skip(spaces),
 )
   .map((array) => array.join(" "))
-  .map((words): Token => ({ type: "proper word", words, kind: "latin" }));
+  .map((words): Token => ({ type: "name", 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): Token => ({ type: "multiple a", count: count + 1 }));
+  .map((count): Token => ({ type: "reduplicated a", count: count + 1 }));
 const repeatingLetter = match(/[a-zA-Z]/, "latin letter")
   .then(memoize((letter) =>
     count(all(matchString(letter)))
@@ -142,7 +142,7 @@ const cartouche = specificSpecialUcsur(START_OF_CARTOUCHE)
 const cartouches = allAtLeastOnce(cartouche)
   .map((words) => words.join(" "))
   .map((words): Token => ({
-    type: "proper word",
+    type: "name",
     words,
     kind: "cartouche",
   }));

src/parser/parser.ts

@@ -82,7 +82,7 @@ const comma = punctuation
   );
 const optionalComma = optional(comma);
 const word = specificToken("word").map(({ word }) => word);
-const properWords = specificToken("proper word").map(({ words }) => words);
+const properWords = specificToken("name").map(({ words }) => words);
 
 function wordFrom(set: Set<string>, description: string) {
   return word.filter((word) =>
@@ -286,7 +286,7 @@ const modifiers = sequence(
         .map((word): Modifier => ({ type: "simple", word }))
         .filter(filter(MODIFIER_RULES)),
       properWords
-        .map((words): Modifier => ({ type: "proper words", words }))
+        .map((words): Modifier => ({ type: "name", words }))
         .filter(filter(MODIFIER_RULES)),
     ),
   ),
@@ -305,7 +305,7 @@ const modifiers = sequence(
   ])
   .filter(filter(MULTIPLE_MODIFIERS_RULES));
 const singlePhrase = phrase
-  .map((phrase): MultiplePhrases => ({ type: "single", phrase }));
+  .map((phrase): MultiplePhrases => ({ type: "simple", phrase }));
 const longAnu = sequence(
   specificToken("headless long glyph start").with(phrase),
   manyAtLeastOnce(
@@ -324,12 +324,12 @@ function nestedPhrasesOnly(
     return singlePhrase;
   } else {
     const [first, ...rest] = nestingRule;
-    const type = first === "anu" ? "anu" : "and conjunction";
+    const type = first === "anu" ? "anu" : "and";
     const longAnuParser = type === "anu"
       ? longAnu.map((phrases): MultiplePhrases => ({
         type: "anu",
         phrases: phrases.map((phrase): MultiplePhrases => ({
-          type: "single",
+          type: "simple",
           phrase,
         })),
       }))
@@ -379,7 +379,7 @@ const preposition = choice(
         emphasis: null,
       },
       modifiers: [],
-      phrases: { type: "single", phrase },
+      phrases: { type: "simple", phrase },
       emphasis: null,
     })),
   sequence(
@@ -411,7 +411,7 @@ const preposition = choice(
       return {
         preposition: { type: "simple", word: words[0], emphasis: null },
         modifiers,
-        phrases: { type: "single", phrase },
+        phrases: { type: "simple", phrase },
         emphasis: null,
       };
     }),
@@ -424,7 +424,7 @@ const preposition = choice(
       },
       modifiers: [],
       phrases: {
-        type: "single",
+        type: "simple",
         phrase: {
           type: "simple",
           headWord: {
@@ -442,7 +442,7 @@ const preposition = choice(
     optionalCombined(prepositionSet, "preposition"),
     modifiers,
     nestedPhrases(["anu"]) as Parser<
-      MultiplePhrases & { type: "single" | "anu" }
+      MultiplePhrases & { type: "simple" | "anu" }
     >,
     optionalEmphasis,
   )
@@ -490,16 +490,16 @@ function multiplePredicates(
   if (nestingRule.length === 0) {
     return choice(
       associatedPredicates([]),
-      phrase.map((predicate): Predicate => ({ type: "single", predicate })),
+      phrase.map((predicate): Predicate => ({ type: "simple", predicate })),
     );
   } else {
     const [first, ...rest] = nestingRule;
-    const type = first === "anu" ? "anu" : "and conjunction";
+    const type = first === "anu" ? "anu" : "and";
     const longAnuParser: Parser<Predicate> = type === "anu"
       ? longAnu.map((phrases): Predicate => ({
         type: "anu",
         predicates: phrases.map((predicate): Predicate => ({
-          type: "single",
+          type: "simple",
           predicate,
         })),
       }))
@@ -541,7 +541,7 @@ const clause = choice(
     .map(([subject, predicates]): Clause => ({
       type: "li clause",
       subjects: {
-        type: "single",
+        type: "simple",
         phrase: {
           type: "simple",
           headWord: {
@@ -631,8 +631,8 @@ const filler = choice(
           ),
         )
     ),
-  specificToken("multiple a")
-    .map(({ count }): Filler => ({ type: "multiple a", count })),
+  specificToken("reduplicated a")
+    .map(({ count }): Filler => ({ type: "reduplicated a", count })),
   specificToken("long word")
     .map(({ word, length }): Filler =>
       fillerSet.has(word)

src/parser/token.ts

@@ -29,11 +29,11 @@ export type Token =
     type: "inside long glyph";
     words: ReadonlyArray<string>;
   }>
-  | Readonly<{ type: "multiple a"; count: number }>
+  | Readonly<{ type: "reduplicated a"; count: number }>
   | Readonly<{ type: "long word"; word: string; length: number }>
   | Readonly<{ type: "x ala x"; word: string }>
   | Readonly<{
-    type: "proper word";
+    type: "name";
     words: string;
     kind: "cartouche" | "latin";
   }>
@@ -53,15 +53,15 @@ export function describe(token: Token): string {
     case "headed long glyph end":
     case "inside long glyph":
       return "end of long glyph";
-    case "multiple a":
+    case "reduplicated a":
       return `"${repeatWithSpace("a", token.count)}"`;
     case "long word":
       return `"${token.word.repeat(token.length)}"`;
     case "x ala x":
       return `"${token.word} ala ${token.word}"`;
     case "punctuation":
       return `punctuation mark "${token.punctuation}"`;
-    case "proper word":
+    case "name":
       switch (token.kind) {
         case "cartouche":
           return "cartouche";