alecthomas/participle
Participle
Participle is a Go parser generator and toolkit for building language frontends. It provides a declarative grammar framework that uses reflection and struct tags to map input patterns directly into typed data structures.
The library features a stateful lexical analyzer that employs state machines to handle nested or modal patterns. It includes a lexer code generator to produce optimized code, reducing runtime memory allocations and increasing throughput.
The project covers recursive descent parsing with support for union types via sealed interfaces and custom parsing logic through interface-based overrides. It also includes an EBNF grammar exporter to generate standard formal representations of a parser's logic for documentation.
The toolkit tracks token positions and range metadata to provide precise diagnostic feedback during syntax errors.
Features
- Compiler Frontend Development - Provides the fundamental tools for building compiler frontends, including lexical analysis and syntax tree generation.
- Recursive Descent Parsers - Implements a recursive descent parsing engine to translate input text into structured syntax trees.
- Frontend Toolkits - Provides a set of utilities for creating language frontends with position tracking and optimized lexer generation.
- Parser Libraries - Serves as a Go library for building recursive descent parsers that map raw text to typed data structures.
- Input Tokenizers - Converts raw bytes into a stream of tokens using a configurable lexer or default scanner.
- Lexical Analyzers - Provides a toolkit for converting raw bytes into token streams using state-machine-driven lexical analysis.
- Programming Language Development - Offers a framework for designing and implementing custom programming or scripting languages.
- Stateful Lexers - Provides stateful lexing capabilities to handle nested or modal token patterns via push-pop operations.
- Source Position Trackings - Populates position and range metadata within the syntax tree to enable precise error reporting.
- State-Machine Lexers - Employs a push-down automaton state machine to handle nested or modal token states during lexical analysis.
- Typed Structure Parsing - Converts input text into strongly typed data structures based on a declarative grammar.
- Grammar-to-Struct Mapping - Uses Go struct tags and reflection to declaratively map text patterns directly into typed data structures.
- Struct-Tag-Driven Grammar Definitions - Implements a declarative framework that maps input patterns to objects using struct tags and reflection.
- Position-Aware Tracking - Maintains character offsets and line numbers to provide precise diagnostic feedback for syntax errors.
- Token Captures - Extracts matching values from the input stream and populates them into fields as strings, lists, or numbers.
- Configuration File Parsers - Enables the creation of structured parsers for custom configuration formats that map to typed data objects.
- Formal Grammar Specifications - Generates standard EBNF representations of a parser's logic for formal language documentation.
- Custom Parsing Logic - Allows developers to implement specific interfaces on grammar nodes to override default capture behavior with custom logic.
- EBNF Grammar Exporters - Generates standard EBNF representations from defined parsing logic to document language syntax.
- Lexer Generators - Provides a generator that transforms lexer definitions into optimized Go code to improve performance.
- Union Types - Supports union types via sealed interfaces to represent grammar alternatives within a single field.
- Compilers and Interpreters - Library for building custom syntax parsers.
