# yaparsec

> parser combinator for typescript

Latest version **2.0.0** (published 2018-01-12) · MIT license · 0 weekly downloads

## Install

```sh
npm install yaparsec
pnpm add yaparsec
yarn add yaparsec
bun add yaparsec
```

## Health

**Score 25/100 (F)** — status: abandoned.

Positive: has types; no vulnerabilities; high quality score.

Warnings: low downloads; no esm support.

Negative: abandoned; low maintenance score.

## Facts

| | |
|---|---|
| Version | 2.0.0 |
| Published | 2018-01-12 |
| First published | 2017-07-28 |
| Weekly downloads | 0 |
| License | MIT |
| TypeScript types | bundled |
| Module format | CommonJS |
| Dependencies | 0 |
| Known vulnerabilities | 0 |
| Install scripts | no |
| GitHub stars | 0 |
| Author | henoc |
| Maintainers | henoc |

## Links

- npm: https://www.npmjs.com/package/yaparsec
- Repository: https://github.com/Henoc/yaparsec
- Homepage: https://github.com/Henoc/yaparsec#readme
- Issues: https://github.com/Henoc/yaparsec/issues
- npm.io page: https://npm.io/package/yaparsec

## Recent versions

- 2.0.0 (latest) — 2018-01-12
- 1.1.0 — 2017-11-15
- 1.0.5 — 2017-11-13
- 1.0.4 — 2017-11-12
- 1.0.3 — 2017-11-12
- 1.0.2 — 2017-11-12
- 1.0.1 — 2017-11-12
- 1.0.0 — 2017-11-12
- 0.1.0 — 2017-07-28

## README

# yaparsec

Yet another parser combinator.  
The class structure is referenced by [scala-parser-combinators](https://github.com/scala/scala-parser-combinators).

## Installing

```bash
npm install yaparsec
```

## Useage

typescript:  

```typescript
import { literal } from "yaparsec";

// literal parsing
const abcParser = literal("abc");
const parsedResult = abcParser.parse("abcdefg"); // input: "abcdefg"
console.log(parsedResult); // Success { rest: 'defg', result: 'abc' }
```

Implemented functions are based on PEG (Parsing Expression Grammar). You can find more examples in test files.

## Operators

`p, q: Parser`  

| function | description |
|:---------|:------------|
|p.parse(input)|take input for parser `p`|
|p.map(fn)|map the parse result of `p` with `fn`|
|p.then(q)|sequence parser|
|p.or(q)|ordered choice parser (try `q` only if `p` fails)|
|p.rep()|`p*`|
|p.rep1()|`p+`|
|p.rep1sep(q)|`p(qp)*`|
|p.opt()|`p?`|
|p.not()|success if input does **not** start with `p`|
|p.guard()|success if input starts with `p`, without consuming input|
|p.saveR(q)|same as sequence, but discard left result (~>)|
|p.saveL(q)|same as sequence, but discard right result (<~)|
|p.into(fq)|2nd parser depends on the result of the 1st parser (>>)|
|seq(...ps)|sequence parser that has many sub parsers|
|lt(str)|parse specified string `str`|
|r(regexp)|parse any string match `regexp`|
|decimal|decimal number parser|
|integer|integer number parser|
|email|email parser|

## Parser

Type of parsers is `Parser<T>`, `T` means the result type of parsing.

## Input

Input type is string or `Input`. You can manage regex as whitespace when useing `Input`.  If string, the default regex `/^\s+/` is selected.

```typescript
// Space or `,` char sequence is treated as whitespace
someparser.of(new Input(inputString, /^[\s,]+/));
```

## Result

Parse result type is `Success<T>` or `Failure<T>`, `T` is the content type. `Success<T>` has two contents, parse result and rest input. You can get the parse result to use `getResult()` in `Success<T>`. If fail, `Failure<T>` has three contents, rest input, error message and the parser name. There are in order to determine the cause of errors.

## Recursion

Arguments that require another parsers can all be lazy, so you can use right recursion.

```typescript
// a*b parser
const aStarB: Parser<string> = literal("b").or((literal("a").then(() => aStarB).map(ret => ret[0] + ret[1]));
```

## License

Yaparsec is available under the MIT license.

---
_Source: https://npm.io/package/yaparsec · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._