implement translation of o clause, closes #60

Author: neverRare

src/translator/clause.ts

@@ -3,10 +3,11 @@ import { nullableAsArray, throwError } from "../misc.ts";
 import * as TokiPona from "../parser/ast.ts";
 import * as English from "./ast.ts";
 import { FilteredOutError, 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 { verb } from "./verb.ts";
+import { addModalToAll, verb } from "./verb.ts";
 import { unemphasized } from "./word.ts";
 
 function phraseClause(
@@ -85,10 +86,7 @@ function liClause(
     predicate(clause.predicates, "li"),
   )
     .flatMap(([subject, predicate]) => {
-      const perspective = subject.type === "simple"
-        ? subject.perspective
-        : "third";
-      return verb(predicate, perspective, subject.quantity)
+      return verb(predicate, perspective(subject), subject.quantity)
         .map((verb) => ({
           type: "default",
           subject,
@@ -97,6 +95,89 @@ function liClause(
         }));
     });
 }
+function iWish(
+  subject: English.NounPhrase,
+  verb: English.VerbPhrase,
+): English.Clause {
+  return {
+    type: "default",
+    subject: {
+      type: "simple",
+      determiner: [],
+      adjective: [],
+      noun: unemphasized("I"),
+      quantity: "singular",
+      perspective: "first",
+      postAdjective: null,
+      preposition: [],
+      emphasis: false,
+    },
+    verb: {
+      type: "default",
+      adverb: [],
+      verb: {
+        modal: null,
+        first: unemphasized("wish"),
+        rest: [],
+      },
+      subjectComplement: null,
+      contentClause: {
+        type: "default",
+        subject,
+        verb,
+        hideSubject: false,
+      },
+      object: null,
+      objectComplement: null,
+      preposition: [],
+      hideVerb: false,
+    },
+    hideSubject: false,
+  };
+}
+function oClause(
+  clause: TokiPona.Clause & { type: "o clause" },
+): ArrayResult<English.Clause> {
+  const subject = clause.subjects != null
+    ? multiplePhrasesAsNoun({
+      phrases: clause.subjects,
+      place: "subject",
+      includeGerund: true,
+      andParticle: "en",
+    })
+    : new ArrayResult<English.NounPhrase>([{
+      type: "simple",
+      determiner: [],
+      adjective: [],
+      noun: unemphasized("you"),
+      quantity: "plural",
+      perspective: "second",
+      postAdjective: null,
+      preposition: [],
+      emphasis: false,
+    }]);
+  return ArrayResult.concat(
+    ArrayResult.combine(subject, predicate(clause.predicates, "o"))
+      .flatMap(([subject, predicate]) => {
+        return verb(predicate, perspective(subject), subject.quantity)
+          .map<English.Clause>((verb) => iWish(subject, verb));
+      }),
+    ArrayResult.combine(
+      subject,
+      predicate(clause.predicates, "o")
+        .map((verb) => addModalToAll(unemphasized("should"), verb)),
+    )
+      .flatMap(([subject, predicate]) => {
+        return verb(predicate, perspective(subject), subject.quantity)
+          .map((verb) => ({
+            type: "default",
+            subject,
+            verb,
+            hideSubject: false,
+          }));
+      }),
+  );
+}
 export function clause(clause: TokiPona.Clause): ArrayResult<English.Clause> {
   switch (clause.type) {
     case "phrases":
@@ -118,8 +199,9 @@ export function clause(clause: TokiPona.Clause): ArrayResult<English.Clause> {
         );
     case "li clause":
       return liClause(clause);
-    case "prepositions":
     case "o clause":
+      return oClause(clause);
+    case "prepositions":
       return new ArrayResult(new TranslationTodoError(clause.type));
   }
 }

src/translator/noun.ts

@@ -126,3 +126,11 @@ export function nounAsPlainString(
   return noun({ definition, reduplicationCount: 1, emphasis: false })
     .map((noun) => EnglishComposer.noun(noun, 0));
 }
+export function perspective(noun: English.NounPhrase): Dictionary.Perspective {
+  switch (noun.type) {
+    case "simple":
+      return noun.perspective;
+    case "compound":
+      return "third";
+  }
+}

src/translator/verb.ts

@@ -1,8 +1,9 @@
 import * as Dictionary from "../../dictionary/type.ts";
 import { ArrayResult } from "../array_result.ts";
-import { mapNullable } from "../misc.ts";
+import { mapNullable, nullableAsArray } from "../misc.ts";
 import { settings } from "../settings.ts";
 import * as English from "./ast.ts";
+import { FilteredOutError } from "./error.ts";
 import { condense } from "./misc.ts";
 import { noun } from "./noun.ts";
 import { nounAsPreposition } from "./preposition.ts";
@@ -43,6 +44,44 @@ export function condenseVerb(present: string, past: string): string {
   const second = past.split(" ")[0];
   return [condense(first, second), ...rest].join(" ");
 }
+export function addModal(modal: English.Word, verb: PartialVerb): PartialVerb {
+  if (verb.modal == null) {
+    const newRest = nullableAsArray(verb.first)
+      .map(({ presentPlural }) => presentPlural)
+      .map((verb) => verb === "are" ? "be" : verb)
+      .map((newVerb) =>
+        word({
+          word: newVerb,
+          reduplicationCount: verb.reduplicationCount,
+          emphasis: verb.wordEmphasis,
+        })
+      );
+    return {
+      ...verb,
+      modal,
+      first: null,
+      rest: [...newRest, ...verb.rest],
+      reduplicationCount: 1,
+      wordEmphasis: false,
+    };
+  } else {
+    throw new FilteredOutError("nested modal verb");
+  }
+}
+export function addModalToAll(
+  modal: English.Word,
+  verb: PartialCompoundVerb,
+): PartialCompoundVerb {
+  switch (verb.type) {
+    case "simple":
+      return { ...addModal(modal, verb), type: "simple" };
+    case "compound":
+      return {
+        ...verb,
+        verb: verb.verb.map((verb) => addModalToAll(modal, verb)),
+      };
+  }
+}
 export function partialVerb(
   options: Readonly<{
     definition: Dictionary.Verb;