How to use parser-ts - 10 common examples

const assertSuccess = <a>(parser: parser.Parser, input: string, expected: A) =&gt; {
  const result = parser(stream.stream(input.split('')))
  if (isRight(result)) {
    assert.deepStrictEqual(result.right.value, expected)
  } else {
    throw new Error(`${result} is not a right`)
  }
}
</a>

const identifierFirstLetter = P.sat(c => !isDigit(c) && !isPunctuation(c))

const identifierBody = P.sat(c => !isPunctuation(c))

/**
 * @since 0.4.0
 */
export const identifier: P.Parser = P.expected(
  S.fold([identifierFirstLetter, C.many(identifierBody)]),
  'an identifier'
)

const leftParens: P.Parser = S.fold([C.char('('), S.spaces])

const rightParens: P.Parser = S.fold([S.spaces, C.char(')')])

const withParens = <a>(parser: P.Parser): P.Parser =&gt; {
  return pipe(
    leftParens,
    P.apSecond(parser),
    P.apFirst(rightParens)
  )
}

const unparametrizedRef: P.Parser = pipe(
  identifier,
  P.map(name =&gt; M.ref(name))
)

/**
 * @since 0.4.0</a>

const isPunctuation = (c: string): boolean => '| =\n():,{};[]->'.indexOf(c) !== -1

const identifierFirstLetter = P.sat(c => !isDigit(c) && !isPunctuation(c))

const identifierBody = P.sat(c => !isPunctuation(c))

/**
 * @since 0.4.0
 */
export const identifier: P.Parser = P.expected(
  S.fold([identifierFirstLetter, C.many(identifierBody)]),
  'an identifier'
)

const leftParens: P.Parser = S.fold([C.char('('), S.spaces])

const rightParens: P.Parser = S.fold([S.spaces, C.char(')')])

const withParens = <a>(parser: P.Parser): P.Parser =&gt; {
  return pipe(
    leftParens,
    P.apSecond(parser),
    P.apFirst(rightParens)
  )
}

const unparametrizedRef: P.Parser = pipe(
  identifier,
  P.map(name =&gt; M.ref(name))
)
</a>

import { pipe } from 'fp-ts/lib/pipeable'
import { run } from 'parser-ts/lib/code-frame'

const isDigit = (c: string): boolean => '0123456789'.indexOf(c) !== -1

const isPunctuation = (c: string): boolean => '| =\n():,{};[]->'.indexOf(c) !== -1

const identifierFirstLetter = P.sat(c => !isDigit(c) && !isPunctuation(c))

const identifierBody = P.sat(c => !isPunctuation(c))

/**
 * @since 0.4.0
 */
export const identifier: P.Parser = P.expected(
  S.fold([identifierFirstLetter, C.many(identifierBody)]),
  'an identifier'
)

const leftParens: P.Parser = S.fold([C.char('('), S.spaces])

const rightParens: P.Parser = S.fold([S.spaces, C.char(')')])

const withParens = <a>(parser: P.Parser): P.Parser =&gt; {
  return pipe(
    leftParens,
    P.apSecond(parser),
    P.apFirst(rightParens)
  )
}

const unparametrizedRef: P.Parser = pipe(</a>

import { some } from 'fp-ts/lib/Option'
import { pipe } from 'fp-ts/lib/pipeable'
import { run } from 'parser-ts/lib/code-frame'

const isDigit = (c: string): boolean => '0123456789'.indexOf(c) !== -1

const isPunctuation = (c: string): boolean => '| =\n():,{};[]->'.indexOf(c) !== -1

const identifierFirstLetter = P.sat(c => !isDigit(c) && !isPunctuation(c))

const identifierBody = P.sat(c => !isPunctuation(c))

/**
 * @since 0.4.0
 */
export const identifier: P.Parser = P.expected(
  S.fold([identifierFirstLetter, C.many(identifierBody)]),
  'an identifier'
)

const leftParens: P.Parser = S.fold([C.char('('), S.spaces])

const rightParens: P.Parser = S.fold([S.spaces, C.char(')')])

const withParens = <a>(parser: P.Parser): P.Parser =&gt; {
  return pipe(
    leftParens,
    P.apSecond(parser),
    P.apFirst(rightParens)
  )
}
</a>

import { parser as P, string as S, char as C } from 'parser-ts'
import * as M from './model'
import { Either } from 'fp-ts/lib/Either'
import { some } from 'fp-ts/lib/Option'
import { pipe } from 'fp-ts/lib/pipeable'
import { run } from 'parser-ts/lib/code-frame'

const isDigit = (c: string): boolean => '0123456789'.indexOf(c) !== -1

const isPunctuation = (c: string): boolean => '| =\n():,{};[]->'.indexOf(c) !== -1

const identifierFirstLetter = P.sat(c => !isDigit(c) && !isPunctuation(c))

const identifierBody = P.sat(c => !isPunctuation(c))

/**
 * @since 0.4.0
 */
export const identifier: P.Parser = P.expected(
  S.fold([identifierFirstLetter, C.many(identifierBody)]),
  'an identifier'
)

const leftParens: P.Parser = S.fold([C.char('('), S.spaces])

const rightParens: P.Parser = S.fold([S.spaces, C.char(')')])

const withParens = <a>(parser: P.Parser): P.Parser =&gt; {</a>

import { parser as P, string as S, char as C } from 'parser-ts'
import * as M from './model'
import { Either } from 'fp-ts/lib/Either'
import { some } from 'fp-ts/lib/Option'
import { pipe } from 'fp-ts/lib/pipeable'
import { run } from 'parser-ts/lib/code-frame'

const isDigit = (c: string): boolean => '0123456789'.indexOf(c) !== -1

const isPunctuation = (c: string): boolean => '| =\n():,{};[]->'.indexOf(c) !== -1

const identifierFirstLetter = P.sat(c => !isDigit(c) && !isPunctuation(c))

const identifierBody = P.sat(c => !isPunctuation(c))

/**
 * @since 0.4.0
 */
export const identifier: P.Parser = P.expected(
  S.fold([identifierFirstLetter, C.many(identifierBody)]),
  'an identifier'
)

const leftParens: P.Parser = S.fold([C.char('('), S.spaces])

const rightParens: P.Parser = S.fold([S.spaces, C.char(')')])

const withParens = <a>(parser: P.Parser): P.Parser =&gt; {
  return pipe(
    leftParens,</a>

case 0:
              return M.unit
            case 1:
              return types[0]
            default:
              return M.tuple(types)
          }
        })
      )
    ),
    P.apFirst(rightParens)
  ),
  'a tuple'
)

const arrow = S.fold([S.spaces, S.string('->'), S.spaces])

/**
 * @since 0.4.0
 */
export const fun: P.Parser = P.expected(
  pipe(
    S.spaces,
    P.chain(() =>
      pipe(
        ref,
        P.alt(() => tuple),
        P.chain(domain =>
          pipe(
            arrow,
            P.apSecond(type),
            P.map(codomain => M.fun(domain, codomain))

P.map(types => M.constructor(name, types.map(type => M.member(type))))
        )
      )
    )
  )
)

/**
 * @since 0.4.0
 */
export const constructor: P.Parser = pipe(
  recordConstructor,
  P.alt(() => positionalConstructor)
)

const equal = S.fold([S.spaces, C.char('='), S.spaces])

const unconstrainedParameterDeclaration: P.Parser = pipe(
  identifier,
  P.map(name => M.parameterDeclaration(name))
)

const constrainedParameterDeclaration: P.Parser = pipe(
  S.fold([C.char('('), S.spaces]),
  P.apSecond(
    pipe(
      pair,
      P.map(({ name, type }) => M.parameterDeclaration(name, some(type))),
      P.apFirst(S.fold([S.spaces, C.char(')')]))
    )
  )
)

export const ref: P.Parser = pipe(
  identifier,
  P.chain(name =>
    pipe(
      S.spaces,
      P.apSecond(
        pipe(
          types,
          P.map(parameters => M.ref(name, parameters))
        )
      )
    )
  )
)

const comma = S.fold([S.spaces, C.char(','), S.spaces])

/**
 * @since 0.4.0
 */
export const tuple: P.Parser = P.expected(
  pipe(
    leftParens,
    P.chain(() =>
      pipe(
        P.sepBy(comma, type),
        P.map(types => {
          switch (types.length) {
            case 0:
              return M.unit
            case 1:
              return types[0]