Documentation ¶
Index ¶
- func AndThen[T stream.Token, I, O any](p parser.Func[T, I], f func(I) (O, error)) parser.Func[T, O]
- func Attempt[T stream.Token, O any](parser parser.Func[T, O]) parser.Func[T, O]
- func Factory[T stream.Token, O any](f func([]T) parser.Func[T, O]) parser.Func[T, O]
- func FlatMap[T stream.Token, O any](p parser.Func[T, []T], f func([]T) (O, error)) parser.Func[T, O]
- func Fold[T stream.Token, I, B any](p parser.Func[T, []I], init func() B, f func(B, I) B) parser.Func[T, B]
- func Ignore[T stream.Token, I any](p parser.Func[T, I]) parser.Func[T, any]
- func Lazy[T stream.Token, O any](f func() parser.Func[T, O]) parser.Func[T, O]
- func Map[T stream.Token, I, O any](p parser.Func[T, I], f func(I) O) parser.Func[T, O]
- func Pair[T stream.Token, O1, O2 any](p1 parser.Func[T, O1], P2 parser.Func[T, O2]) parser.Func[T, pair.Pair[O1, O2]]
- func Tuple3[T stream.Token, O1, O2, O3 any](p1 parser.Func[T, O1], p2 parser.Func[T, O2], p3 parser.Func[T, O3]) parser.Func[T, tuple.Tuple3[O1, O2, O3]]
- func Tuple4[T stream.Token, O1, O2, O3, O4 any](p1 parser.Func[T, O1], p2 parser.Func[T, O2], p3 parser.Func[T, O3], ...) parser.Func[T, tuple.Tuple4[O1, O2, O3, O4]]
- func Tuple5[T stream.Token, O1, O2, O3, O4, O5 any](p1 parser.Func[T, O1], p2 parser.Func[T, O2], p3 parser.Func[T, O3], ...) parser.Func[T, tuple.Tuple5[O1, O2, O3, O4, O5]]
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func AndThen ¶
AndThen parses with `p` and applies `f` on the result if `p` parses successfully. `f` may optionally fail with an error.
Example ¶
package main import ( "fmt" "strconv" "github.com/flier/gocombine/pkg/parser/char" "github.com/flier/gocombine/pkg/parser/combinator" "github.com/flier/gocombine/pkg/parser/repeat" ) func main() { p := combinator.AndThen(repeat.Many1(char.Digit()), func(s []rune) (int, error) { return strconv.Atoi(string(s)) }) fmt.Println(p([]rune("123"))) fmt.Println(p([]rune("9999999999999999"))) fmt.Println(p([]rune("foobar"))) }
Output: 123 [] <nil> 9999999999999999 [] <nil> 0 [111 111 98 97 114] and then, many1, digit, satisfy, actual 'f', unexpected
func Attempt ¶
Attempt behaves as `parser` except it always acts as `parser` peeked instead of committed on its parse.
func Factory ¶
Factory constructs the `parser` lazily.
This is similar to `Lazy` but it takes `input` as an argument and allows different parsers to be returned on each call to `p` while still reporting the correct errors.
Example ¶
package main import ( "fmt" "github.com/flier/gocombine/pkg/parser" "github.com/flier/gocombine/pkg/parser/char" "github.com/flier/gocombine/pkg/parser/combinator" ) func main() { p := combinator.Factory(func(s []rune) parser.Func[rune, []rune] { if s[0] == 'a' { return char.String("apple") } return char.String("banana") }) fmt.Println(p([]rune("apple"))) fmt.Println(p([]rune("banana"))) }
Output: [97 112 112 108 101] [] <nil> [98] [97 110 97 110 97] string, cmp, expected "apple", actual "b", unexpected
func FlatMap ¶
func FlatMap[T stream.Token, O any](p parser.Func[T, []T], f func([]T) (O, error)) parser.Func[T, O]
FlatMap uses `f` to map over the output of `p`. If `f` returns an error the parser fails.
Example ¶
package main import ( "fmt" "github.com/flier/gocombine/pkg/parser/char" "github.com/flier/gocombine/pkg/parser/combinator" "github.com/flier/gocombine/pkg/parser/repeat" ) func main() { p := combinator.FlatMap( char.Take(4), func(input []rune) (out []rune, err error) { out, _, err = repeat.Many1(char.Digit())(input) return }, ) fmt.Println(p([]rune("12abcd"))) fmt.Println(p([]rune("123"))) fmt.Println(p([]rune("foobar"))) }
Output: [49 50] [99 100] <nil> [] [49 50 51] flat map, take, unexpected EOF [] [97 114] flat map, many1, digit, satisfy, actual 'f', unexpected
func Fold ¶
func Fold[T stream.Token, I, B any](p parser.Func[T, []I], init func() B, f func(B, I) B) parser.Func[T, B]
Fold every element into an accumulator by applying an operation, returning the final result.
Example ¶
package main import ( "fmt" "github.com/flier/gocombine/pkg/parser/char" "github.com/flier/gocombine/pkg/parser/combinator" "github.com/flier/gocombine/pkg/parser/repeat" ) func main() { p := combinator.Fold(repeat.Many1(char.Digit()), func() int { return 0 }, func(acc int, c rune) int { return acc*10 + int(c-'0') }) fmt.Println(p([]rune("123"))) fmt.Println(p([]rune("9999999999999999"))) fmt.Println(p([]rune("foobar"))) }
Output: 123 [] <nil> 9999999999999999 [] <nil> 0 [111 111 98 97 114] fold, many1, digit, satisfy, actual 'f', unexpected
func Lazy ¶
Lazy constructs the `parser` lazily.
Can be used to effectively reduce the size of deeply nested parsers as only the function producing the parser is stored.
func Map ¶
Map uses `f` to map over the `p` parsed value.
Example ¶
package main import ( "fmt" "github.com/flier/gocombine/pkg/parser/char" "github.com/flier/gocombine/pkg/parser/combinator" ) func main() { p := combinator.Map(char.Digit(), func(r rune) bool { return r == '9' }) fmt.Println(p([]rune("9i"))) }
Output: true [105] <nil>
func Pair ¶
func Pair[T stream.Token, O1, O2 any](p1 parser.Func[T, O1], P2 parser.Func[T, O2]) parser.Func[T, pair.Pair[O1, O2]]
Pair parses two heterogeneous value.
Example ¶
package main import ( "fmt" "github.com/flier/gocombine/pkg/parser/char" "github.com/flier/gocombine/pkg/parser/choice" "github.com/flier/gocombine/pkg/parser/combinator" "github.com/flier/gocombine/pkg/parser/repeat" ) func main() { p := combinator.Pair(choice.Optional(char.OneOf("+-")), repeat.Many1(char.Digit())) fmt.Println(p([]rune("123"))) fmt.Println(p([]rune("+123"))) fmt.Println(p([]rune("foobar"))) }
Output: {<none> [49 50 51]} [] <nil> {43 [49 50 51]} [] <nil> {<none> []} [111 111 98 97 114] pair, many1, digit, satisfy, actual 'f', unexpected
func Tuple3 ¶
func Tuple3[ T stream.Token, O1, O2, O3 any, ]( p1 parser.Func[T, O1], p2 parser.Func[T, O2], p3 parser.Func[T, O3], ) parser.Func[T, tuple.Tuple3[O1, O2, O3]]
Tuple3 parses a tuple of heterogeneous values.
Types ¶
This section is empty.