add negative metadata to adverb

Author: neverRare

dictionary/dictionary

@@ -21,7 +21,7 @@ akesi:
 
 ala:
     not(d negative);
-    not(adv);
+    not(adv negative);
     nothing(n plural);
     no(d quantifier plural);
 

dictionary/parser.ts

@@ -214,9 +214,17 @@ const adjectiveKind = choiceWithCheck(
     ),
   ),
 );
+const adverb = checkedSequence(
+  word.skip(openParenthesis).skip(keyword("adv")),
+  optionalAll(keyword("negative")).skip(closeParenthesis),
+)
+  .map(([adverb, negative]) => ({
+    adverb,
+    negative: negative != null,
+  }));
 const adjective = checkedSequence(
   sequence(
-    all(simpleUnit("adv")),
+    allWithCheck(adverb),
     word.skip(openParenthesis).skip(keyword("adj")),
   ),
   sequence(
@@ -279,8 +287,6 @@ const particleDefinition = checkedSequence(
   sequence(keyword("def"), closeParenthesis),
 )
   .map(([definition]) => ({ type: "particle definition", definition }));
-const adverbDefinition = checkedSimpleUnit("adv")
-  .map((adverb) => ({ type: "adverb", adverb }));
 const prepositionDefinition = checkedSimpleUnitWithTemplate(
   "prep",
   sequence(keyword("indirect"), keyword("object")),
@@ -557,7 +563,7 @@ const definition = choiceWithCheck(
   // adjective parser must come before adverb parser
   adjective.map((adjective) => ({ ...adjective, type: "adjective" })),
   verbDefinition,
-  adverbDefinition,
+  adverb.map((adverb) => ({ ...adverb, type: "adverb" })),
   interjectionDefinition,
   particleDefinition,
   determiner.map((determiner) => ({ ...determiner, type: "determiner" })),

dictionary/type.ts

@@ -46,8 +46,12 @@ export type AdjectiveType =
   | "origin"
   | "material"
   | "qualifier";
+export type Adverb = Readonly<{
+  adverb: string;
+  negative: boolean;
+}>;
 export type Adjective = Readonly<{
-  adverb: ReadonlyArray<string>;
+  adverb: ReadonlyArray<Adverb>;
   adjective: string;
   kind: AdjectiveType;
   gerundLike: boolean;
@@ -86,7 +90,7 @@ export type Definition =
     type: "compound adjective";
     adjective: ReadonlyArray<Adjective>;
   }>
-  | Readonly<{ type: "adverb"; adverb: string }>
+  | (Readonly<{ type: "adverb" }> & Adverb)
   | (Readonly<{ type: "verb" }> & Verb)
   | Readonly<{ type: "modal verb"; verb: string }>
   | Readonly<{ type: "preposition"; preposition: string }>

src/translator/adjective.ts

@@ -38,7 +38,14 @@ export function adjective(
     .map(({ emphasis, so }) => ({
       type: "simple",
       kind: definition.kind,
-      adverb: [...definition.adverb, ...nullableAsArray(so)].map(noEmphasis),
+      adverb: [
+        ...definition.adverb,
+        ...nullableAsArray(so).map((so) => ({ adverb: so, negative: false })),
+      ]
+        .map((adverb) => ({
+          adverb: noEmphasis(adverb.adverb),
+          negative: adverb.negative,
+        })),
       adjective: word({
         word: definition.adjective,
         reduplicationCount,

src/translator/adverb.ts

@@ -2,8 +2,8 @@ import * as English from "./ast.ts";
 import { FilteredError } from "./error.ts";
 
 export function fixAdverb(
-  adverb: ReadonlyArray<English.Word>,
-): ReadonlyArray<English.Word> {
+  adverb: ReadonlyArray<English.Adverb>,
+): ReadonlyArray<English.Adverb> {
   if (adverb.length > 1) {
     throw new FilteredError("multiple adverbs");
   } else {

src/translator/ast.ts

@@ -33,7 +33,7 @@ export type AdjectivePhrase =
   | Readonly<{
     type: "simple";
     kind: Dictionary.AdjectiveType;
-    adverb: ReadonlyArray<Word>;
+    adverb: ReadonlyArray<Adverb>;
     adjective: Word;
     emphasis: boolean;
   }>
@@ -46,8 +46,12 @@ export type AdjectivePhrase =
 export type Complement =
   | Readonly<{ type: "noun"; noun: NounPhrase }>
   | Readonly<{ type: "adjective"; adjective: AdjectivePhrase }>;
+export type Adverb = Readonly<{
+  adverb: Word;
+  negative: boolean;
+}>;
 export type AdverbVerb = {
-  adverb: ReadonlyArray<Word>;
+  adverb: ReadonlyArray<Adverb>;
   verb: Word;
 };
 export type Verb = Readonly<{
@@ -87,7 +91,7 @@ export type Clause =
   | Readonly<{ type: "adverb"; adverb: Word }>
   | Readonly<{ type: "dependent"; conjunction: Word; clause: Clause }>;
 export type Preposition = Readonly<{
-  adverb: ReadonlyArray<Word>;
+  adverb: ReadonlyArray<Adverb>;
   preposition: Word;
   object: NounPhrase;
   emphasis: boolean;

src/translator/composer.ts

@@ -42,7 +42,10 @@ export function adjective(
   let text: string;
   switch (phrases.type) {
     case "simple":
-      text = [...phrases.adverb.map(word), word(phrases.adjective)]
+      text = [
+        ...phrases.adverb.map(({ adverb }) => word(adverb)),
+        word(phrases.adjective),
+      ]
         .join(" ");
       break;
     case "compound":
@@ -70,7 +73,7 @@ function complement(complement: English.Complement) {
 }
 export function adverbVerb(verbAdverb: English.AdverbVerb): string {
   const { adverb, verb } = verbAdverb;
-  return [...adverb, verb].map(word).join(" ");
+  return [...adverb.map(({ adverb }) => adverb), verb].map(word).join(" ");
 }
 export function verb(phrase: English.VerbPhrase, depth: number): string {
   let text: string;

src/translator/modifier.ts

@@ -23,7 +23,7 @@ export type ModifierTranslation =
   }>
   | Readonly<{ type: "adjective"; adjective: English.AdjectivePhrase }>
   | Readonly<{ type: "determiner"; determiner: English.Determiner }>
-  | Readonly<{ type: "adverb"; adverb: English.Word }>
+  | Readonly<{ type: "adverb"; adverb: English.Adverb }>
   | Readonly<{ type: "name"; name: string }>
   | Readonly<{ type: "position phrase"; noun: English.NounPhrase }>;
 export type AdjectivalModifier = Readonly<{
@@ -37,7 +37,7 @@ export type AdjectivalModifier = Readonly<{
   inPositionPhrase: null | English.NounPhrase;
 }>;
 export type AdverbialModifier = Readonly<{
-  adverb: ReadonlyArray<English.Word>;
+  adverb: ReadonlyArray<English.Adverb>;
   inWayPhrase: null | English.NounPhrase;
 }>;
 export type MultipleModifierTranslation =
@@ -132,11 +132,14 @@ export function defaultModifier(
             case "adverb":
               return IterableResult.single({
                 type: "adverb",
-                adverb: word({
-                  word: definition.adverb,
-                  reduplicationCount,
-                  emphasis,
-                }),
+                adverb: {
+                  adverb: word({
+                    word: definition.adverb,
+                    reduplicationCount,
+                    emphasis,
+                  }),
+                  negative: definition.negative,
+                },
               });
             default:
               return IterableResult.empty();

src/translator/verb.ts

@@ -18,7 +18,7 @@ export type PartialVerb =
   & VerbObjects
   & Readonly<{
     modal: null | English.AdverbVerb;
-    adverb: ReadonlyArray<English.Word>;
+    adverb: ReadonlyArray<English.Adverb>;
     first: null | Dictionary.VerbForms;
     reduplicationCount: number;
     wordEmphasis: boolean;