Implement packrat parsing

src/cache.ts

@@ -0,0 +1,39 @@
+type Function_ = (...x: never[]) => unknown;
+
+type Memoize<F extends Function_> = {
+  (...x: Parameters<F>): ReturnType<F>;
+  clearCache: () => void;
+};
+
+const memoizedFunctions: Memoize<Function_>[] = [];
+
+export const memoize = <F extends Function_>(
+  fn: F,
+) => {
+  const cache = new Map<string, unknown>();
+
+  const memoizedFunction = ((...x: never[]) => {
+    const hash = JSON.stringify(x);
+    if (cache.has(hash)) {
+      return cache.get(hash);
+    } else {
+      return fn(...x);
+    }
+  }) as F;
+
+  const memoizedCallableObject = Object.assign(memoizedFunction, {
+    clearCache: () => {
+      cache.clear();
+    }
+  });
+
+  memoizedFunctions.push(memoizedCallableObject);
+
+  return memoizedCallableObject;
+};
+
+export const clearCache = () => {
+  memoizedFunctions.forEach(memoizedFunction => {
+    memoizedFunction.clearCache();
+  });
+}

src/parser.ts

@@ -1,5 +1,6 @@
 import { encoder } from './unicode';
 import { InputType, InputTypes, isTypedArray } from './inputTypes';
+import { clearCache, memoize } from './cache';
 
 // createParserState :: x -> s -> ParserState e a s
 const createParserState = <D>(target: InputType, data: D | null = null): ParserState<null, string | null, D | null> => {
@@ -90,13 +91,15 @@ export class Parser<T, E = string, D = any> {
   p: StateTransformerFunction<T, E, D>;
 
   constructor(p: StateTransformerFunction<T, E, D>) {
-    this.p = p;
+    this.p = memoize(p);
   }
 
   // run :: Parser e a s ~> x -> Either e a
   run(target: InputType): ResultType<T, E, D> {
     const state = createParserState(target);
 
+    clearCache();
+
     const resultState = this.p(state);
 
     if (resultState.isError) {
@@ -123,6 +126,8 @@ export class Parser<T, E = string, D = any> {
     const state = createParserState(target);
     const newState = this.p(state);
 
+    clearCache();
+
     if (newState.isError) {
       return errorFn(newState.error, newState);
     }