An experimental implementation of parser combinators for Golang[Generic], inspired by the Haskell library Parsec and the Rust combine. As in Parsec the parsers are LL(1) by default but they can opt-in to arbitrary lookahead using the attempt combinator.

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"
	"github.com/flier/gocombine/pkg/parser/to"
)

func main() {
	parser := combinator.Map(
		repeat.SepBy(to.String(repeat.Many1(char.Letter())), char.Space()),
		func(words []string) string {
			return words[len(words)-1]
		})

	result, _, err := parser.Parse([]rune("Pick up that word!"))
	if err != nil {
		panic(err)
	}

	fmt.Println(result)
}

Larger examples can be found in the examples and benches folders.

A parser combinator is, broadly speaking, a function which takes several parsers as arguments and returns a new parser, created by combining those parsers. For instance, the Many parser takes one parser, parser, as input and returns a new parser which applies parser zero or more times. Thanks to the modularity that parser combinators gives it is possible to define parsers for a wide range of tasks without needing to implement the low level plumbing while still having the full power of Rust when you need it.

The library adheres to semantic versioning.

If you end up trying it I welcome any feedback from your experience with it. I am usually reachable within a day by opening an issue, sending an email or posting a message on Gitter.

This project is licensed under either of Apache License (LICENSE-APACHE) or MIT license (LICENSE-MIT) at your option.