this is better encoded directly on the syntax tree

Author: neverRare

src/parser/ast.ts

@@ -41,10 +41,10 @@ export type Phrase =
 export type MultiplePhrases =
   | Readonly<{ type: "simple"; phrase: Phrase }>
   | Readonly<{
-    type: "and";
+    type: "and" | "anu";
+    particle: string;
     phrases: ReadonlyArray<MultiplePhrases>;
-  }>
-  | Readonly<{ type: "anu"; phrases: ReadonlyArray<MultiplePhrases> }>;
+  }>;
 export type Preposition = Readonly<{
   preposition: HeadedWordUnit;
   modifiers: ReadonlyArray<Modifier>;
@@ -59,8 +59,11 @@ export type Predicate =
     objects: null | MultiplePhrases;
     prepositions: ReadonlyArray<Preposition>;
   }>
-  | Readonly<{ type: "and"; predicates: ReadonlyArray<Predicate> }>
-  | Readonly<{ type: "anu"; predicates: ReadonlyArray<Predicate> }>;
+  | Readonly<{
+    type: "and" | "anu";
+    particle: string;
+    predicates: ReadonlyArray<Predicate>;
+  }>;
 export type Clause =
   | Readonly<{ type: "phrases"; phrases: MultiplePhrases }>
   | Readonly<{ type: "o vocative"; phrases: MultiplePhrases }>

src/parser/composer.ts

@@ -90,82 +90,71 @@ export function phrase(value: Phrase): string {
       return preposition(value);
   }
 }
-function particle(type: "and" | "anu", particle: string) {
-  if (type === "and") {
-    return particle;
-  } else {
-    return "anu;";
-  }
-}
-export function multiplePhrases(
-  phrases: MultiplePhrases,
-  andParticle: string,
-): string {
+export function multiplePhrases(phrases: MultiplePhrases): string {
   switch (phrases.type) {
     case "simple":
       return phrase(phrases.phrase);
     case "and":
     case "anu": {
       return phrases.phrases
-        .map((phrases) => multiplePhrases(phrases, andParticle))
-        .join(` ${particle(phrases.type, andParticle)} `);
+        .map((phrases) => multiplePhrases(phrases))
+        .join(` ${phrases.particle} `);
     }
   }
 }
 export function preposition(preposition: Preposition): string {
   return [
     wordUnit(preposition.preposition),
     ...preposition.modifiers.map(modifier),
-    multiplePhrases(preposition.phrases, ""),
+    multiplePhrases(preposition.phrases),
     ...emphasisAsArray(preposition.emphasis),
   ]
     .join(" ");
 }
 export function multiplePredicates(
   predicates: Predicate,
-  andParticle: string,
 ): string {
   switch (predicates.type) {
     case "simple":
       return phrase(predicates.predicate);
     case "associated": {
       return [
-        multiplePhrases(predicates.predicates, andParticle),
+        multiplePhrases(predicates.predicates),
         ...nullableAsArray(predicates.objects).map(() => "e"),
         ...nullableAsArray(predicates.objects)
-          .map((objects) => multiplePhrases(objects, "e")),
+          .map((objects) => multiplePhrases(objects)),
         ...predicates.prepositions.map(preposition),
       ]
         .join(" ");
     }
     case "and":
     case "anu":
       return predicates.predicates
-        .map((predicates) => multiplePredicates(predicates, andParticle))
-        .join(` ${particle(predicates.type, andParticle)} `);
+        .map((predicates) => multiplePredicates(predicates))
+        .join(` ${predicates.particle} `);
   }
 }
 export function clause(clause: Clause): string {
   switch (clause.type) {
     case "phrases":
-      return multiplePhrases(clause.phrases, "en");
+      return multiplePhrases(clause.phrases);
     case "o vocative":
-      return `${multiplePhrases(clause.phrases, "en")} o`;
+      return `${multiplePhrases(clause.phrases)} o`;
     case "li clause": {
       const li = clause.explicitLi ? ["li"] : [];
       return [
-        multiplePhrases(clause.subjects, "en"),
+        multiplePhrases(clause.subjects),
         ...li,
-        multiplePredicates(clause.predicates, "li"),
+        multiplePredicates(clause.predicates),
       ]
         .join(" ");
     }
     case "o clause":
       return [
         ...nullableAsArray(clause.subjects)
-          .map((subjects) => multiplePhrases(subjects, "en")),
+          .map((subjects) => multiplePhrases(subjects)),
         "o",
-        multiplePredicates(clause.predicates, "o"),
+        multiplePredicates(clause.predicates),
       ]
         .join(" ");
   }

src/parser/parser.ts

@@ -324,6 +324,7 @@ function nestedPhrasesOnly(
     const longAnuParser = type === "anu"
       ? longAnu.map((phrases): MultiplePhrases => ({
         type: "anu",
+        particle: "anu",
         phrases: phrases.map((phrase): MultiplePhrases => ({
           type: "simple",
           phrase,
@@ -342,6 +343,7 @@ function nestedPhrasesOnly(
       )
         .map(([group, moreGroups]): MultiplePhrases => ({
           type,
+          particle: first,
           phrases: [group, ...moreGroups],
         })),
     );
@@ -494,6 +496,7 @@ function multiplePredicates(
     const longAnuParser: Parser<Predicate> = type === "anu"
       ? longAnu.map((phrases): Predicate => ({
         type: "anu",
+        particle: "anu",
         predicates: phrases.map((predicate): Predicate => ({
           type: "simple",
           predicate,
@@ -521,6 +524,7 @@ function multiplePredicates(
       )
         .map(([group, moreGroups]): Predicate => ({
           type,
+          particle: first,
           predicates: [group, ...moreGroups],
         })),
       multiplePredicates(rest),

src/translator/phrase.ts

@@ -487,7 +487,7 @@ export function multiplePhrases(
           }
         })
         .addErrorWhenNone(() =>
-          new ExhaustedError(Composer.multiplePhrases(phrases, andParticle))
+          new ExhaustedError(Composer.multiplePhrases(phrases))
         );
     }
   }

src/translator2/phrase.ts

@@ -454,7 +454,7 @@ export function multiplePhrases(
           }
         })
         .addErrorWhenNone(() =>
-          new ExhaustedError(Composer.multiplePhrases(phrases, "(and)"))
+          new ExhaustedError(Composer.multiplePhrases(phrases))
         );
     }
   }