parse.bend checks

raw source on the hub · import 0x154e0a68ef9a0223bacaacefc589cad8/parse.bend as Parse

Parser combinators over text, with positioned errors. Source: https://github.com/paymog/bend-kit/tree/main/parse

1 import

import Base

Types

type Cur source · line 10 · raw

Data

left is the length of s: loops use it as fuel. Build a Cur with start.

Cur

@s:String -> @off:U32 -> @left:Nat -> Cur

type Res source · line 14 · raw

@-A:Data -> Data

off is the char offset of the failure; want names what was expected there.

Ok
```
@-A:Data -> @v:A -> @cur:Cur -> Res<A>
```

Err

@-A:Data -> @off:U32 -> @want:String -> Res<A>

type Step source · line 19 · raw

@-A:Data -> @-F:Data -> Data

One step of rec: a finished value, or a frame that wants a child value.

Leaf

@-A:Data -> @-F:Data -> @v:A -> Step<A, F>

Open

@-A:Data -> @-F:Data -> @f:F -> Step<A, F>

Definitions

def Both source · line 24 · raw

@-A:Data -> @-B:Data -> Data

A reusable pair (a, b); A & B is not Data.

def start source · line 27 · raw

@+s:String -> Cur

def off source · line 30 · raw

@c:Cur -> U32

def fuel source · line 35 · raw

@c:Cur -> Nat

def dec source · line 40 · raw

@n:Nat -> Nat

def quote source · line 47 · raw

@s:String -> String

def satisfy.if source · line 53 · raw

@ok:Bool -> @+h:U32 -> @t:String -> @+o:U32 -> @n:Nat -> @want:String -> Res<U32>

def char source · line 71 · raw

@+w:U32 -> @c:Cur -> Res<U32>

The char w.

def lit.if source · line 80 · raw

@ok:Bool -> @+w:String -> @+s:String -> @+o:U32 -> @n:Nat -> Res<String>

def lit source · line 89 · raw

@+w:String -> @c:Cur -> Res<String>

The string w.

def eof source · line 120 · raw

@c:Cur -> Res<Unit>

def pure source · line 132 · raw

@-A:Data -> @v:A -> @c:Cur -> Res<A>

def fail source · line 135 · raw

@-A:Data -> @want:String -> @c:Cur -> Res<A>

def seq.b source · line 159 · raw

@-A:Data -> @-B:Data -> @v:A -> @r:Res<B> -> Res<Both(A, B)>

def keep.b source · line 177 · raw

@-A:Data -> @-B:Data -> @v:A -> @r:Res<B> -> Res<A>

def alt.join source · line 206 · raw

@same:Bool -> @w1:String -> @w2:String -> String

def alt.pick source · line 214 · raw

@-A:Data -> @k:Cmp -> @+o1:U32 -> @+w1:String -> @+o2:U32 -> @+w2:String -> Res<A>

The error that got further wins; at the same offset, both wants join.

def alt.e source · line 223 · raw

@-A:Data -> @+o1:U32 -> @+w1:String -> @r:Res<A> -> Res<A>

def opt.r source · line 241 · raw

@-A:Data -> @c:Cur -> @r:Res<A> -> Res<Maybe<&2, A>>

def progress.if source · line 252 · raw

@-A:Data -> @ok:Bool -> @v:A -> @c:Cur -> @+o:U32 -> Res<A>

def progress source · line 260 · raw

@-A:Data -> @+o:U32 -> @r:Res<A> -> Res<A>

A success that took no input fails, so loops end.

def cons.r source · line 282 · raw

@-A:Data -> @v:A -> @r:Res<List<&2, A>> -> Res<List<&2, A>>

def text.r source · line 300 · raw

@-A:Data -> @+s:String -> @+o:U32 -> @r:Res<A> -> Res<String>

def nil.r source · line 324 · raw

@-A:Data -> @c:Cur -> @r:Res<List<&2, A>> -> Res<List<&2, A>>

def res.off source · line 335 · raw

@-A:Data -> @r:Res<A> -> U32

Templates

template satisfy source · line 61 · raw

@-f:(@+c:U32 -> Bool) -> @want:String -> @c:Cur -> Res<U32>

One char c with f(c); the value is its code.

template take_while.go source · line 95 · raw

@-f:(@+c:U32 -> Bool) -> @t:String -> @+h:U32 -> @+o:U32 -> @n:Nat -> @acc:String -> @ok:Bool -> Res<String>

h is the next char and t the text after it; ok is f(h).

template take_while source · line 111 · raw

@-f:(@+c:U32 -> Bool) -> @c:Cur -> Res<String>

The longest run of chars with f; it can be empty.

template map.r source · line 138 · raw

@-A:Data -> @-B:Data -> @-f:(@_:A -> B) -> @r:Res<A> -> Res<B>

template map source · line 145 · raw

@-A:Data -> @-B:Data -> @-f:(@_:A -> B) -> @-p:(@_:Cur -> Res<A>) -> @c:Cur -> Res<B>

template bind.r source · line 148 · raw

@-A:Data -> @-B:Data -> @-k:(@_:A -> @_:Cur -> Res<B>) -> @r:Res<A> -> Res<B>

template bind source · line 156 · raw

@-A:Data -> @-B:Data -> @-p:(@_:Cur -> Res<A>) -> @-k:(@_:A -> @_:Cur -> Res<B>) -> @c:Cur -> Res<B>

p, then the parser k picks from p's value.

template seq.a source · line 166 · raw

@-A:Data -> @-B:Data -> @-q:(@_:Cur -> Res<B>) -> @r:Res<A> -> Res<Both(A, B)>

template seq source · line 174 · raw

@-A:Data -> @-B:Data -> @-p:(@_:Cur -> Res<A>) -> @-q:(@_:Cur -> Res<B>) -> @c:Cur -> Res<Both(A, B)>

p, then q; both values.

template keep.a source · line 184 · raw

@-A:Data -> @-B:Data -> @-q:(@_:Cur -> Res<B>) -> @r:Res<A> -> Res<A>

template left source · line 192 · raw

@-A:Data -> @-B:Data -> @-p:(@_:Cur -> Res<A>) -> @-q:(@_:Cur -> Res<B>) -> @c:Cur -> Res<A>

p, then q; p's value.

template skip.a source · line 195 · raw

@-A:Data -> @-B:Data -> @-q:(@_:Cur -> Res<B>) -> @r:Res<A> -> Res<B>

template right source · line 203 · raw

@-A:Data -> @-B:Data -> @-p:(@_:Cur -> Res<A>) -> @-q:(@_:Cur -> Res<B>) -> @c:Cur -> Res<B>

p, then q; q's value.

template alt.r source · line 230 · raw

@-A:Data -> @-q:(@_:Cur -> Res<A>) -> @c:Cur -> @r:Res<A> -> Res<A>

template alt source · line 238 · raw

@-A:Data -> @-p:(@_:Cur -> Res<A>) -> @-q:(@_:Cur -> Res<A>) -> @+c:Cur -> Res<A>

p; if it fails, q from the same place.

template opt source · line 249 · raw

@-A:Data -> @-p:(@_:Cur -> Res<A>) -> @+c:Cur -> Res<Maybe<&2, A>>

p, or None with no input taken.

template many.go source · line 267 · raw

@-A:Data -> @-p:(@_:Cur -> Res<A>) -> @fuel:Nat -> @c:Cur -> @acc:List<&2, A> -> @r:Res<A> -> Res<List<&2, A>>

template many source · line 279 · raw

@-A:Data -> @-p:(@_:Cur -> Res<A>) -> @+c:Cur -> Res<List<&2, A>>

p zero or more times, until it fails or takes no input.

template many1.r source · line 289 · raw

@-A:Data -> @-p:(@_:Cur -> Res<A>) -> @r:Res<A> -> Res<List<&2, A>>

template many1 source · line 297 · raw

@-A:Data -> @-p:(@_:Cur -> Res<A>) -> @c:Cur -> Res<List<&2, A>>

p one or more times.

template text source · line 308 · raw

@-A:Data -> @-p:(@_:Cur -> Res<A>) -> @c:Cur -> Res<String>

p; the value is the text p took.

template sep_by1.r source · line 313 · raw

@-A:Data -> @-S:Data -> @-p:(@_:Cur -> Res<A>) -> @-sep:(@_:Cur -> Res<S>) -> @r:Res<A> -> Res<List<&2, A>>

template sep_by1 source · line 321 · raw

@-A:Data -> @-S:Data -> @-p:(@_:Cur -> Res<A>) -> @-sep:(@_:Cur -> Res<S>) -> @c:Cur -> Res<List<&2, A>>

p one or more times, with sep between.

template sep_by source · line 332 · raw

@-A:Data -> @-S:Data -> @-p:(@_:Cur -> Res<A>) -> @-sep:(@_:Cur -> Res<S>) -> @+c:Cur -> Res<List<&2, A>>

p zero or more times, with sep between.

template rec.go source · line 342 · raw

@-A:Data -> @-F:Data -> @-open:(@_:Cur -> Res<Step<A, F>>) -> @-next:(@_:F -> @_:A -> @_:Cur -> Res<Step<A, F>>) -> @fuel:Nat -> @r:Res<Step<A, F>> -> @stack:List<&2, F> -> Res<A>

template rec source · line 366 · raw

@-A:Data -> @-F:Data -> @-open:(@_:Cur -> Res<Step<A, F>>) -> @-next:(@_:F -> @_:A -> @_:Cur -> Res<Step<A, F>>) -> @+c:Cur -> Res<A>

A nested value. At a value, open gives a Leaf, or an Open frame that wants a child. When a child v ends inside frame f, next(f, v) gives the finished container as a Leaf, or the frame for the next child as an Open. Each step must take input.

template run source · line 372 · raw

@-A:Data -> @-p:(@_:Cur -> Res<A>) -> @+s:String -> Res<A>

p over all of s.