Support bind and bindTo for Parser monad

CHANGELOG.md

@@ -13,6 +13,11 @@
 **Note**: Gaps between patch versions are faulty/broken releases. **Note**: A feature tagged as Experimental is in a
 high state of flux, you're at risk of it changing without notice.
 
+# 0.6.8
+
+- **New Feature**
+  - Add "do notation" to `Parser` monad (@CYBAI)
+
 # 0.6.7
 
 - **New Feature**

docs/modules/Parser.ts.md

@@ -65,6 +65,9 @@ Added in v0.6.0
   - [parser](#parser)
 - [model](#model)
   - [Parser (interface)](#parser-interface)
+- [utils](#utils)
+  - [bind](#bind)
+  - [bindTo](#bindto)
 
 ---
 
@@ -637,3 +640,28 @@ export interface Parser<I, A> {
 ```
 
 Added in v0.6.0
+
+# utils
+
+## bind
+
+**Signature**
+
+```ts
+export declare const bind: <N extends string, I, A, B>(
+  name: Exclude<N, keyof A>,
+  f: (a: A) => Parser<I, B>
+) => (fa: Parser<I, A>) => Parser<I, { [K in N | keyof A]: K extends keyof A ? A[K] : B }>
+```
+
+Added in v0.6.8
+
+## bindTo
+
+**Signature**
+
+```ts
+export declare const bindTo: <N extends string>(name: N) => <I, A>(fa: Parser<I, A>) => Parser<I, { [K in N]: A }>
+```
+
+Added in v0.6.8

examples/command.ts

@@ -33,7 +33,6 @@
  * For example, one could generalize the parser exemplified below to accept any command. Then, the
  * structure of the parsed AST for specific commands can be enforced using instances of `io-ts` `Schema`s.
  */
-import { Do } from 'fp-ts-contrib/lib/Do'
 import * as A from 'fp-ts/lib/Array'
 import { mapLeft, Either } from 'fp-ts/lib/Either'
 import { getStructMonoid, Monoid } from 'fp-ts/lib/Monoid'
@@ -173,10 +172,11 @@ const positional: P.Parser<string, Positional> = pipe(C.many1(C.notSpace), P.map
 const argument = P.either<string, Argument>(flag, () => P.either<string, Argument>(named, () => positional))
 
 const statement = (cmd: string) =>
-  Do(P.parser)
-    .bind('command', whitespaceSurrounded(S.string(cmd)))
-    .bind('args', P.many(whitespaceSurrounded(argument)))
-    .done()
+  pipe(
+    whitespaceSurrounded(S.string(cmd)),
+    P.bindTo('command'),
+    P.bind('args', () => P.many(whitespaceSurrounded(argument)))
+  )
 
 const ast = (command: string, source: string): P.Parser<string, Ast> => {
   return pipe(

package.json

@@ -43,7 +43,6 @@
     "docs-ts": "^0.5.1",
     "dtslint": "^0.4.2",
     "fp-ts": "^2.0.0",
-    "fp-ts-contrib": "^0.1.17",
     "import-path-rewrite": "github:gcanti/import-path-rewrite",
     "jest": "^24.8.0",
     "mocha": "^5.2.0",

src/Parser.ts

@@ -577,3 +577,41 @@ export const parser: Monad2<URI> & Alternative2<URI> = {
   alt: alt_,
   zero: fail
 }
+
+// -------------------------------------------------------------------------------------
+// do notation
+// -------------------------------------------------------------------------------------
+
+/**
+ * @internal
+ */
+const bind_ = <A, N extends string, B>(
+  a: A,
+  name: Exclude<N, keyof A>,
+  b: B
+): { [K in keyof A | N]: K extends keyof A ? A[K] : B } => Object.assign({}, a, { [name]: b }) as any
+
+/**
+ * @since 0.6.8
+ */
+export const bindTo = <N extends string>(name: N) => <I, A>(fa: Parser<I, A>): Parser<I, { [K in N]: A }> =>
+  pipe(
+    fa,
+    map(a => bind_({}, name, a))
+  )
+
+/**
+ * @since 0.6.8
+ */
+export const bind = <N extends string, I, A, B>(name: Exclude<N, keyof A>, f: (a: A) => Parser<I, B>) => (
+  fa: Parser<I, A>
+): Parser<I, { [K in keyof A | N]: K extends keyof A ? A[K] : B }> =>
+  pipe(
+    fa,
+    chain(a =>
+      pipe(
+        f(a),
+        map(b => bind_(a, name, b))
+      )
+    )
+  )

test/Parser.ts

@@ -3,6 +3,7 @@ import { char as C, parser as P, string as S } from '../src'
 import { error, success } from '../src/ParseResult'
 import { stream } from '../src/Stream'
 import { run } from './helpers'
+import { pipe } from 'fp-ts/lib/pipeable'
 
 describe('Parser', () => {
   it('eof', () => {
@@ -120,4 +121,25 @@ describe('Parser', () => {
     assert.deepStrictEqual(run(parser, 'ab'), success(['a', 'b'], stream(['a', 'b'], 2), stream(['a', 'b'])))
     assert.deepStrictEqual(run(parser, 'abc'), success(['a', 'b'], stream(['a', 'b', 'c'], 2), stream(['a', 'b', 'c'])))
   })
+
+  it('bind', () => {
+    const parser = pipe(
+      C.char('a'),
+      P.bindTo('a'),
+      P.bind('b', () => C.char('b')),
+      P.map(({ a, b }) => [a, b])
+    )
+    assert.deepStrictEqual(run(parser, 'ab'), success(['a', 'b'], stream(['a', 'b'], 2), stream(['a', 'b'])))
+    assert.deepStrictEqual(run(parser, 'bc'), error(stream(['b', 'c'], 0), ['"a"']))
+  })
+
+  it('bindTo', () => {
+    const parser = pipe(
+      C.char('a'),
+      P.bindTo('headingA'),
+      P.map(({ headingA }) => [headingA])
+    )
+    assert.deepStrictEqual(run(parser, 'ab'), success(['a'], stream(['a', 'b'], 1), stream(['a', 'b'])))
+    assert.deepStrictEqual(run(parser, 'bc'), error(stream(['b', 'c'], 0), ['"a"']))
+  })
 })