remove unneeded ArrayResult.from calls

Author: neverRare

src/parser/parser_lib.ts

@@ -2,7 +2,6 @@ import { assert } from "@std/assert/assert";
 import { MemoizationCacheResult, memoize } from "@std/cache/memoize";
 import { ArrayResult, ArrayResultError } from "../array_result.ts";
 import { Clearable, ClearableCacheSet, Lazy } from "../cache.ts";
-import { throwError } from "../../misc/misc.ts";
 
 export type ValueRest<T> = Readonly<{ rest: string; value: T }>;
 export type ParserResult<T> = ArrayResult<ValueRest<T>>;
@@ -213,60 +212,54 @@ export function matchCapture(
   description: string,
 ): Parser<RegExpMatchArray> {
   const newRegex = new RegExp(`^${regex.source}`, regex.flags);
-  return new Parser((src) =>
-    ArrayResult.from(() => {
-      const match = src.match(newRegex);
-      if (match != null) {
-        return new ArrayResult([{
-          value: match,
-          rest: src.slice(match[0].length),
-        }]);
-      } else {
-        throw new UnexpectedError(describeSource(src), description);
-      }
-    })
-  );
+  return new Parser((src) => {
+    const match = src.match(newRegex);
+    if (match != null) {
+      return new ArrayResult([{
+        value: match,
+        rest: src.slice(match[0].length),
+      }]);
+    } else {
+      return new ArrayResult(
+        new UnexpectedError(describeSource(src), description),
+      );
+    }
+  });
 }
 export function match(regex: RegExp, description: string): Parser<string> {
   return matchCapture(regex, description).map(([matched]) => matched);
 }
 export function slice(length: number, description: string): Parser<string> {
   return new Parser((src) =>
-    ArrayResult.from(() =>
-      src.length >= length
-        ? new ArrayResult([{
-          rest: src.slice(length),
-          value: src.slice(0, length),
-        }])
-        : throwError(new UnexpectedError(describeSource(src), description))
-    )
+    src.length >= length
+      ? new ArrayResult([{
+        rest: src.slice(length),
+        value: src.slice(0, length),
+      }])
+      : new ArrayResult(new UnexpectedError(describeSource(src), description))
   );
 }
 export function matchString(
   match: string,
   description = `"${match}"`,
 ): Parser<string> {
   return new Parser((src) =>
-    ArrayResult.from(() =>
-      src.length >= match.length && src.slice(0, match.length) === match
-        ? new ArrayResult([{
-          rest: src.slice(match.length),
-          value: match,
-        }])
-        : throwError(new UnexpectedError(describeSource(src), description))
-    )
+    src.length >= match.length && src.slice(0, match.length) === match
+      ? new ArrayResult([{
+        rest: src.slice(match.length),
+        value: match,
+      }])
+      : new ArrayResult(new UnexpectedError(describeSource(src), description))
   );
 }
 export const everything = new Parser((src) =>
   new ArrayResult([{ value: src, rest: "" }])
 );
 export const character = match(/./us, "character");
 export const end = new Parser((src) =>
-  ArrayResult.from(() =>
-    src === ""
-      ? new ArrayResult([{ value: null, rest: "" }])
-      : throwError(new UnexpectedError(describeSource(src), "end of text"))
-  )
+  src === ""
+    ? new ArrayResult([{ value: null, rest: "" }])
+    : new ArrayResult(new UnexpectedError(describeSource(src), "end of text"))
 );
 export function withSource<T>(
   parser: Parser<T>,

src/translator/adjective.ts

@@ -1,6 +1,6 @@
 import * as Dictionary from "../../dictionary/type.ts";
 import { ArrayResult } from "../array_result.ts";
-import { nullableAsArray, throwError } from "../../misc/misc.ts";
+import { nullableAsArray } from "../../misc/misc.ts";
 import * as TokiPona from "../parser/ast.ts";
 import * as English from "./ast.ts";
 import { UntranslatableError } from "./error.ts";
@@ -55,27 +55,24 @@ export function compoundAdjective(
   }>,
 ): ArrayResult<English.AdjectivePhrase & { type: "compound" }> {
   const { adjectives, reduplicationCount, emphasis } = options;
-  return ArrayResult.from(() =>
-    reduplicationCount === 1
-      ? ArrayResult.combine(
-        ...adjectives
-          .map((definition) =>
-            adjective({ definition, reduplicationCount: 1, emphasis })
-          ),
-      )
-        .map((adjective) => ({
-          type: "compound",
-          conjunction: "and",
-          adjective,
-          emphasis: false,
-        }))
-      : throwError(
-        new UntranslatableError(
-          "reduplication",
-          "compound adjective",
+  if (reduplicationCount === 1) {
+    return ArrayResult.combine(
+      ...adjectives
+        .map((definition) =>
+          adjective({ definition, reduplicationCount: 1, emphasis })
         ),
-      )
-  );
+    )
+      .map((adjective) => ({
+        type: "compound",
+        conjunction: "and",
+        adjective,
+        emphasis: false,
+      }));
+  } else {
+    return new ArrayResult(
+      new UntranslatableError("reduplication", "compound adjective"),
+    );
+  }
 }
 export function rankAdjective(kind: Dictionary.AdjectiveType): number {
   return [

src/translator/number.ts

@@ -1,7 +1,7 @@
 import { sumOf } from "@std/collections/sum-of";
 import { ArrayResult } from "../array_result.ts";
 import { dictionary } from "../dictionary.ts";
-import { nullableAsArray, throwError } from "../../misc/misc.ts";
+import { nullableAsArray } from "../../misc/misc.ts";
 import { FilteredError } from "./error.ts";
 
 function singleNumber(word: string): ArrayResult<number> {
@@ -64,16 +64,16 @@ function nasinNanpaPona(number: ReadonlyArray<number>): null | number {
   }
 }
 function combineNumbers(numbers: ReadonlyArray<number>): ArrayResult<number> {
-  return ArrayResult.from(() =>
-    numbers.length === 1 || !numbers.includes(0)
-      ? ArrayResult.concat(
-        ArrayResult.from(() =>
-          new ArrayResult(nullableAsArray(nasinNanpaPona(numbers)))
-        ),
-        ArrayResult.from(() => new ArrayResult([regularNumber(numbers)])),
-      )
-      : throwError(new FilteredError('"ala" along with other numeral'))
-  );
+  if (numbers.length === 1 || !numbers.includes(0)) {
+    return ArrayResult.concat(
+      ArrayResult.from(() =>
+        new ArrayResult(nullableAsArray(nasinNanpaPona(numbers)))
+      ),
+      ArrayResult.from(() => new ArrayResult([regularNumber(numbers)])),
+    );
+  } else {
+    return new ArrayResult(new FilteredError('"ala" along with other numeral'));
+  }
 }
 export function number(number: ReadonlyArray<string>): ArrayResult<number> {
   return ArrayResult.combine(...number.map(singleNumber))

src/translator/predicate.ts

@@ -1,5 +1,5 @@
 import { ArrayResult } from "../array_result.ts";
-import { nullableAsArray, throwError } from "../../misc/misc.ts";
+import { nullableAsArray } from "../../misc/misc.ts";
 import * as TokiPona from "../parser/ast.ts";
 import { AdjectiveWithInWay } from "./adjective.ts";
 import * as English from "./ast.ts";
@@ -127,17 +127,18 @@ function associatedPredicate(
   object: null | PhraseTranslation,
   preposition: ReadonlyArray<English.Preposition>,
 ): ArrayResult<PartialCompoundVerb> {
-  return ArrayResult.from(() => {
-    const verbObject = object == null
-      ? new ArrayResult([phraseAsVerb(predicate)])
-      : object.type === "noun"
-      ? predicateVerb(predicate, object.noun)
-      : throwError(new UntranslatableError(object.type, "object"));
-    return verbObject.map((verbObject) => ({
-      ...verbObject,
-      preposition: [...verbObject.preposition, ...preposition],
-    }));
-  });
+  let verbObject: ArrayResult<PartialCompoundVerb>;
+  if (object == null) {
+    verbObject = new ArrayResult([phraseAsVerb(predicate)]);
+  } else if (object.type === "noun") {
+    verbObject = predicateVerb(predicate, object.noun);
+  } else {
+    return new ArrayResult(new UntranslatableError(object.type, "object"));
+  }
+  return verbObject.map((verbObject) => ({
+    ...verbObject,
+    preposition: [...verbObject.preposition, ...preposition],
+  }));
 }
 export function predicate(
   tokiPonaPredicate: TokiPona.Predicate,