recognize anu as sentence starting particle

Author: neverRare

src/parser/ast.ts

@@ -80,11 +80,12 @@ export type Clause =
   >;
 export type ContextClause =
   | Clause
-  | (Readonly<{ type: "nanpa" }> & Nanpa);
+  | (Readonly<{ type: "nanpa" }> & Nanpa)
+  | (Readonly<{ type: "anu"; anu: HeadedWordUnit }>);
 export type Sentence =
   | Readonly<{
     type: "default";
-    kinOrTaso: null | HeadedWordUnit;
+    startingParticle: null | HeadedWordUnit;
     laClauses: ReadonlyArray<ContextClause>;
     finalClause: Clause;
     anuSeme: null | HeadedWordUnit;

src/parser/composer.ts

@@ -176,6 +176,8 @@ export function contextClause(contextClause: ContextClause): string {
   switch (contextClause.type) {
     case "nanpa":
       return nanpa(contextClause);
+    case "anu":
+      return wordUnit(contextClause.anu);
     default:
       return clause(contextClause);
   }
@@ -185,7 +187,7 @@ export function sentence(sentence: Sentence): string {
   switch (sentence.type) {
     case "default":
       text = [
-        ...nullableAsArray(sentence.kinOrTaso).map(wordUnit),
+        ...nullableAsArray(sentence.startingParticle).map(wordUnit),
         ...sentence.laClauses
           .map(contextClause)
           .map((clause) => `${clause} la`),

src/parser/extract.ts

@@ -104,6 +104,8 @@ export function everyWordUnitInContextClause(
   switch (contextClause.type) {
     case "nanpa":
       return everyWordUnitInNanpa(contextClause);
+    case "anu":
+      return [contextClause.anu];
     default:
       return everyWordUnitInClause(contextClause);
   }
@@ -114,7 +116,7 @@ export function everyWordUnitInSentence(
   switch (sentence.type) {
     case "default":
       return [
-        ...nullableAsArray(sentence.kinOrTaso),
+        ...nullableAsArray(sentence.startingParticle),
         ...sentence.laClauses.flatMap(everyWordUnitInContextClause),
         ...everyWordUnitInClause(sentence.finalClause),
         ...nullableAsArray(sentence.anuSeme),

src/parser/filter.ts

@@ -301,20 +301,21 @@ export const SENTENCE_RULE: ReadonlyArray<(sentence: Sentence) => boolean> = [
   (sentence) => {
     if (sentence.type === "default") {
       if (
-        sentence.kinOrTaso != null && sentence.kinOrTaso.type === "x ala x"
+        sentence.startingParticle != null &&
+        sentence.startingParticle.type === "x ala x"
       ) {
-        const { kinOrTaso: { word } } = sentence;
+        const { startingParticle: { word } } = sentence;
         throw new UnrecognizedError(`"${word} ala ${word}"`);
       }
     }
     return true;
   },
-  // If there is "la", there can't be "taso" or "kin"
+  // If there is "la", there can't be starting particle e.g. taso
   (sentence) =>
     sentence.type !== "default" || sentence.laClauses.length === 0 ||
-    sentence.kinOrTaso == null || throwError(
+    sentence.startingParticle == null || throwError(
       new UnrecognizedError(
-        `${sentence.kinOrTaso.word} particle with "la"`,
+        `${sentence.startingParticle.word} particle with "la"`,
       ),
     ),
 

src/parser/parser.ts

@@ -605,6 +605,7 @@ const clause = choice<Clause>(
   .filter(filter(CLAUSE_RULE));
 const contextClause = choice<ContextClause>(
   nanpa.map((nanpa) => ({ ...nanpa, type: "nanpa" })),
+  wordUnit(new Set(["anu"]), '"anu"').map((anu) => ({ type: "anu", anu })),
   clause,
 );
 const la = choice(
@@ -652,7 +653,8 @@ const anuSeme = choice(
 const sentence = choice<Sentence>(
   sequence(
     optional(
-      wordUnit(new Set(["kin", "taso"]), "taso/kin").skip(optionalComma),
+      wordUnit(new Set(["taso", "kin", "anu"]), "taso/kin/anu")
+        .skip(optionalComma),
     ),
     many(contextClause.skip(la)),
     clause,
@@ -668,7 +670,7 @@ const sentence = choice<Sentence>(
     .map<Sentence & { type: "default" }>(
       (
         [
-          kinOrTaso,
+          startingParticle,
           laClauses,
           finalClause,
           anuSeme,
@@ -678,7 +680,7 @@ const sentence = choice<Sentence>(
       ) => {
         const sentence: Sentence & { type: "default" } = {
           type: "default",
-          kinOrTaso,
+          startingParticle,
           laClauses,
           finalClause,
           anuSeme,

src/translator/clause.ts

@@ -209,7 +209,10 @@ export function contextClause(
 ): ArrayResult<English.Clause> {
   switch (contextClause.type) {
     case "nanpa":
-      return new ArrayResult(new TranslationTodoError("nanpa context clause"));
+    case "anu":
+      return new ArrayResult(
+        new TranslationTodoError(`${contextClause.type} context clause`),
+      );
     default:
       return clause(contextClause);
   }

src/translator/sentence.ts

@@ -144,18 +144,18 @@ function sentence(
             clause,
           }))
         );
-      if (sentence.kinOrTaso != null) {
+      if (sentence.startingParticle != null) {
         return new ArrayResult(
           new TranslationTodoError(
-            `"${sentence.kinOrTaso.word}" starting particle`,
+            `"${sentence.startingParticle.word}" starting particle`,
           ),
         );
       }
       const lastEngClause = clause(sentence.finalClause);
       const right = nullableAsArray(sentence.anuSeme).map(anuSeme);
       const interjectionClause =
-        sentence.laClauses.length === 0 && sentence.kinOrTaso == null &&
-          sentence.kinOrTaso == null
+        sentence.laClauses.length === 0 && sentence.startingParticle == null &&
+          sentence.startingParticle == null
           ? interjection(sentence.finalClause)
           : new ArrayResult<English.Clause>();
       const engClauses = ArrayResult.combine(