perf: improve performance by simplifying values passed around

- Got noticeable gains by getting rid of 'state' object and constantly copying input string. - Got rid of helper functions which were causing overhead and unnecessary pressure.
norskeld · May 13, 2022 · 505dad8 · 505dad8 · vercel · May 13, 2022
1 parent 4eb856d
commit 505dad8
Show file tree

Hide file tree

Showing 43 changed files with 254 additions and 252 deletions.
diff --git a/src/combinators/chain.ts b/src/combinators/chain.ts
@@ -1,4 +1,4 @@
-import type { Parser } from '../state'
+import { type Parser } from '../state'
 
 import { sequence } from './sequence'
 import { many } from './many'

diff --git a/src/combinators/choice.ts b/src/combinators/choice.ts
@@ -3,19 +3,19 @@ import type { Parser, Result, ToUnion } from '../state'
 export function choice<T extends Array<Parser<unknown>>>(...ps: T): Parser<ToUnion<T>>
 export function choice<T>(...ps: Array<Parser<T>>): Parser<T> {
   return {
-    parse(state) {
+    parse(input, pos) {
       let nextResult: Result<T> | null = null
 
       for (const parser of ps) {
-        const result = parser.parse(state)
+        const result = parser.parse(input, pos)
 
-        switch (result.kind) {
-          case 'success': {
+        switch (result.isOk) {
+          case true: {
             return result
           }
 
-          case 'failure': {
-            if (!nextResult || nextResult.state.index < result.state.index) {
+          case false: {
+            if (!nextResult || nextResult.pos < result.pos) {
               nextResult = result
             }
           }

diff --git a/src/combinators/error.ts b/src/combinators/error.ts
@@ -1,17 +1,21 @@
-import { failure, type Parser } from '../state'
+import { type Parser } from '../state'
 
 export function error<T>(parser: Parser<T>, expected: string): Parser<T> {
   return {
-    parse(state) {
-      const result = parser.parse(state)
+    parse(input, pos) {
+      const result = parser.parse(input, pos)
 
-      switch (result.kind) {
-        case 'success': {
+      switch (result.isOk) {
+        case true: {
           return result
         }
 
-        case 'failure': {
-          return failure(state, expected)
+        case false: {
+          return {
+            isOk: false,
+            pos,
+            error: expected
+          }
         }
       }
     }

diff --git a/src/combinators/many.ts b/src/combinators/many.ts
@@ -1,23 +1,28 @@
-import { success, type Parser } from '../state'
+import { type Parser } from '../state'
 
 export function many<T>(parser: Parser<T>): Parser<Array<T>> {
   return {
-    parse(state) {
-      let values: Array<T> = []
-      let nextState = state
+    parse(input, pos) {
+      const values: Array<T> = []
+      let nextPos = pos
 
       while (true) {
-        const result = parser.parse(nextState)
+        const result = parser.parse(input, nextPos)
 
-        switch (result.kind) {
-          case 'success': {
-            values = [...values, result.value]
-            nextState = result.state
+        switch (result.isOk) {
+          case true: {
+            values.push(result.value)
+            nextPos = result.pos
             break
           }
 
-          case 'failure': {
-            return success(nextState, values)
+          case false: {
+            return {
+              isOk: true,
+              pos: nextPos,
+              input,
+              value: values
+            }
           }
         }
       }

diff --git a/src/combinators/map.ts b/src/combinators/map.ts
@@ -1,16 +1,20 @@
-import { success, type Parser } from '../state'
+import { type Parser } from '../state'
 
 export function map<T, R>(parser: Parser<T>, fn: (value: T) => R): Parser<R> {
   return {
-    parse(state) {
-      const result = parser.parse(state)
+    parse(input, pos) {
+      const result = parser.parse(input, pos)
 
-      switch (result.kind) {
-        case 'success': {
-          return success(result.state, fn(result.value))
+      switch (result.isOk) {
+        case true: {
+          return {
+            isOk: true,
+            pos: result.pos,
+            value: fn(result.value)
+          }
         }
 
-        case 'failure': {
+        case false: {
           return result
         }
       }

diff --git a/src/combinators/optional.ts b/src/combinators/optional.ts
@@ -1,4 +1,4 @@
-import type { Parser } from '../state'
+import { type Parser } from '../state'
 
 import { nothing } from '../parsers/nothing'
 import { choice } from './choice'

diff --git a/src/combinators/sepBy.ts b/src/combinators/sepBy.ts
@@ -1,4 +1,4 @@
-import type { Parser } from '../state'
+import { type Parser } from '../state'
 
 import { sequence } from './sequence'
 import { many } from './many'

diff --git a/src/combinators/sequence.ts b/src/combinators/sequence.ts
@@ -1,29 +1,33 @@
-import { success, type Parser, type ToTuple } from '../state'
+import type { Parser, ToTuple } from '../state'
 
 export function sequence<T extends Array<Parser<unknown>>>(...ps: T): Parser<ToTuple<T>>
 export function sequence<T>(...ps: Array<Parser<T>>): Parser<Array<T>> {
   return {
-    parse(state) {
-      let values: Array<T> = []
-      let nextState = state
+    parse(input, pos) {
+      const values: Array<T> = []
+      let nextPos = pos
 
       for (const parser of ps) {
-        const result = parser.parse(nextState)
+        const result = parser.parse(input, nextPos)
 
-        switch (result.kind) {
-          case 'success': {
-            values = [...values, result.value]
-            nextState = result.state
+        switch (result.isOk) {
+          case true: {
+            values.push(result.value)
+            nextPos = result.pos
             break
           }
 
-          case 'failure': {
+          case false: {
             return result
           }
         }
       }
 
-      return success(nextState, values)
+      return {
+        isOk: true,
+        pos: nextPos,
+        value: values
+      }
     }
   }
 }
diff --git a/src/combinators/take.ts b/src/combinators/take.ts
@@ -1,4 +1,4 @@
-import type { Parser } from '../state'
+import { type Parser } from '../state'
 
 import { sequence } from './sequence'
 import { map } from './map'

diff --git a/src/parsers/defer.ts b/src/parsers/defer.ts
@@ -1,4 +1,4 @@
-import { failure, type Parser } from '../state'
+import { type Parser } from '../state'
 
 interface Deferred<T> extends Parser<T> {
   with(parser: Parser<T>): void
@@ -12,12 +12,16 @@ export function defer<T>(): Deferred<T> {
       deferred = parser
     },
 
-    parse(state) {
+    parse(input, pos) {
       if (deferred) {
-        return deferred.parse(state)
+        return deferred.parse(input, pos)
       }
 
-      return failure(state, `Deferred parser wasn't initialized.`)
+      return {
+        isOk: false,
+        pos,
+        error: `Deferred parser wasn't initialized.`
+      }
     }
   }
 }
diff --git a/src/parsers/eof.ts b/src/parsers/eof.ts
@@ -1,17 +1,25 @@
-import { success, failure, type Parser } from '../state'
+import { type Parser } from '../state'
 
 export function eof(): Parser<null> {
   return {
-    parse(state) {
-      const isEof = state.index === state.text.length
+    parse(input, pos) {
+      const isEof = pos === input.length
 
       switch (isEof) {
         case true: {
-          return success({ text: state.text, index: state.text.length }, null)
+          return {
+            isOk: true,
+            pos: input.length,
+            value: null
+          }
         }
 
         case false: {
-          return failure(state, 'end of input')
+          return {
+            isOk: false,
+            pos,
+            error: 'end of input'
+          }
         }
       }
     }

diff --git a/src/parsers/float.ts b/src/parsers/float.ts
@@ -1,20 +1,25 @@
-import { success, type Parser } from '../state'
+import { type Parser } from '../state'
 
 import { regexp } from './regexp'
 
 const FLOAT_RE = /-?\d+\.\d+/g
 
 export function float(): Parser<number> {
   return {
-    parse(state) {
-      const result = regexp(FLOAT_RE, 'float').parse(state)
+    parse(input, pos) {
+      const result = regexp(FLOAT_RE, 'float').parse(input, pos)
 
-      switch (result.kind) {
-        case 'success': {
-          return success(result.state, parseFloat(result.value))
+      switch (result.isOk) {
+        case true: {
+          return {
+            isOk: true,
+            input,
+            pos: result.pos,
+            value: parseFloat(result.value)
+          }
         }
 
-        case 'failure': {
+        case false: {
           return result
         }
       }

diff --git a/src/parsers/integer.ts b/src/parsers/integer.ts
@@ -1,4 +1,4 @@
-import { success, type Parser } from '../state'
+import { type Parser } from '../state'
 
 import { regexp } from './regexp'
 
@@ -7,15 +7,19 @@ const INT_UNSIGNED_RE = /\d+/g
 
 function createIntegerParser(re: RegExp, expectation: string, radix: number): Parser<number> {
   return {
-    parse(state) {
-      const result = regexp(re, expectation).parse(state)
+    parse(input, pos) {
+      const result = regexp(re, expectation).parse(input, pos)
 
-      switch (result.kind) {
-        case 'success': {
-          return success(result.state, parseInt(result.value, radix))
+      switch (result.isOk) {
+        case true: {
+          return {
+            isOk: true,
+            pos: result.pos,
+            value: parseInt(result.value, radix)
+          }
         }
 
-        case 'failure': {
+        case false: {
           return result
         }
       }

diff --git a/src/parsers/nothing.ts b/src/parsers/nothing.ts
@@ -1,9 +1,13 @@
-import { success, type Parser } from '../state'
+import { type Parser } from '../state'
 
 export function nothing(): Parser<null> {
   return {
-    parse(state) {
-      return success(state, null)
+    parse(_, pos) {
+      return {
+        isOk: true,
+        pos,
+        value: null
+      }
     }
   }
 }
diff --git a/src/parsers/regexp.ts b/src/parsers/regexp.ts
@@ -1,21 +1,29 @@
-import { success, failure, type Parser } from '../state'
+import { type Parser } from '../state'
 
 export function regexp(re: RegExp, expected: string): Parser<string> {
   return {
-    parse(state) {
+    parse(input, pos) {
       // Reset RegExp index, because we abuse the 'g' flag.
-      re.lastIndex = state.index
+      re.lastIndex = pos
 
       // `.exec` is actually a little bit faster than `.test`.
-      const result = re.exec(state.text)
+      const result = re.exec(input)
 
-      if (result && result.index === state.index) {
+      if (result && result.index === pos) {
         const [match] = result
-        const index = state.index + match.length
+        const index = pos + match.length
 
-        return success({ text: state.text, index }, match)
+        return {
+          isOk: true,
+          pos: index,
+          value: match
+        }
       } else {
-        return failure(state, expected)
+        return {
+          isOk: false,
+          pos,
+          error: expected
+        }
       }
     }
   }

diff --git a/src/parsers/rest.ts b/src/parsers/rest.ts
@@ -1,15 +1,13 @@
-import { success, type Parser } from '../state'
+import { type Parser } from '../state'
 
 export function rest(): Parser<string> {
   return {
-    parse(state) {
-      return success(
-        {
-          text: state.text,
-          index: state.text.length
-        },
-        state.text.substring(state.index)
-      )
+    parse(input, pos) {
+      return {
+        isOk: true,
+        pos: input.length,
+        value: input.substring(pos)
+      }
     }
   }
 }