From 0cc4e48c848aef5751573628e4af6e194b272d1d Mon Sep 17 00:00:00 2001 From: Akshay Nair Date: Thu, 6 Jan 2022 21:53:27 +0530 Subject: feat: more parser + Expr type --- src/index.ts | 101 +++++++++++++++++++++++++++------------------------------- src/parser.ts | 94 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 141 insertions(+), 54 deletions(-) create mode 100644 src/parser.ts (limited to 'src') diff --git a/src/index.ts b/src/index.ts index a9b3409..3dc572b 100644 --- a/src/index.ts +++ b/src/index.ts @@ -1,55 +1,48 @@ -import { flow, identity, pipe } from 'fp-ts/function' -import { Either, left, right, map, chain, mapLeft, fold, orElse } from 'fp-ts/Either' - -type char = string - -type ParserResult = [T, string] -type ParserError = [string, string] -type Parser = (input: string) => Either> - -export const many0 = (parser: Parser): Parser> => flow( - parser, - chain(([a, nextInput]) => - pipe( - nextInput, - many0(parser), - map(([ls, inp]): ParserResult => [[a, ...ls], inp]), - ) - ), - orElse(([_, inp]) => right([[] as T[], inp])) -) - -export const many1 = (parser: Parser): Parser> => flow( - many0(parser), - chain(([res, inp]) => - res.length > 0 ? right([res, inp]) : left([`many1 failed to parse at ${inp}`, inp])) -) - -export const satify_char = (f: (c: char) => boolean): Parser => (input: string) => { - const c = input.charAt(0) - if (f(c)) return right([c, input.slice(1)]) - return left([`Expected to satisfy ${f}, got "${c}"`, input]) -}; - -export const digit = satify_char(c => /^[0-9]$/g.test(c)) - -export const integer: Parser = flow( - many1(digit), - map(([ds, input]) => [parseInt(ds.join(''), 10), input]) -) - -export const or = (parsers: Parser[]): Parser => { - const ppp = ([p, ...ps]: Parser[]) => flow( - p, - orElse(([_, inp]) => or(ps)(inp)) - ) - - return parsers.length > 0 ? ppp(parsers) : (inp: string) => left(['unable to match', inp]) -} - -export const space = satify_char(c => c === ' ') -export const newline = satify_char(c => c === '\n') -export const tab = satify_char(c => c === '\t') - -export const whitespace = or([space, newline, tab]) +import { constant, flow, identity, pipe } from 'fp-ts/function' +import {mapTo, symbol} from './parser' + +export const start = mapTo(symbol('^'), constant({ tag: 'Start' } as Expr)) +export const end = mapTo(symbol('$'), constant({ tag: 'End' } as Expr)) +export const anyItem = mapTo(symbol(','), constant({ tag: 'AnyItem' } as Expr)) +export const nextItem = mapTo(symbol(','), constant({ tag: 'NextItem' } as Expr)) +// export const optional = mapTo(symbol('?'), constant({ tag: 'Optional' } as Expr)) +// export const zeroOrMore = mapTo(symbol('*'), constant({ tag: 'ZeroOrMore' } as Expr)) +// export const oneOrMore = mapTo(symbol('+'), constant({ tag: 'OneOrMore' } as Expr)) + +type Expr = + | { tag: 'Start' } + | { tag: 'End' } + | { tag: 'Optional' } + | { tag: 'OneOrMore' } + | { tag: 'ZeroOrMore' } + | { tag: 'NextItem' } + | { tag: 'AnyItem' } + | { tag: 'Or' } + | { tag: 'String' } + | { tag: 'Number' } + | { tag: 'Bool' } + | { tag: 'Truthy' } + | { tag: 'Falsey' } + +/* + +^ $ => start and end of list +? => optional +. => any item +* => 0 or more instances ++ => 1 or more instances +{3,6} => 3 to 6 instances +\s => string +\n => number +\b => boolean +\T => truthy +\F => falsey +(> 5) => number greater than +(< 5) => number less than +, => followed by +[name x] => apply x on property `name` +| => or +/x/ => match regular expression (string values in list) + +*/ diff --git a/src/parser.ts b/src/parser.ts new file mode 100644 index 0000000..076e0c5 --- /dev/null +++ b/src/parser.ts @@ -0,0 +1,94 @@ +import { flow, pipe } from 'fp-ts/function' +import { Either, left, right, map, chain, orElse } from 'fp-ts/Either' + +export type char = string + +export type ParserResult = [T, string] +export type ParserError = [string, string] +export type Parser = (input: string) => Either> + +export const constP = (v: T): Parser => (inp: string) => right([v, inp]) + +export const many0 = (parser: Parser): Parser> => flow( + parser, + chain(([a, nextInput]) => + pipe( + nextInput, + many0(parser), + map(([ls, inp]): ParserResult => [[a, ...ls], inp]), + ) + ), + orElse(([_, inp]) => right([[] as T[], inp])) +) + +export const many1 = (parser: Parser): Parser> => flow( + many0(parser), + chain(([res, inp]) => + res.length > 0 ? right([res, inp]) : left([`many1 failed to parse at ${inp}`, inp])) +) + +export const prefixed = (a: Parser, b: Parser): Parser => flow( + a, + chain(([_, inp]) => b(inp)) +) + +export const suffixed = (a: Parser, b: Parser): Parser => flow( + a, + chain(([out, inp]) => pipe(inp, + b, + chain(([_, inp2]) => right([out, inp2])) + )) +) + +export const delimited = (p: Parser, a: Parser, s: Parser): Parser => + suffixed(prefixed(p, a), s) + +export const satifyChar = (f: (c: char) => boolean): Parser => (input: string) => { + const c = input.charAt(0) + if (f(c)) return right([c, input.slice(1)]) + return left([`Expected to satisfy ${f}, got "${c}"`, input]) +} + +export const digit = satifyChar(c => /^[0-9]$/g.test(c)) + +export const integer: Parser = flow( + many1(digit), + map(([ds, input]) => [parseInt(ds.join(''), 10), input]) +) + +export const or = (parsers: Parser[]): Parser => { + const ppp = ([p, ...ps]: Parser[]) => flow( + p, + orElse(([_, inp]) => or(ps)(inp)) + ) + + return parsers.length > 0 ? ppp(parsers) : (inp: string) => left(['unable to match', inp]) +} + +export const matchChar = (ch: char): Parser => satifyChar(c => c === ch) + +export const space = matchChar(' ') +export const newline = matchChar('\n') +export const tab = matchChar('\t') + +export const whitespace = or([space, newline, tab]) +export const whitespaces0 = many0(whitespace) + +export const matchString = (s: string): Parser => + s === '' ? constP('') : flow( + matchChar(s.charAt(0)), + chain(([c, inp]) => pipe( + inp, + matchString(s.slice(1)), + map(([s, inp]) => [c + s, inp]), + )) + ) + +export const symbol = (s: string): Parser => + delimited(whitespaces0, matchString(s), whitespaces0) + +export const mapTo = (p: Parser, f: (p: I) => R): Parser => flow( + p, + map(([v, inp]) => [f(v), inp]) +) + -- cgit v1.3.1