implement preposition

Author: neverRare

src/parser/composer.ts

@@ -90,16 +90,19 @@ export function phrase(value: Phrase): string {
       return preposition(value);
   }
 }
-function particle(type: "and conjunction" | "anu", particle: string): string {
+function particle(
+  type: "and conjunction" | "anu",
+  particle: null | string,
+): string {
   if (type === "and conjunction") {
-    return particle;
+    return particle!;
   } else {
     return "anu;";
   }
 }
 export function multiplePhrases(
   phrases: MultiplePhrases,
-  andParticle: string,
+  andParticle: null | string,
 ): string {
   switch (phrases.type) {
     case "single":

src/translator/ast.ts

@@ -88,6 +88,7 @@ export type Preposition = Readonly<{
   adverb: ReadonlyArray<Word>;
   preposition: Word;
   object: NounPhrase;
+  emphasis: boolean;
 }>;
 export type Sentence = Readonly<{
   clauses: ReadonlyArray<Clause>;

src/translator/composer.ts

@@ -68,7 +68,10 @@ export function adjective(
   return word({ word: text, emphasis: phrases.emphasis });
 }
 function preposition(preposition: English.Preposition): string {
-  return `${word(preposition.preposition)} ${noun(preposition.object, 0)}`;
+  return word({
+    word: `${word(preposition.preposition)} ${noun(preposition.object, 0)}`,
+    emphasis: preposition.emphasis,
+  });
 }
 function complement(
   complement: English.Complement,

src/translator/phrase.ts

@@ -325,7 +325,7 @@ export function multiplePhrases(
     phrases: TokiPona.MultiplePhrases;
     place: Place;
     includeGerund: boolean;
-    andParticle: string;
+    andParticle: null | string;
     includeVerb: boolean;
   }>,
 ): ArrayResult<PhraseTranslation> {

src/translator/preposition.ts

@@ -1,13 +1,74 @@
+import { throwError } from "../../misc/misc.ts";
 import { ArrayResult } from "../array_result.ts";
+import { dictionary } from "../dictionary.ts";
 import * as TokiPona from "../parser/ast.ts";
+import { fixAdverb } from "./adverb.ts";
 import * as English from "./ast.ts";
-import { TranslationTodoError } from "./error.ts";
-import { noEmphasis } from "./word.ts";
+import { FilteredError, TranslationTodoError } from "./error.ts";
+import { multipleModifiers } from "./modifier.ts";
+import { multiplePhrases } from "./phrase.ts";
+import { noEmphasis, word } from "./word.ts";
+import { getReduplicationCount } from "./word_unit.ts";
 
 export function preposition(
-  _preposition: TokiPona.Preposition,
+  preposition: TokiPona.Preposition,
 ): ArrayResult<English.Preposition> {
-  throw new TranslationTodoError("preposition");
+  return ArrayResult.combine(
+    prepositionAsWord(preposition.preposition),
+    multipleModifiers(preposition.modifiers)
+      .filterMap((modifier) =>
+        modifier.type === "adverbial"
+          ? (modifier.inWayPhrase == null ? modifier.adverb : throwError(
+            new FilteredError(
+              '"in [adjective] way" prepositional phrase modifying preposition',
+            ),
+          ))
+          : throwError(new FilteredError("adjectives modifying preposition"))
+      )
+      .map(fixAdverb),
+    multiplePhrases({
+      phrases: preposition.phrases,
+      place: "object",
+      includeGerund: true,
+      andParticle: null,
+      includeVerb: false,
+    })
+      .filterMap((phrases) =>
+        phrases.type === "noun"
+          ? phrases.noun
+          : throwError(new FilteredError(`${phrases.type} as indirect object`))
+      ),
+  )
+    .map<English.Preposition>(([preposition, adverb, object]) => ({
+      adverb,
+      preposition,
+      object,
+      emphasis: preposition.emphasis != null,
+    }));
+}
+function prepositionAsWord(
+  preposition: TokiPona.HeadedWordUnit,
+): ArrayResult<English.Word> {
+  switch (preposition.type) {
+    case "x ala x":
+      return new ArrayResult(
+        new TranslationTodoError("preposition ala preposition"),
+      );
+    case "default":
+    case "reduplication":
+      return new ArrayResult(
+        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,
@@ -17,5 +78,6 @@ export function nounAsPreposition(
     adverb: [],
     preposition: noEmphasis(preposition),
     object: phrase,
+    emphasis: false,
   };
 }