combinators

README

Parser Combinators

Personal parser combinator library for Golang.

Examples

TODO

Longer Examples

• Minimark Syntax

TODO

• [Work in progress] Recoverable parsing
• [Idea] Add tab indented parser combinator inside the Minimark example syntax.
• [Idea] LibConfig Syntax

Commands

Benchmarks

go test -bench=. ./... > "notes/benchmark-$(git rev-parse --short HEAD).txt"

Documentation

Index

• Variables
• func ParseRuneReader(parser Parser, r io.RuneReader) (interface{}, error)
• func StringifyInterfaces(i interface{}) string
• type FuncParser
  • func (p FuncParser) Apply(state ParserState) (*ParserResult, error)
• type Parser
  • func AnyOf(parsers ...Parser) Parser
  • func Expect(expected rune) Parser
  • func ExpectAny(expectedList []rune) Parser
  • func ExpectPredicate(predicate func(rune) bool, descriptions ...string) Parser
  • func ExpectString(expectedList []rune) Parser
  • func OneOrMore(parser Parser) Parser
  • func Optional(parser Parser) Parser
  • func RepeatUntil(parser Parser, terminator Parser) Parser
  • func RestarableOneOrMore(parser Parser, restart Parser) Parser
  • func SeqIgnore(parser Parser) Parser
  • func SeqOf(parsers ...Parser) Parser
  • func StringifyResult(parser Parser) Parser
  • func Transform(parser Parser, transform func(interface{}) interface{}) Parser
  • func ZeroOrMore(parser Parser) Parser
• type ParserResult
  • func Fail(state ParserState, err error) (*ParserResult, error)
  • func Success(state ParserState, result interface{}) (*ParserResult, error)
• type ParserState
• type Partial
• type RuneScanner
  • func (s *RuneScanner) CurrentRune() rune
  • func (s *RuneScanner) GetLocation() (int, int)
  • func (s *RuneScanner) PrintErrorMessage(e error)
  • func (s *RuneScanner) Remaining() ParserState

Variables

var Alphanumeric = AnyOf(Letter, Digit)

Alphanumeric ...

var Any = ExpectPredicate(func(r rune) bool { return true }, `any`)

Any ...

var Decimal = Transform(
	SeqOf(
		Transform(
			Optional(ExpectAny([]rune("+-"))),
			func(i interface{}) interface{} {
				if i == nil {
					return ""
				}

				return i.(string)
			},
		),
		Integer,
		Expect('.'),
		OneOrMore(Digit),
	),
	func(iSeq interface{}) interface{} {
		seq := iSeq.([]interface{})
		iOneOrMore := seq[3].([]interface{})
		str := ""
		for _, digit := range iOneOrMore {
			str += digit.(string)
		}
		return seq[0].(string) + seq[1].(string) + seq[2].(string) + str
	},
)

Decimal ...

var Decimal2 = Transform(
	SeqOf(
		Optional(ExpectAny([]rune("+-"))),
		Integer,
		Expect('.'),
		OneOrMore(Digit),
	),
	func(i interface{}) interface{} {
		return StringifyInterfaces(i)
	},
)

Decimal2 ...

var Digit = ExpectPredicate(unicode.IsDigit, `digit`)

Digit ...

var EOF = FuncParser(func(state ParserState) (*ParserResult, error) {
	if state.CurrentRune() == 0 {
		return Success(state.Remaining(), string(state.CurrentRune()))
	}

	return Fail(state, fmt.Errorf(`Expected end of stream`))
})

EOF ...

var InlineSpace = ExpectPredicate(func(r rune) bool {
	return r == ' ' || r == '\t'
}, `inline space`)

InlineSpace ...

var Integer = Transform(
	AnyOf(
		SeqOf(
			ExpectAny([]rune("123456789")),
			ZeroOrMore(Digit),
		),
		Expect('0'),
	),
	func(iany interface{}) interface{} {
		if zero, ok := iany.(string); ok {
			return zero
		}

		seq := iany.([]interface{})
		expectAny := seq[0].(string)
		iZeroOrMore := seq[1].([]interface{})

		rem := ""
		for _, digit := range iZeroOrMore {
			rem += digit.(string)
		}

		return expectAny + rem
	})

Integer ...

var Letter = ExpectPredicate(unicode.IsLetter, `letter`)

Letter ...

var Newline = ExpectPredicate(func(r rune) bool {
	return r == '\n' || r == '\r'
}, `newline`)

Newline ...

var Space = ExpectPredicate(unicode.IsSpace, `space`)

Space ...

Functions

func ParseRuneReader

func ParseRuneReader(parser Parser, r io.RuneReader) (interface{}, error)

ParseRuneReader - trivial

func StringifyInterfaces

func StringifyInterfaces(i interface{}) string

StringifyInterfaces ...

Types

type FuncParser

type FuncParser func(state ParserState) (*ParserResult, error)

FuncParser functional binding for the Parser interface

func (FuncParser) Apply

func (p FuncParser) Apply(state ParserState) (*ParserResult, error)

Apply - trivial

type Parser

type Parser interface {
	Apply(state ParserState) (*ParserResult, error)
}

Parser rappresents a generic parser combinator

func AnyOf

func AnyOf(parsers ...Parser) Parser

AnyOf must match one of the given parsers

func Expect

func Expect(expected rune) Parser

Expect creates a Parser that expects a single given character and if successfull returns a string as Result

func ExpectAny

func ExpectAny(expectedList []rune) Parser

ExpectAny creates a Parser that expects any rune from a given list

func ExpectPredicate

func ExpectPredicate(predicate func(rune) bool, descriptions ...string) Parser

ExpectPredicate creates a Parser for a rune based on given predicate function

func ExpectString

func ExpectString(expectedList []rune) Parser

ExpectString creates a Parser that expects all the runes from a given list

func OneOrMore

func OneOrMore(parser Parser) Parser

OneOrMore matches one or more of a given parser

func Optional

func Optional(parser Parser) Parser

Optional matches zero or one of a given parser

func RepeatUntil

func RepeatUntil(parser Parser, terminator Parser) Parser

RepeatUntil ...

func RestarableOneOrMore

func RestarableOneOrMore(parser Parser, restart Parser) Parser

RestarableOneOrMore restarts the parsing from a given safepoint matched by another "restart" parser. For example (see examples for the precise definition of this parser, special modifiers omitted for brevity):

parser := RestarableOneOrMore(SeqOf(OneOrMore(Expect('a')), AnyOf(Newline, EOF)), Newline)
ParseRuneReader(parser, strings.NewReader("aaaa\naaaaa\naaabbbb\naaaaa\naa"))

and the result is ["aaaa", "aaaaa", Partial("aaa"), "aaaaa", "aa"]

func SeqIgnore

func SeqIgnore(parser Parser) Parser

SeqIgnore wrapps an existing parser and ignores its result when used in "SeqOf"

func SeqOf

func SeqOf(parsers ...Parser) Parser

SeqOf combines parsers in a seequence

func StringifyResult

func StringifyResult(parser Parser) Parser

StringifyResult ...

func Transform

func Transform(parser Parser, transform func(interface{}) interface{}) Parser

Transform a parser result if successfull

func ZeroOrMore

func ZeroOrMore(parser Parser) Parser

ZeroOrMore matches zero or more of a given parser

type ParserResult

type ParserResult struct {
	Result    interface{}
	Remaining ParserState
}

ParserResult ...

func Fail

func Fail(state ParserState, err error) (*ParserResult, error)

Fail creates a "failing" ParserResult

func Success

func Success(state ParserState, result interface{}) (*ParserResult, error)

Success creates a successfull ParserResult

type ParserState

type ParserState interface {
	CurrentRune() rune
	Remaining() ParserState
}

ParserState ...

type Partial

type Partial interface{}

Partial rappresents a partial parse for use of all "Recoveralbe*" functions

type RuneScanner

type RuneScanner struct {
	// contains filtered or unexported fields
}

RuneScanner is a basic scanner based on a RuneReader

func (*RuneScanner) CurrentRune

func (s *RuneScanner) CurrentRune() rune

CurrentRune ...

func (*RuneScanner) GetLocation

func (s *RuneScanner) GetLocation() (int, int)

GetLocation ...

func (*RuneScanner) PrintErrorMessage

func (s *RuneScanner) PrintErrorMessage(e error)

PrintErrorMessage ...

func (*RuneScanner) Remaining

func (s *RuneScanner) Remaining() ParserState

Remaining ...