partial implementation of verb negation

Author: neverRare

src/translator/adjective.ts

@@ -1,7 +1,8 @@
 import * as Dictionary from "../../dictionary/type.ts";
-import { nullableAsArray } from "../../misc/misc.ts";
+import { mapNullable, nullableAsArray } from "../../misc/misc.ts";
 import { IterableResult } from "../compound.ts";
 import * as TokiPona from "../parser/ast.ts";
+import { extractNegativeFromAdverbs } from "./adverb.ts";
 import * as English from "./ast.ts";
 import { UntranslatableError } from "./error.ts";
 import { noEmphasis, word } from "./word.ts";
@@ -110,3 +111,22 @@ export function fixAdjective(
     })
     .sort((a, b) => rankAdjective(a.kind) - rankAdjective(b.kind));
 }
+export function extractNegativeFromAdjective(
+  adjective: English.AdjectivePhrase,
+): null | English.AdjectivePhrase {
+  switch (adjective.type) {
+    case "simple":
+      return mapNullable(
+        extractNegativeFromAdverbs(adjective.adverb),
+        (adverb) => ({ ...adjective, adverb }),
+      );
+    case "compound": {
+      const adjectives = adjective.adjective.map(extractNegativeFromAdjective);
+      if (adjectives.every((adjective) => adjective != null)) {
+        return { ...adjective, adjective: adjectives };
+      } else {
+        return null;
+      }
+    }
+  }
+}

src/translator/adverb.ts

@@ -10,3 +10,13 @@ export function fixAdverb(
     return adverb;
   }
 }
+export function extractNegativeFromAdverbs(
+  adverb: ReadonlyArray<English.Adverb>,
+): null | ReadonlyArray<English.Adverb> {
+  const index = adverb.findIndex(({ negative }) => negative);
+  if (index === -1) {
+    return null;
+  } else {
+    return [...adverb].splice(index, 1);
+  }
+}

src/translator/ast.ts

@@ -51,8 +51,9 @@ export type Adverb = Readonly<{
   negative: boolean;
 }>;
 export type AdverbVerb = {
-  adverb: ReadonlyArray<Adverb>;
+  preAdverb: ReadonlyArray<Adverb>;
   verb: Word;
+  postAdverb: ReadonlyArray<Adverb>;
 };
 export type Verb = Readonly<{
   modal: null | AdverbVerb;

src/translator/clause.ts

@@ -152,16 +152,14 @@ function oClause(clause: TokiPona.Clause & { type: "o clause" }) {
       return IterableResult.concat(
         verb(predicate, subjectPerspective, subject.quantity)
           .map((verb) => iWish(subject, verb)),
-        IterableResult.from(() =>
-          verb(
-            addModalToAll(
-              noAdverbs(noEmphasis("should")),
-              predicate,
-            ),
+        IterableResult.from(() => {
+          const takeNegative = true;
+          return verb(
+            addModalToAll("should", predicate, takeNegative),
             subjectPerspective,
             subject.quantity,
-          )
-        )
+          );
+        })
           .map((verb) => ({
             type: "default",
             subject,

src/translator/composer.ts

@@ -72,8 +72,13 @@ function complement(complement: English.Complement) {
   }
 }
 export function adverbVerb(verbAdverb: English.AdverbVerb): string {
-  const { adverb, verb } = verbAdverb;
-  return [...adverb.map(({ adverb }) => adverb), verb].map(word).join(" ");
+  const { preAdverb, verb, postAdverb } = verbAdverb;
+  return [
+    ...preAdverb.map(({ adverb }) => adverb),
+    verb,
+    ...postAdverb.map(({ adverb }) => adverb),
+  ]
+    .map(word).join(" ");
 }
 export function verb(phrase: English.VerbPhrase, depth: number): string {
   let text: string;

src/translator/determiner.ts

@@ -133,6 +133,16 @@ export function fixDeterminer(
     );
   }
 }
+export function extractNegativeFromDeterminers(
+  determiner: ReadonlyArray<English.Determiner>,
+): null | ReadonlyArray<English.Determiner> {
+  const index = determiner.findIndex(({ kind }) => kind === "negative");
+  if (index === -1) {
+    return null;
+  } else {
+    return [...determiner].splice(index, 1);
+  }
+}
 function prettyPrintDeterminers(
   determiners: ReadonlyArray<English.Determiner>,
 ) {

src/translator/noun.ts

@@ -1,11 +1,11 @@
 import * as Dictionary from "../../dictionary/type.ts";
-import { nullableAsArray } from "../../misc/misc.ts";
+import { mapNullable, nullableAsArray } from "../../misc/misc.ts";
 import { IterableResult } from "../compound.ts";
 import { settings } from "../settings.ts";
 import { adjective } from "./adjective.ts";
 import * as English from "./ast.ts";
 import * as EnglishComposer from "./composer.ts";
-import { determiner } from "./determiner.ts";
+import { determiner, extractNegativeFromDeterminers } from "./determiner.ts";
 import { condense } from "./misc.ts";
 import { word } from "./word.ts";
 
@@ -138,3 +138,22 @@ export function perspective(noun: English.NounPhrase): Dictionary.Perspective {
       return "third";
   }
 }
+export function extractNegativeFromNoun(
+  noun: English.NounPhrase,
+): null | English.NounPhrase {
+  switch (noun.type) {
+    case "simple":
+      return mapNullable(
+        extractNegativeFromDeterminers(noun.determiner),
+        (determiner) => ({ ...noun, determiner }),
+      );
+    case "compound": {
+      const nouns = noun.nouns.map(extractNegativeFromNoun);
+      if (nouns.every((noun) => noun != null)) {
+        return { ...noun, nouns };
+      } else {
+        return null;
+      }
+    }
+  }
+}

src/translator/phrase.ts

@@ -2,7 +2,11 @@ import { mapNullable, nullableAsArray } from "../../misc/misc.ts";
 import { IterableResult } from "../compound.ts";
 import * as TokiPona from "../parser/ast.ts";
 import * as Composer from "../parser/composer.ts";
-import { AdjectiveWithInWay, fixAdjective } from "./adjective.ts";
+import {
+  AdjectiveWithInWay,
+  extractNegativeFromAdjective,
+  fixAdjective,
+} from "./adjective.ts";
 import { fixAdverb } from "./adverb.ts";
 import * as English from "./ast.ts";
 import { fixDeterminer, getNumber } from "./determiner.ts";
@@ -18,8 +22,12 @@ import {
   AdverbialModifier,
   multipleModifiers,
 } from "./modifier.ts";
-import { fromNounForms, PartialNoun } from "./noun.ts";
-import { nounAsPreposition, preposition } from "./preposition.ts";
+import { extractNegativeFromNoun, fromNounForms, PartialNoun } from "./noun.ts";
+import {
+  extractNegativeFromPreposition,
+  nounAsPreposition,
+  preposition,
+} from "./preposition.ts";
 import { Place } from "./pronoun.ts";
 import { PartialCompoundVerb, PartialVerb } from "./verb.ts";
 import { word } from "./word.ts";
@@ -138,6 +146,7 @@ function adjectivePhrase(
       }
   }
 }
+// TODO: extract "not"
 function verbPhrase(
   options: Readonly<{
     emphasis: boolean;
@@ -165,11 +174,11 @@ function verbPhrase(
     return {
       ...verb,
       modal: {
-        adverb: fixAdverb([
+        ...verb.modal,
+        preAdverb: fixAdverb([
           ...[...modifier.adverb].reverse(),
-          ...verb.modal.adverb,
+          ...verb.modal.preAdverb,
         ]),
-        verb: verb.modal.verb,
       },
       phraseEmphasis: emphasis,
       preposition,
@@ -229,21 +238,23 @@ function defaultPhrase(
     .addErrorWhenNone(() => new ExhaustedError(Composer.phrase(phrase)));
 }
 function prepositionAsVerb(preposition: English.Preposition) {
+  const extracted = extractNegativeFromPreposition(preposition);
   return {
     modal: null,
     adverb: [],
     first: {
       presentPlural: "are",
       presentSingular: "is",
       past: "were",
+      negated: extracted != null,
     },
     reduplicationCount: 1,
     wordEmphasis: false,
     rest: [],
     subjectComplement: null,
     object: null,
     objectComplement: null,
-    preposition: [preposition],
+    preposition: [extracted ?? preposition],
     forObject: false,
     predicateType: null,
     phraseEmphasis: false,
@@ -336,20 +347,27 @@ export function phraseAsVerb(
   switch (phrase.type) {
     case "noun":
     case "adjective": {
+      let negated: boolean;
       let subjectComplement: English.Complement;
       switch (phrase.type) {
-        case "noun":
+        case "noun": {
+          const extract = extractNegativeFromNoun(phrase.noun);
+          negated = extract != null;
           subjectComplement = {
             type: "noun",
-            noun: phrase.noun,
+            noun: extract ?? phrase.noun,
           };
           break;
-        case "adjective":
+        }
+        case "adjective": {
+          const extract = extractNegativeFromAdjective(phrase.adjective);
+          negated = extract != null;
           subjectComplement = {
             type: "adjective",
-            adjective: phrase.adjective,
+            adjective: extract ?? phrase.adjective,
           };
           break;
+        }
       }
       return {
         type: "simple",
@@ -359,6 +377,7 @@ export function phraseAsVerb(
           presentPlural: "are",
           presentSingular: "is",
           past: "were",
+          negated,
         },
         wordEmphasis: false,
         reduplicationCount: 1,