1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
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> = [T, string]
export type ParserError = [string, string]
export type Parser<T> = (input: string) => Either<ParserError, ParserResult<T>>
export const constP =
<T>(v: T): Parser<T> =>
(inp: string) =>
right([v, inp])
export const many0 = <T>(parser: Parser<T>): Parser<Array<T>> =>
flow(
parser,
chain(([a, nextInput]) =>
pipe(
nextInput,
many0(parser),
map(([ls, inp]): ParserResult<T[]> => [[a, ...ls], inp])
)
),
orElse(([_, inp]) => right([[] as T[], inp]))
)
export const many1 = <T>(parser: Parser<T>): Parser<Array<T>> =>
flow(
many0(parser),
chain(([res, inp]) =>
res.length > 0
? right([res, inp])
: left([`many1 failed to parse at ${inp}`, inp])
)
)
export const prefixed = <T>(a: Parser<any>, b: Parser<T>): Parser<T> =>
flow(
a,
chain(([_, inp]) => b(inp))
)
export const suffixed = <T>(a: Parser<T>, b: Parser<any>): Parser<T> =>
flow(
a,
chain(([out, inp]) =>
pipe(
inp,
b,
chain(([_, inp2]) => right([out, inp2]))
)
)
)
export const delimited = <T>(
p: Parser<any>,
a: Parser<T>,
s: Parser<any>
): Parser<T> => suffixed(prefixed(p, a), s)
export const satifyChar =
(f: (c: char) => boolean): Parser<char> =>
(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<number> = flow(
many1(digit),
map(([ds, input]) => [parseInt(ds.join(''), 10), input])
)
export const or = <T>(parsers: Parser<T>[]): Parser<T> => {
const ppp = ([p, ...ps]: Parser<T>[]) =>
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<char> => 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<string> =>
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<string> =>
delimited(whitespaces0, matchString(s), whitespaces0)
export const mapTo = <I, R>(p: Parser<I>, f: (p: I) => R): Parser<R> =>
flow(
p,
map(([v, inp]) => [f(v), inp])
)
|
