fix some stuff

src/char.js

@@ -1,8 +1,8 @@
 import { State } from './state.js'
-import { anyOf } from './combinator.js'
+import { anyOf, map } from './combinator.js'
 import { Alpha, Alphanumeric, Digits, LowerAlpha, UpperAlpha } from './const.js'
 import { fail, join, mapStr, next, succeed } from './fn.js'
-import { map, seq } from './seq.js'
+import { seq } from './seq.js'
 import { curry } from '../vendor/izuna/src/curry.js'
 
 /** @import { ParserState } from './state.js' */
@@ -12,12 +12,9 @@ export const char = curry(
    * @param {string} ch
    * @param {ParserState} state
    */
-  //(ch, state) => (
-  //  next(state) === ch ? succeed(ch, state) : fail(`could not parse ${ch} `, state)
-  //))
-  (ch, state) => {
-    return next(state) === ch ? succeed(ch, state) : fail(`could not parse ${ch} `, state)
-  })
+  (ch, state) => (
+    next(state) === ch ? succeed(ch, state) : fail(`could not parse ${ch} `, state)
+  ))
 
 export const str = curry(
   /**

src/combinator.js

@@ -1,5 +1,5 @@
 import { char } from './char.js'
-import { fail, fork, mapStr } from './fn.js'
+import { diff, fail, fork, mapStr, succeed, Tuple } from './fn.js'
 import { curry } from '../vendor/izuna/src/curry.js'
 
 /** @import { ParserState } from './state.js' */

src/cond.js

@@ -19,12 +19,13 @@ export const maybe = curry(
   })
 
 export const not = curry((parser, state) => {
-  const result = parser(state)
+  const [original, clone] = fork(state)
+  const result = parser(clone)
 
   if (result.isOk()) {
-    return fail('"not" parser failed', state)
+    return fail('"not" parser failed', original)
   } else {
-    return succeed([], state)
+    return succeed([], original)
   }
 })
 

src/seq.js

@@ -51,34 +51,13 @@ export const seq = (...parsers) =>
     return acc
   }
 
-export const map = curry(
-  /** 
-   * @param {(...args: any[]) => any} fn
-   * @param {Parser} parser
-   * @param {ParserState} state
-   */
-  (fn, parser, state) => {
-    return parser(state).chain(result => {
-      try {
-        /** @type {Result<ParserState, ParseError>} */
-        const parsed = fn(diff(state[0], result[0]))
-        const backtrack = Tuple(state[0], result[1])
-
-
-        return succeed(parsed, backtrack)
-      } catch (e) {
-        return fail('failed to map', state, e)
-      }
-    })
-  })
-
 
 export const many = curry((parser, state) => {
   let result = ok(state)
 
   while (true) {
-    const [a, b] = fork(state)
-    const res = parser(clone(result.unwrap()))
+    const [original, clone] = result.chain(fork)
+    const res = parser(clone)
     if (res.isOk()) {
       result = res
     } else {