improve partial verb structure

Author: neverRare

src/translator/phrase.ts

@@ -171,30 +171,34 @@ function verbPhrase(
   }
   const negated = extracted != null;
   const useAdverbs = extracted ?? adverbs;
-  if (verb.first != null) {
-    return {
-      ...verb,
-      first: { ...verb.first, negated, adverbs: useAdverbs },
-      emphasis: emphasis,
-      prepositions,
-    };
-  } else if (verb.modal != null) {
-    const postAdverb = negated ? NOT : null;
-    return {
-      ...verb,
-      modal: {
-        preAdverbs: useAdverbs,
-        verb: verb.modal.verb,
-        postAdverb,
-      },
-      emphasis: emphasis,
-      prepositions,
-    };
-  } else {
-    // This should be unreachable
-    throw new FilteredError(
-      "verb phrase without modal verb nor conjugated verb",
-    );
+  const { first } = verb;
+  switch (first.type) {
+    case "modal": {
+      const postAdverb = negated ? NOT : null;
+      return {
+        ...verb,
+        first: {
+          type: "modal",
+          preAdverbs: useAdverbs,
+          verb: first.verb,
+          postAdverb,
+        },
+        emphasis: emphasis,
+        prepositions,
+      };
+    }
+    case "conjugated":
+      return {
+        ...verb,
+        first: {
+          ...first,
+          type: "conjugated",
+          negated,
+          adverbs: useAdverbs,
+        },
+        emphasis: emphasis,
+        prepositions,
+      };
   }
 }
 function defaultPhrase(
@@ -247,8 +251,8 @@ function defaultPhrase(
 function prepositionAsVerb(preposition: English.Preposition): PartialVerb {
   const extracted = extractNegativeFromPreposition(preposition);
   return {
-    modal: null,
     first: {
+      type: "conjugated",
       adverbs: [],
       presentPlural: "are",
       presentSingular: "is",
@@ -368,8 +372,8 @@ export function phraseAsVerb(
       }
       return {
         type: "simple",
-        modal: null,
         first: {
+          type: "conjugated",
           adverbs: [],
           presentPlural: "are",
           presentSingular: "is",

src/translator/predicate.ts

@@ -45,8 +45,8 @@ function applyToAndTurnInto(
       IterableResult.fromArray<PartialCompoundVerb>([
         {
           type: "simple",
-          modal: null,
           first: {
+            type: "conjugated",
             adverbs: [],
             presentPlural: "apply",
             presentSingular: "applies",
@@ -66,8 +66,8 @@ function applyToAndTurnInto(
         },
         {
           type: "simple",
-          modal: null,
           first: {
+            type: "conjugated",
             adverbs: [],
             presentPlural: "turn",
             presentSingular: "turns",
@@ -96,8 +96,8 @@ function make(predicate: AdjectiveWithInWay, object: English.NounPhrase) {
   ])
     .map(([negated, adjective]): PartialCompoundVerb => ({
       type: "simple",
-      modal: null,
       first: {
+        type: "conjugated",
         adverbs: [],
         presentPlural: "make",
         presentSingular: "makes",

src/translator/verb.ts

@@ -23,11 +23,13 @@ export type VerbObjects = Readonly<{
   objectComplement: null | English.Complement;
   prepositions: ReadonlyArray<English.Preposition>;
 }>;
+export type FirstVerb =
+  | (Readonly<{ type: "modal" }> & English.AdverbVerb)
+  | (Readonly<{ type: "conjugated" }> & VerbForms);
 export type PartialVerb =
   & VerbObjects
   & Readonly<{
-    modal: null | English.AdverbVerb;
-    first: null | VerbForms;
+    first: FirstVerb;
     rest: ReadonlyArray<English.AdverbVerb>;
     subjectComplement: null | English.Complement;
     forObject: boolean | string;
@@ -55,40 +57,40 @@ function addModal(
     verb: PartialVerb;
     takeNegative: boolean;
   }>,
-) {
+): PartialVerb {
   const { modal, verb, takeNegative } = options;
-  if (verb.modal == null) {
-    const newRest = nullableAsArray(verb.first)
-      .map((first): English.AdverbVerb => {
-        const { adverbs, presentPlural, negated } = first;
-        const useVerb = presentPlural === "are" ? "be" : presentPlural;
-        const preAdverbs = takeNegative ? adverbs : [
-          ...(negated ? [NOT] : []),
-          ...adverbs,
-        ];
-        return {
-          preAdverbs,
-          verb: word({ ...first, word: useVerb }),
-          postAdverb: null,
-        };
-      });
-    const postAdverb = takeNegative && (verb.first?.negated ?? false)
-      ? NOT
-      : null;
-    return {
-      ...verb,
-      modal: {
-        preAdverbs: [],
-        verb: noEmphasis(modal),
-        postAdverb,
-      },
-      first: null,
-      rest: [...newRest, ...verb.rest],
-      reduplicationCount: 1,
-      emphasis: false,
-    };
-  } else {
-    throw new FilteredError("nested modal verb");
+  const { first } = verb;
+  switch (first.type) {
+    case "modal":
+      throw new FilteredError("nested modal verb");
+    case "conjugated": {
+      const newRest = nullableAsArray(first)
+        .map((first): English.AdverbVerb => {
+          const { adverbs, presentPlural, negated } = first;
+          const useVerb = presentPlural === "are" ? "be" : presentPlural;
+          const preAdverbs = takeNegative ? adverbs : [
+            ...(negated ? [NOT] : []),
+            ...adverbs,
+          ];
+          return {
+            preAdverbs,
+            verb: word({ ...first, word: useVerb }),
+            postAdverb: null,
+          };
+        });
+      const postAdverb = takeNegative && (first.negated ?? false) ? NOT : null;
+      return {
+        ...verb,
+        first: {
+          type: "modal",
+          preAdverbs: [],
+          verb: noEmphasis(modal),
+          postAdverb,
+        },
+        rest: [...newRest, ...verb.rest],
+        emphasis: false,
+      };
+    }
   }
 }
 export function addModalToAll(
@@ -145,9 +147,9 @@ export function partialVerb(
   return IterableResult.combine(object, prepositions)
     .map(([object, prepositions]): PartialVerb => ({
       ...definition,
-      modal: null,
       first: {
         ...definition,
+        type: "conjugated",
         adverbs: [],
         negated: false,
         reduplicationCount,
@@ -360,30 +362,6 @@ export function verb(
   quantity: English.Quantity,
 ): IterableResult<English.VerbPhrase> {
   switch (partialVerb.type) {
-    case "simple": {
-      const verbForms = partialVerb.first;
-      if (verbForms != null) {
-        return fromVerbForms(verbForms, perspective, quantity)
-          .map((verb): English.VerbPhrase => ({
-            ...partialVerb,
-            type: "simple",
-            verb: {
-              modal: verb.modal,
-              verbs: [...verb.verbs, ...partialVerb.rest],
-            },
-            contentClause: null,
-            hideVerb: false,
-          }));
-      } else {
-        return IterableResult.single({
-          ...partialVerb,
-          type: "simple",
-          verb: { modal: partialVerb.modal, verbs: partialVerb.rest },
-          contentClause: null,
-          hideVerb: false,
-        });
-      }
-    }
     case "compound":
       return IterableResult.combine(
         ...partialVerb.verbs.map((partialVerb) =>
@@ -395,6 +373,31 @@ export function verb(
           type: "compound",
           verbs,
         }));
+    case "simple": {
+      const { first } = partialVerb;
+      switch (first.type) {
+        case "modal":
+          return IterableResult.single({
+            ...partialVerb,
+            type: "simple",
+            verb: { modal: first, verbs: partialVerb.rest },
+            contentClause: null,
+            hideVerb: false,
+          });
+        case "conjugated":
+          return fromVerbForms(first, perspective, quantity)
+            .map((verb): English.VerbPhrase => ({
+              ...partialVerb,
+              type: "simple",
+              verb: {
+                modal: verb.modal,
+                verbs: [...verb.verbs, ...partialVerb.rest],
+              },
+              contentClause: null,
+              hideVerb: false,
+            }));
+      }
+    }
   }
 }
 export function noAdverbs(verb: English.Word): English.AdverbVerb {

src/translator/word_unit.ts

@@ -79,7 +79,8 @@ function defaultWordUnit(
         case "modal verb":
           return IterableResult.single<WordUnitTranslation>({
             type: "verb",
-            modal: {
+            first: {
+              type: "modal",
               preAdverbs: [],
               verb: word({
                 word: definition.verb,
@@ -88,7 +89,6 @@ function defaultWordUnit(
               }),
               postAdverb: null,
             },
-            first: null,
             rest: [],
             subjectComplement: null,
             object: null,