implement translation of "preposition la"

Author: neverRare

src/translator/ast.ts

@@ -82,6 +82,7 @@ export type Clause =
   | Readonly<{ type: "subject phrase"; subject: NounPhrase }>
   | Readonly<{ type: "interjection"; interjection: Word }>
   | Readonly<{ type: "vocative"; call: string; addressee: NounPhrase }>
+  | (Readonly<{ type: "preposition" }> & Preposition)
   | Readonly<{ type: "dependent"; conjunction: Word; clause: Clause }>;
 export type Preposition = Readonly<{
   adverb: ReadonlyArray<Word>;

src/translator/clause.ts

@@ -6,7 +6,7 @@ import { FilteredError, TranslationTodoError } from "./error.ts";
 import { perspective } from "./noun.ts";
 import { multiplePhrases, multiplePhrasesAsNoun } from "./phrase.ts";
 import { predicate } from "./predicate.ts";
-import { nounAsPreposition } from "./preposition.ts";
+import { nounAsPreposition, preposition } from "./preposition.ts";
 import { addModalToAll, noAdverbs, verb } from "./verb.ts";
 import { noEmphasis } from "./word.ts";
 
@@ -204,19 +204,26 @@ export function clause(clause: TokiPona.Clause): ArrayResult<English.Clause> {
 }
 export function contextClause(
   contextClause: TokiPona.ContextClause,
-): ArrayResult<English.Clause> {
+): ArrayResult<ReadonlyArray<English.Clause>> {
   switch (contextClause.type) {
     case "prepositions":
+      return ArrayResult.combine(...contextClause.prepositions.map(preposition))
+        .map((prepositions) =>
+          prepositions.map((preposition) => ({
+            ...preposition,
+            type: "preposition",
+          }))
+        );
     case "nanpa":
     case "anu":
       return new ArrayResult(
         new TranslationTodoError(`${contextClause.type} context clause`),
       );
     default:
-      return clause(contextClause).map((clause) => ({
+      return clause(contextClause).map((clause) => [{
         type: "dependent",
         conjunction: noEmphasis("given"),
         clause,
-      }));
+      }]);
   }
 }

src/translator/composer.ts

@@ -125,6 +125,8 @@ function clause(ast: English.Clause): string {
       return noun(ast.subject, 0);
     case "vocative":
       return `${ast.call} ${noun(ast.addressee, 0)}`;
+    case "preposition":
+      return preposition(ast);
     case "dependent":
       return `${word(ast.conjunction)} ${clause(ast.clause)}`;
   }

src/translator/sentence.ts

@@ -131,7 +131,10 @@ function sentence(
   switch (sentence.type) {
     case "default": {
       const laClauses = sentence.laClauses;
-      const givenClauses = ArrayResult.combine(...laClauses.map(contextClause));
+      const contextClauses = ArrayResult.combine(
+        ...laClauses.map(contextClause),
+      )
+        .map((clause) => clause.flat());
       if (sentence.startingParticle != null) {
         return new ArrayResult(
           new TranslationTodoError(
@@ -147,11 +150,11 @@ function sentence(
           ? interjection(sentence.finalClause)
           : new ArrayResult<English.Clause>();
       const engClauses = ArrayResult.combine(
-        givenClauses,
+        contextClauses,
         ArrayResult.concat(interjectionClause, lastEngClause),
       )
-        .map(([givenClauses, lastClause]) => [
-          ...givenClauses,
+        .map(([contextClauses, lastClause]) => [
+          ...contextClauses,
           lastClause,
           ...right,
         ]);