implement pi, nanpa, and preposition

Author: neverRare

src/translator2/modifier.ts

@@ -10,6 +10,8 @@ import { pronoun } from "./pronoun.ts";
 import { adjective, compoundAdjective } from "./adjective.ts";
 import * as Composer from "../parser/composer.ts";
 import { word } from "./word.ts";
+import { phrase, PhraseTranslation } from "./phrase.ts";
+import { nanpa } from "./nanpa.ts";
 
 export type ModifierTranslation =
   | Readonly<{ type: "noun"; noun: English.NounPhrase }>
@@ -143,6 +145,20 @@ function defaultModifier(wordUnit: TokiPona.WordUnit) {
     }
   }
 }
+function pi(
+  insidePhrase: TokiPona.Phrase,
+): IterableResult<ModifierTranslation> {
+  return phrase({
+    phrase: insidePhrase,
+    includeGerund: true,
+  })
+    .filter((modifier) =>
+      modifier.type !== "verb" &&
+      (modifier.type !== "adjective" || modifier.inWayPhrase == null)
+    ) as IterableResult<
+      PhraseTranslation & { type: Exclude<PhraseTranslation["type"], "verb"> }
+    >;
+}
 function modifier(modifier: TokiPona.Modifier) {
   switch (modifier.type) {
     case "simple":
@@ -153,8 +169,13 @@ function modifier(modifier: TokiPona.Modifier) {
         name: modifier.words,
       });
     case "pi":
+      return pi(modifier.phrase);
     case "nanpa":
-      return IterableResult.errors([new TranslationTodoError(modifier.type)]);
+      return nanpa(modifier)
+        .map((noun): ModifierTranslation => ({
+          type: "noun",
+          noun: { ...noun, type: "simple" },
+        }));
   }
 }
 export function multipleModifiers(

src/translator2/nanpa.ts

@@ -0,0 +1,36 @@
+import * as TokiPona from "../parser/ast.ts";
+import { IterableResult } from "../compound.ts";
+import * as English from "./ast.ts";
+import { phrase } from "./phrase.ts";
+import { throwError } from "../../misc/misc.ts";
+import { FilteredError } from "./error.ts";
+
+export function nanpa(
+  nanpa: TokiPona.Nanpa,
+): IterableResult<English.SimpleNounPhrase> {
+  return phrase({
+    phrase: nanpa.phrase,
+    includeGerund: true,
+  })
+    .map((phrase): English.SimpleNounPhrase =>
+      phrase.type !== "noun"
+        ? throwError(
+          new FilteredError(
+            `${phrase.type} within "position X" phrase`,
+          ),
+        )
+        : {
+          determiners: [],
+          adjectives: [],
+          singular: { subject: "position", object: "position" },
+          plural: null,
+          reduplicationCount: 1,
+          wordEmphasis: false,
+          perspective: "third",
+          postCompound: phrase.noun,
+          adjectiveName: null,
+          prepositions: [],
+          phraseEmphasis: false,
+        }
+    );
+}

src/translator2/phrase.ts

@@ -1,11 +1,7 @@
 import * as English from "./ast.ts";
 import { AdjectiveWithInWay } from "./adjective.ts";
 import { AdjectivalModifier } from "./modifier.ts";
-import {
-  ExhaustedError,
-  FilteredError,
-  TranslationTodoError,
-} from "./error.ts";
+import { ExhaustedError, FilteredError } from "./error.ts";
 import { mapNullable, nullableAsArray } from "../../misc/misc.ts";
 import { nounAsPreposition } from "./preposition.ts";
 import { AdverbialModifier } from "./modifier.ts";
@@ -15,6 +11,7 @@ import { wordUnit } from "./word_unit.ts";
 import { multipleModifiers } from "./modifier.ts";
 import * as Composer from "../parser/composer.ts";
 import { CONJUNCTION } from "./misc.ts";
+import { preposition } from "./preposition.ts";
 
 export type PhraseTranslation =
   | Readonly<{ type: "noun"; noun: English.NounPhrase }>
@@ -297,7 +294,12 @@ export function phrase(
     case "simple":
       return defaultPhrase({ ...options, phrase });
     case "preposition":
-      return IterableResult.errors([new TranslationTodoError("preposition")]);
+      return preposition(phrase)
+        .map(prepositionAsVerb)
+        .map((verb): PhraseTranslation => ({
+          type: "verb",
+          verb: { ...verb, type: "simple" },
+        }));
     case "preverb":
       return preverb(phrase)
         .map((verb): PhraseTranslation => ({

src/translator2/preposition.ts

@@ -1,6 +1,72 @@
 import * as English from "./ast.ts";
-import { noEmphasis } from "./word.ts";
+import { noEmphasis, word } from "./word.ts";
+import * as TokiPona from "../parser/ast.ts";
+import { IterableResult } from "../compound.ts";
+import { multipleModifiers } from "./modifier.ts";
+import { throwError } from "../../misc/misc.ts";
+import { FilteredError, TranslationTodoError } from "./error.ts";
+import { multiplePhrases } from "./phrase.ts";
+import { dictionary } from "../dictionary.ts";
+import { getReduplicationCount } from "./word_unit.ts";
 
+export function preposition(
+  preposition: TokiPona.Preposition,
+): IterableResult<English.Preposition> {
+  return IterableResult.combine(
+    prepositionAsWord(preposition.preposition),
+    multipleModifiers(preposition.modifiers)
+      .map((modifier) =>
+        modifier.type === "adverbial"
+          ? (modifier.inWayPhrase == null ? modifier.adverbs : throwError(
+            new FilteredError(
+              '"in [adjective] way" prepositional phrase modifying ' +
+                "preposition",
+            ),
+          ))
+          : throwError(new FilteredError("adjectives modifying preposition"))
+      ),
+    multiplePhrases({
+      phrases: preposition.phrases,
+      includeGerund: true,
+      andParticle: null,
+    })
+      .map((phrases) =>
+        phrases.type === "noun"
+          ? phrases.noun
+          : throwError(new FilteredError(`${phrases.type} as indirect object`))
+      ),
+  )
+    .map(([preposition, adverbs, object]): English.Preposition => ({
+      adverbs,
+      preposition,
+      object,
+      emphasis: preposition.emphasis,
+    }));
+}
+function prepositionAsWord(
+  preposition: TokiPona.HeadedWordUnit,
+): IterableResult<English.Word> {
+  switch (preposition.type) {
+    case "x ala x":
+      return IterableResult.errors([
+        new TranslationTodoError("preposition ala preposition"),
+      ]);
+    case "simple":
+    case "reduplication":
+      return IterableResult.fromArray(
+        dictionary.get(preposition.word)!.definitions,
+      )
+        .filterMap((definition) =>
+          definition.type === "preposition"
+            ? word({
+              word: definition.preposition,
+              reduplicationCount: getReduplicationCount(preposition),
+              emphasis: preposition.emphasis != null,
+            })
+            : null
+        );
+  }
+}
 export function nounAsPreposition(
   phrase: English.NounPhrase,
   preposition: string,