rename

Author: neverRare

dictionary/parser.ts

@@ -34,8 +34,8 @@ import {
   IndirectObject,
   Noun,
   NounForms,
-  PartialVerb,
   PostAdjective,
+  VerbAccessory,
 } from "./type.ts";
 
 const RESERVED_SYMBOLS = "#()*+/:;<=>@[\\]^`{|}~";
@@ -459,7 +459,7 @@ const verbDefinition = checkedSequence(
         ))
         .map(nullableAsArray),
     )
-      .map(([_, indirectObjects]): null | PartialVerb => ({
+      .map(([_, indirectObjects]): null | VerbAccessory => ({
         directObject: null,
         indirectObjects,
         forObject: true,
@@ -469,7 +469,7 @@ const verbDefinition = checkedSequence(
       sequence(closeParenthesis, openBracket, keyword("predicate")),
       closeBracket,
     )
-      .map((): null | PartialVerb => ({
+      .map((): null | VerbAccessory => ({
         directObject: null,
         indirectObjects: [],
         forObject: false,
@@ -479,12 +479,12 @@ const verbDefinition = checkedSequence(
       keyword("modal"),
       sequence(closeParenthesis, template(keyword("predicate"))),
     )
-      .map((): null | PartialVerb => null),
+      .map((): null | VerbAccessory => null),
     checkedSequence(
       keyword("linking"),
       sequence(closeParenthesis, template(keyword("predicate"))),
     )
-      .map((): null | PartialVerb => ({
+      .map((): null | VerbAccessory => ({
         directObject: null,
         indirectObjects: [],
         forObject: false,
@@ -509,7 +509,7 @@ const verbDefinition = checkedSequence(
         ),
       ),
     )
-      .map(([_, [directObject, rawIndirectObject]]): PartialVerb => {
+      .map(([_, [directObject, rawIndirectObject]]): VerbAccessory => {
         if (rawIndirectObject == null) {
           return {
             directObject,

dictionary/type.ts

@@ -64,13 +64,13 @@ export type IndirectObject = Readonly<{
   preposition: string;
   object: Noun;
 }>;
-export type PartialVerb = Readonly<{
+export type VerbAccessory = Readonly<{
   directObject: null | Noun;
   indirectObjects: ReadonlyArray<IndirectObject>;
   forObject: boolean | string;
   predicateType: null | "verb" | "noun adjective";
 }>;
-export type Verb = VerbForms & PartialVerb;
+export type Verb = VerbForms & VerbAccessory;
 export type Definition =
   | Readonly<{ type: "filler"; before: string; repeat: string; after: string }>
   | Readonly<{ type: "particle definition"; definition: string }>

src/parser/parser_lib.ts

@@ -3,20 +3,20 @@ import { MemoizationCacheResult, memoize } from "@std/cache/memoize";
 import { lazy as lazyEval } from "../../misc/misc.ts";
 import { ArrayResult, ResultError } from "../compound.ts";
 
-type SingleResult<T> = Readonly<{ value: T; length: number }>;
-type ParserResult<T> = ArrayResult<SingleResult<T>>;
-type InnerParser<T> = (input: number) => ParserResult<T>;
+type ValueLength<T> = Readonly<{ value: T; length: number }>;
+type ParserResult<T> = ArrayResult<ValueLength<T>>;
+type RawParser<T> = (input: number) => ParserResult<T>;
 type Cache<T> = Map<number, MemoizationCacheResult<ParserResult<T>>>;
 
 let currentSource = "";
 const allCache: Set<WeakRef<Cache<unknown>>> = new Set();
 
 export class Parser<T> {
-  readonly rawParser: InnerParser<T>;
-  constructor(parser: InnerParser<T>) {
+  readonly rawParser: RawParser<T>;
+  constructor(parser: RawParser<T>) {
     const cache: Cache<T> = new Map();
     allCache.add(new WeakRef(cache));
-    this.rawParser = memoize<InnerParser<T>, number, Cache<T>>(
+    this.rawParser = memoize<RawParser<T>, number, Cache<T>>(
       parser,
       { cache },
     );
@@ -36,7 +36,7 @@ export class Parser<T> {
   map<U>(mapper: (value: T) => U): Parser<U> {
     return new Parser((input) =>
       this.rawParser(input)
-        .map(({ value, length }): SingleResult<U> => ({
+        .map(({ value, length }): ValueLength<U> => ({
           value: mapper(value),
           length,
         }))
@@ -62,7 +62,7 @@ export class Parser<T> {
         .flatMap(({ value, length }) =>
           mapper(value)
             .rawParser(position + length)
-            .map(({ value, length: addedLength }): SingleResult<U> => ({
+            .map(({ value, length: addedLength }): ValueLength<U> => ({
               value,
               length: length + addedLength,
             }))
@@ -131,7 +131,7 @@ export const emptyArray: Parser<ReadonlyArray<never>> = nothing.map(() => []);
 export function lookAhead<T>(parser: Parser<T>): Parser<T> {
   return new Parser((input) =>
     parser.rawParser(input)
-      .map(({ value }): SingleResult<T> => ({ value, length: 0 }))
+      .map(({ value }): ValueLength<T> => ({ value, length: 0 }))
   );
 }
 export function lazy<T>(parser: () => Parser<T>): Parser<T> {
@@ -316,7 +316,7 @@ export type WithSource<T> = readonly [value: T, source: string];
 export function withSource<T>(parser: Parser<T>): Parser<WithSource<T>> {
   return new Parser((position) =>
     parser.rawParser(position).map(
-      ({ value, length }): SingleResult<WithSource<T>> => ({
+      ({ value, length }): ValueLength<WithSource<T>> => ({
         value: [
           value,
           currentSource.slice(position, position + length),
@@ -330,7 +330,7 @@ export type WithPosition<T> = Readonly<{ value: T }> & Position;
 export function withPosition<T>(parser: Parser<T>): Parser<WithPosition<T>> {
   return new Parser((position) =>
     parser.rawParser(position).map(
-      ({ value, length }): SingleResult<WithPosition<T>> => ({
+      ({ value, length }): ValueLength<WithPosition<T>> => ({
         value: { value, position, length },
         length,
       }),

src/settings.ts

@@ -1,12 +1,12 @@
-export type RedundancySettings = "both" | "condensed" | "default only";
+export type Redundancy = "both" | "condensed" | "default only";
 
 // may be extended but existing properties must stay unchanged
 export type Settings = {
   teloMisikeke: boolean;
   randomize: boolean;
   multiline: boolean;
-  quantity: RedundancySettings;
-  tense: RedundancySettings;
+  quantity: Redundancy;
+  tense: Redundancy;
   xAlaXPartialParsing: boolean;
   separateRepeatedModifiers: boolean;
   hardcodedAnuLa: boolean;

src/settings_frontend.ts

@@ -2,12 +2,7 @@
 
 import { toKebabCase } from "@std/text/to-kebab-case";
 import { checkLocalStorage, setIgnoreError } from "./local_storage.ts";
-import {
-  defaultSettings,
-  RedundancySettings,
-  Settings,
-  settings,
-} from "./settings.ts";
+import { defaultSettings, Redundancy, Settings, settings } from "./settings.ts";
 
 type Updater<T> = Readonly<{
   parse: (value: string) => null | T;
@@ -32,13 +27,13 @@ const BOOL_UPDATER: Updater<boolean> = {
     (input as HTMLInputElement).checked = value;
   },
 };
-const REDUNDANCY_UPDATER: Updater<RedundancySettings> = {
+const REDUNDANCY_UPDATER: Updater<Redundancy> = {
   parse: (value) =>
     ["both", "condensed", "default only"].includes(value)
-      ? value as RedundancySettings
+      ? value as Redundancy
       : null,
   stringify: (value) => value,
-  load: ({ value }) => value as RedundancySettings,
+  load: ({ value }) => value as Redundancy,
   set: (input, value) => {
     input.value = value;
   },

src/translator/ast.ts

@@ -52,19 +52,19 @@ export type Adverb = Readonly<{
   adverb: Word;
   negative: boolean;
 }>;
-export type AdverbVerb = {
+export type Verb = {
   preAdverbs: ReadonlyArray<Adverb>;
   verb: Word;
   postAdverb: null | Adverb;
 };
-export type Verb = Readonly<{
-  modal: null | AdverbVerb;
-  verbs: ReadonlyArray<AdverbVerb>;
+export type WholeVerb = Readonly<{
+  modal: null | Verb;
+  verbs: ReadonlyArray<Verb>;
 }>;
 export type VerbPhrase =
   | Readonly<{
     type: "simple";
-    verb: Verb;
+    verb: WholeVerb;
     subjectComplement: null | Complement;
     contentClause: null | Clause;
     object: null | NounPhrase;

src/translator/composer.ts

@@ -71,7 +71,7 @@ function complement(complement: English.Complement) {
       return adjective(complement.adjective, 0);
   }
 }
-function adverbVerb(verbAdverb: English.AdverbVerb) {
+function singeVerb(verbAdverb: English.Verb) {
   const { preAdverbs, verb, postAdverb } = verbAdverb;
   const verbPost = verb.word === "can" && postAdverb != null &&
       postAdverb.adverb.word === "not"
@@ -95,7 +95,7 @@ export function verb(phrase: English.VerbPhrase, depth: number): string {
           ...nullableAsArray(modal),
           ...verbs,
         ]
-          .map(adverbVerb)
+          .map(singeVerb)
         : [];
       text = [
         ...verbText,

src/translator/fixer.ts

@@ -181,16 +181,16 @@ function fixComplement(complement: English.Complement): English.Complement {
       };
   }
 }
-function fixAdverbVerb(adverbVerb: English.AdverbVerb): English.AdverbVerb {
+function fixSingleVerb(adverbVerb: English.Verb): English.Verb {
   return {
     ...adverbVerb,
     preAdverbs: fixMultipleAdverbs(adverbVerb.preAdverbs),
   };
 }
-function fixVerb(verb: English.Verb): English.Verb {
+function fixVerb(verb: English.WholeVerb): English.WholeVerb {
   return {
-    modal: mapNullable(verb.modal, fixAdverbVerb),
-    verbs: verb.verbs.map(fixAdverbVerb),
+    modal: mapNullable(verb.modal, fixSingleVerb),
+    verbs: verb.verbs.map(fixSingleVerb),
   };
 }
 function fixVerbPhrase(verb: English.VerbPhrase): English.VerbPhrase {

src/translator/noun.ts

@@ -54,7 +54,7 @@ type NounQuantity = Readonly<{ noun: string; quantity: English.Quantity }>;
 export function fromNounForms(
   nounForms: Dictionary.NounForms,
   determinerNumber: Dictionary.Quantity,
-): IterableResult<{ noun: string; quantity: English.Quantity }> {
+): IterableResult<NounQuantity> {
   const { singular, plural } = nounForms;
   switch (determinerNumber) {
     case "singular":

src/translator/verb.ts

@@ -18,19 +18,19 @@ export type VerbForms =
     reduplicationCount: number;
     emphasis: boolean;
   }>;
-export type VerbObjects = Readonly<{
+export type VerbAccessory = Readonly<{
   object: null | English.NounPhrase;
   objectComplement: null | English.Complement;
   prepositions: ReadonlyArray<English.Preposition>;
 }>;
 export type FirstVerb =
-  | (Readonly<{ type: "modal" }> & English.AdverbVerb)
+  | (Readonly<{ type: "modal" }> & English.Verb)
   | (Readonly<{ type: "conjugated" }> & VerbForms);
 export type PartialVerb =
-  & VerbObjects
+  & VerbAccessory
   & Readonly<{
     first: FirstVerb;
-    rest: ReadonlyArray<English.AdverbVerb>;
+    rest: ReadonlyArray<English.Verb>;
     subjectComplement: null | English.Complement;
     forObject: boolean | string;
     predicateType: null | "verb" | "noun adjective";
@@ -44,7 +44,7 @@ export type PartialCompoundVerb =
       conjunction: string;
       verbs: ReadonlyArray<PartialCompoundVerb>;
     }>
-    & VerbObjects
+    & VerbAccessory
   );
 function condenseVerb(present: string, past: string) {
   const [first, ...rest] = present.split(" ");
@@ -65,7 +65,7 @@ function addModal(
       throw new FilteredError("nested modal verb");
     case "conjugated": {
       const newRest = nullableAsArray(first)
-        .map((first): English.AdverbVerb => {
+        .map((first): English.Verb => {
           const { adverbs, presentPlural, negated } = first;
           const useVerb = presentPlural === "are" ? "be" : presentPlural;
           const preAdverbs = takeNegative ? adverbs : [
@@ -189,7 +189,7 @@ function fromVerbForms(
   verbForms: VerbForms,
   perspective: Dictionary.Perspective,
   quantity: English.Quantity,
-): IterableResult<English.Verb> {
+): IterableResult<English.WholeVerb> {
   const { negated, adverbs } = verbForms;
   const is = verbForms.presentSingular === "is";
   const presentSingular = is && perspective === "first"
@@ -203,8 +203,8 @@ function fromVerbForms(
       ? [pastPlural, verbForms.presentPlural, "do"]
       : [pastSingular, presentSingular, "does"];
   type Result = Readonly<{
-    modal: null | English.AdverbVerb;
-    doesNot: null | English.AdverbVerb;
+    modal: null | English.Verb;
+    doesNot: null | English.Verb;
     verb: string;
     postAdverb: null | English.Adverb;
   }>;
@@ -344,7 +344,9 @@ function fromVerbForms(
       }
       break;
   }
-  return result.map(({ modal, doesNot, verb, postAdverb }): English.Verb => ({
+  return result.map((
+    { modal, doesNot, verb, postAdverb },
+  ): English.WholeVerb => ({
     modal,
     verbs: [
       ...nullableAsArray(doesNot),
@@ -400,6 +402,6 @@ export function verb(
     }
   }
 }
-export function noAdverbs(verb: English.Word): English.AdverbVerb {
+export function noAdverbs(verb: English.Word): English.Verb {
   return { preAdverbs: [], verb, postAdverb: null };
 }