Lib.rs

nom

A byte-oriented, zero-copy, parser combinators library

pest

The Elegant Parser

logos

Create ridiculously fast Lexers

lalrpop

convenient LR(1) parser generator

combine

Fast parser combinators on arbitrary streams with zero-copy support

peg

Parsing Expression Grammar (PEG) parser generator

chumsky

A parser library for humans with powerful error recovery

pom

PEG parser combinators using operator overloading without macros

tree-sitter-rust

Rust grammar for tree-sitter

bitreader

reading individual bits from a slice of bytes. You can read "unusual" numbers of bits from the byte slice, for example 13 bits at once. The reader internally keeps track of position within the buffer.

pest_meta

pest meta language parser and validator

yap

Parser library. A lightweight, dependency free, parser combinator inspired set of utility methods to help with parsing strings and slices.

parol

LL(k) and LALR(1) parser generator for Rust

nimbleparse

Yacc grammar debugging tool

tree-sitter-swift

swift grammar for the tree-sitter parsing library

rustlr

Bottom-Up Parser Generator with Advanced Options

rusty_parser

A Generic compile-time Parser generator and pattern matching library written in Rust

antlr-rust

ANTLR4 runtime for Rust

nom-derive

Custom derive nom parsers from struct

minimal-lexical

Fast float parsing conversion routines

nom-tracer

Extension of nom to trace parser execution

cfg

manipulating context-free grammars

splitty

a string splitter taking quotes into account

lelwel

Resilient LL(1) parser generator

token-string

Short (up to 65,535 bytes) immutable strings to e.g. parse tokens, implemented in Rust. These are sometimes called 'German Strings', because Germans have written the paper mentioning them.

tree-sitter-elixir

Elixir grammar for the tree-sitter parsing library

tree-sitter-cpp

C++ grammar for tree-sitter

tree-sitter-scala

Scala grammar for tree-sitter

monch

Inspired by nom, but specifically for strings

oni-comb-parser-rs

parser combinators

rustemo

A LR/GLR parser generator

fast-float

Fast floating-point number parser

nom-recursive

Extension of nom to handle left recursion

cfgrammar

Grammar manipulation

pidgin

non-recursive grammars

supply-chain-trust-example-crate-000099

A byte-oriented, zero-copy, parser combinators library

gramatica

A compiler compiler for Rust implementing Earley's parser

laps

Build lexers and parsers by deriving traits

locspan

Code mapping utility types and traits

safe-regex

Safe regular expression library

gramma

Generate a scannerless parser by declaring types

bitvec-nom2

Bit level parsing for nom with bitvec

descape

Adds a single extension trait for &str to unescape any backslashes

peginator

PEG parser generator for creating ASTs in Rust (runtime)

pest_consume

A framework for processing the output of a pest-generated parser

rustylr

executable for rusty_lr

gallop

General LL(1) Parser

tree-sitter-c

C grammar for tree-sitter

lieval

A lightweight Rust crate for parsing and evaluating mathematical expressions from strings

yggdrasil-rt

Yggdrasil Shared Structure

pest_vm

pest grammar virtual machine

fn-bnf

A parsing grammar generator that lets you use arbitrary Rust items as rules

inpt

A derive crate for dumb type-level text parsing

earlgrey

parsing context-free grammars using Earley algorithm

structview

Viewing binary data as high-level data structures, safely

parcelona

minimalistic elegance parser combinator library

rusttyc

writing type checkers with a lattice-like type system in rust

chomp1

A fast monadic-style parser combinator designed to work on stable Rust

alkale

LL(1) lexer library for Rust

tokenizer-lib

Tokenization utilities for building parsers in Rust

rusticata-macros

Helper macros for Rusticata

peg-runtime

Runtime support for rust-peg grammars. To use rust-peg, see the peg crate.

lrlex

lexer generator

lexerus

annotated lexer

pest_typed_generator

Pest-typed's code generator

glue

parser combinator framework for parsing text based formats, it is easy to use and relatively fast too

syntax-parser-generator

Independent library for generating lexical-analyzers and LALR parsers

kiki

A minimalist parser generator for Rust

ndef-rs

NDEF (NFC Data Exchange Format) parser and generator in Rust

syntaxe

declarative parser combinators

logos-codegen

Create ridiculously fast Lexers

pomelo

Lemon parser generator as a Rust procedural macro

tuckey

lexer/parser generation framework

parsa

a functional combinator parsing library

pa-rs

Parsing library using concepts of Parser combinators

lib-lexin

lexer library

tree-sitter-r

R grammar for the tree-sitter parsing library

pratt

parser for Rust

rust-bison-skeleton

Bison skeleton for Rust

parse_int

Parse &str with common prefixes to integer values

rflex

Fast lexer code generator for Rust

lexers

Tools for tokenizing and scanning

pom-trace

PEG parser combinators using operator overloading without macros

bnf_rules

LR(1) parser generator

thisenum

Assign constant literals to enum arms

decodetree

parser and generator

strloin

copy on write slices of a string

cinputs

that simplifies the constraining of inputs

zero

zero-allocation parsing of binary data

nom-language

Language parsing focused combinators for the nom parser library

winnow

A byte-oriented, zero-copy, parser combinators library

simple-tokenizer

A tiny no_std tokenizer with line & column tracking

rusty_lr_parser

macro line parser for rusty_lr

lexer-rs

Lexical anaylzer framework for context-free text parsing into tokens

lrtable

LR grammar table generation

dynparser

Dynamic parser. You can define rules at run time. It's possible to use peg format

transduce

Zero-copy isomorphic parsing: your code should look like what it parses

nameless-peg-parser

PEG, still unstable

mpl

Minimal parser combinator of Minimal Parsing Language (MPL) like Top-Down Parsing Language (TDPL)

lemon-mint

Famous Lemon Parser Generator implemented in rust as library with API

pag-lexer

Parser-lexer fusion generator (derivative lexer)

shrimple-parser

Zero-dependency next-gen parsing combinator library with flexible error reporting

lip

powerful parser combinators for creating reusable and flexible parsers

rushell_deps_pom

PEG parser combinators using operator overloading without macros

is_number

Check if a string can be parsed as a number

langlang

parser generator based on Parsing Expression Grammars (tools)

split-paragraphs

Iterator over paragraphs of a string

byte-parser

Parse a str or a slice with a function style

parsit

very simple lib, the parsing combinators, recursive descendent that uses logos as lexer

peekread

Allows peeking ahead in Read streams

pkl-parser

Pkl Parser!

generator-combinator

Composes combinators to generate patterns of increasing complexity

ruly2

parser generator from context free grammar

take_sni

just parse sni from buf

manger

A performant, low-level, lightweight and intuitive combinatoric parser library

pest_derive

pest's derive macro

number_range

parse list of numbers from/to human readable string

paresse

Parser generators for lazy people

bitstream_reader

Reading bit sequences from a byte slice

lexer

plugin based lexical reader

autumn

A recursive descent parser combinator library

nom-greedyerror

Custom error type to take a deepest error

chainchomp

Tinyest Opinionated parser combinator library for Rust

lang_pt

A parser tool to generate recursive descent top down parser

syntacks

An opinionated parser library for Rust

css_forge

A robust and efficient CSS parsing library for Rust

wagon-togll

Example tool that uses the WAGon ecosystem to create GLL based parsers

enso-automata

A finite-automata-based lexing engine

parol_runtime

Runtime library for parsers generated by the 'parol' parser generator

indent_tokenizer

Generate tokens based on indentation

strp

string parsing utility crate, supporting no_std contexts

oak

A typed parser generator syntax extension for Parsing Expression Grammar (PEG)

textmate-scope-selector-peg

Textmate scope selector implementation as a PEG (parser grammar) in Rust

lexr

Flexible, powerful and simple lexing in Rust

daisychain

a method chaining parsing library

lua_ir

lua runtime and IR generation

parserc

Asynchronous-compatible parser combinator library for rust language

tree-sitter-css

CSS grammar for tree-sitter

sprout

growing simple, but beautiful AST trees 🌳

fast_input

Fast and easy input from standard in, made for competetive programming

gll-pg-core

A parser generator for GLL grammar, core library

pom-preview

PEG parser combinators using operator overloading without macros

ielr

Table generation backend for LR parser generators

unscanny

Painless string scanning

valk-utils

Dead simple functions that valkyrie_pilot uses, and maybe you can too

accept

My personal parser combinator library, deciding what tokens to accept

mexe

arithmetic expression evaluator

parze

A clean, efficient parser combinator

changelog_document

Feature-rich changelog format. Include a parser and serializer.

rusty_lr_buildscript

buildscipt tools for rusty_lr

nom-packrat

Extension of nom to apply Packrat Parsing

binator

Parser Combinator

pest_generator

pest code generator

tree-sitter-fortran

fortran grammar for the tree-sitter parsing library

somen

An asynchronous parser combinator

combine_wasi

Fast parser combinators on arbitrary streams with zero-copy support

wagon-ident

Ident struct for WAGon. Used in various crates for various reasons

blex

A lightweight lexing framework

rspg

LR(1) parser generator library

combine-language

Extra parser combinators, useful for parsing programming languages

lrpar

Yacc-compatible parser generator

kilo

small, fast utility crate/library for manipulating strings and generating sourcemaps with all in Magic 🪄

muncher

Easy to use char muncher for writing a lexer

alder

Parser combinator library inspired by Elm parser error messages

shunting

evaluating math expressions

tuker

A small tokenizer/parser library with an emphasis on usability

derive-finite-automaton

Procedural macro for generating finite automaton

pratt-gen

Generate recursive-descent & precedence climbing parsers

nom_learn

WhileDB

glr

RNGLR parser generator

rustemo-compiler

Rustemo compiler and development tools

lalrpop-snap

convenient LR(1) parser generator

aott

Aspect Of The Tokens - a parser combinator framework

wee-peg

Parsing Expression Grammar (PEG) parser generator

synattra

A Syn Attribute Parser Toolkit

tree-sitter-embedded-template

Embedded Template (ERB, EJS) grammar for tree-sitter

munch

Blazing fast, zero-copy parser combinator library with an elegant API for both strings and bytes

do-not-use-antlr-rust

ANTLR4 runtime for Rust

nom8

A byte-oriented, zero-copy, parser combinators library (fork for proposals for v8)

thin-shunting

evaluating math expressions

parcours

Parser Combinators for Unique Results

ripeg

Incremental PEG parser Rust library

parcos

minimal parser combinator library

winnow-rule

A procedural macro for defining winnow combinators in simple DSL

nom-regex

regular expressions for nom parsers

pest_typed

A statically typed version of pest

skimmer

streams reader

langlang_syntax

langlang is a parser generator based on Parsing Expression Grammars (library)

pest_tmp

The Elegant Parser

marpa

Safe bindings to the libmarpa parsing engine

libreda-stream-parser

Very simple parser generator for parsing data streams

quake_infostring

Parse QuakeWorld info strings

abackus

Parser builder using EBNF

ruminant

An exploration into implementing parser combinators

pag-parser

Parser-lexer fusion generator (parser generator)

parco

Zero-cost parser combinators

static-regular-grammar

Derive macro for static regular grammar

chumsky-branch

branch combinator for the chumsky parsing library

pex

A nightly parser combinator library for Rust

chomp

A fast monadic-style parser combinator designed to work on stable Rust

pest_debugger

pest grammar debugger

tuck5

A pragmatic lexer/parser generator

gnaw

Conveniently chip small pieces off a slice or str to use elsewhere

parslers

A Staged Selective Parser Combinator Library for the Rust Programming Language

nyst

parser library

oom

One or Many types (Haskell NonEmpty)

parsed

Parser combinators library

strtoint

Parse integers from strings, with support for base prefixes

rzcalc

calculator expression parser and evaluater using recursive descent parser, written in rust

rusty-snowflake

generating and parsing Snowflake IDs

safe-regex-compiler

Regex compiler for the safe-regex crate

peginator-cli

Command line interface for peginator (a PEG parser generator)

estring

way to parse a string using type annotations

logos-cli

Create ridiculously fast Lexers

plex

A syntax extension for writing lexers and parsers

parse_me

Parser combinator crate. Provides a simple parser combinator crate for Rust.

abortable_parser

A parser combinator library with an emphasis on error handling

textpos

A small library to track human-readable text positions

flexi-parse

flexible parsing

or-rs

or-rs's enum types

chonk

A lightweight parser combinator framework

pcomb

A tiny parser combinator library

gll-pg-macros

A parser generator for GLL grammar, macros part

pegtastic

Parsing Expression Grammar (PEG) parser generator

enso-flexer

A finite-automata-based lexing engine

fabparse

A minimized parser combinator library

kombi

A Parser Combinator Library

keyword-parser

Keyword parser for combine

laps_regex

Tools for generating NFAs, DFAs and state-transition tables from regular expressions

kg-syntax

Runtime LR(1) parser generator library

look_ahead_items

I was repeating, and sometimes I wanted to look ahead. Shifted by chunks instead of one.

calculator-parser

calculation parser for user input

tinyparse

A tiny combinator parser library

pacosso

https://github.com/toschoo/pacosso/blob/master/README.md

tree-sitter-starlark

Starlark grammar for tree-sitter

zordon

low-level abstractions for zero-copy parsing and mutation

volt_parse

The advanced, slightly different take on the parser combinator concept

parseme

A framework for building robust parsers

destruct-lib

Destruct structs and enums for simpler combinator implementation

posix-regex

parsing POSIX regular expressions

in-place-string-map

An in-place string modification library

strtools

containing various string utilities

logos-iter

Extensions for Logos lexer

char-circle

A circular buffer for strings and traits for in-place string transforms

tree-sitter-rigz

Rigz grammar for tree-sitter

enquote

Quotes and unquotes strings

bitvec-nom

Bit level parsing for nom with bitvec

coolrule

A boolean expression evaluator. A Rust port of boolrule.

combpop

Type-based parser combinator

fkl_ext_api

Feakin is a architecture design and visual collaboration tool. This is the parser for Feakin.

statemachine

working with statemachines

paco

parser combinator library

read-from

Supplies the ReadFrom and WriteTo traits

char-lex

Create easy enum based lexers

tree-builder

Parser Generator library which uses Nom and procedural macros to generate recursive-descent parsers

cursortanium

A solid cursor for Rust

tree-sitter-hygen-template

Hygen Template grammar for tree-sitter

regex-lexer

A regex-based lexer (tokenizer)

num-parse

Generic, JavaScript-like parseInt() functions for Rust

eles

ELES; Extensible Logical Expression Solver

from-str-sequential

A FromStr-like trait for enums, matching the first compatible variant

lld-pg

lld-script parser and generator

new-pkl

Fastest PKL-parsing crate out there!

bnf_rules_parser

LR(1) parser generator

relex

building a regex-based lexer

key-list

A very minimal crate to get you a specific sequence between two characters in a string, fast

pdl-derive

PDL's derive macro

racc_runtime

RACC is a port of Berkeley YACC to Rust, and allows you to write grammar definitions directly in Rust source code

pahs

A pahsing (parsing) library

noam

A byte-oriented, zero-copy, parser combinator library

simple-lexer

runtime lexer generator

fhir-derive

FHIR-RS macro implementation

wop

An front-end to lrp

escape_it_lib

Converts white-space characters into their escaped versions in provided Strings

rxml_proc

Macros to, at compile time, validate strings against the CData, Name and NCName productions from the XML 1.0 grammar

binator_context

Group commun context handle to use with binator

jpar

A text-oriented, zero-copy, parser combinators library

pex-trie

A parser combinator library for Rust

escafers

parser & generator for escape sequences

nano_parser_gen

A parser generator inspired by yacc (types and functions)

lemon-tree

Famous Lemon Parser Generator, designed as library that builds your parser transparently during cargo build. Use attributes to describe parser rules.

lox-scanner

lexical scanner for Lox

layered-amount

Amount plugin for layered-nlp

sas-lexer-macro

Internal macro for sas-lexer crate

memoir

self-describing parser combinators

peruse

A small parser combinator library

parsell

LL(1) streaming parser combinators

pm-lexer

sample lexer using the proc-macro crate, to be used in the pomelo testings

ratatat

expressive parser combinators with caching

peggle

regex-like parsing library, capable of handling Parsing Expression Grammar (PEG) rules

kamo

assist in the creation of an interpreter or compiler and its associated runtime

clip_core

Defines clip core traits

tree-sitter-fluentbit

fluent-bit grammar for tree-sitter

pegtastic-runtime

Runtime support for pegtastic grammars. To use pegtastic, see the pegtastic crate.

prattle

General, configurable Pratt/TDOP parser

regex-lexer-lalrpop

A regex-based lexer (tokenizer)

re-set

Regular expression set parser at run time

simple-cursor

A super simple character cursor implementation geared towards lexers/tokenizers

inference_core

Feakin is a architecture design and visual collaboration tool. This is the parser for Feakin.

rslua_traits

Some traits for rslua

hime_redist

Redistributable runtime library for parsers generated with Hime (LR, RNGLR)

ruly

parser generator from context free grammar

oak_runtime

Parser generated by Oak depends on this library. Please consult the package Oak for more informations.

tokenate

do some grunt work of writing a tokenizer

perplex

A grammar analyzer and LR(k)/GLR parser generator

astray_core

Core functionality of the astray macro

from-regex

Derive deserialization of structs and enums from regex patterns

nailgun

A PEG parser generator

plain

A small Rust library that allows users to reinterpret data of certain types safely

sana

Create lexers easily

rumtk-core

Core library for providing general functionality to support the other RUMTK crates. See rumtk-hl7-v2 crate as example

grammar_tool

understanding LL(k) grammars

somen-language

somen parser combinator for languages

dsntk-macros

dsntk | Decision Toolkit | Procedural and derive macros

nom-bufreader-rp

BufReader adapter for nom parsers

pag-compiler

Parser-lexer fusion generator (compiler interface)

string-to-num

A trait for easy parsing of decimal, hexidecmal, binary, and octal numbers

wagon-parser

Parser for the WAGon DSL

simple-parser-bootstrap

runtime recursive descent parser generator

oni-comb-toys-rs

toys parser

tree-sitter-ocaml

OCaml grammar for tree-sitter

regular-expression

parsing, compiling, and executing regular expressions

chars_input

chars input

parol-macros

Macros for LL(k) parser generator parol

rcombinators

A parser combinator library in rust

combine-proc-macro

Support for using combine parser combinators with the proc_macro API

stringslice

A collection of methods to slice strings based on character indices rather than bytes

transliterate

A string to string parser which avoids the intermediate tree by building the output string directly

indented-blocks

parser for indented blocks

pct

tree-sitter-flatbuffers

Flatbuffers grammar for tree-sitter

anpa

A generic monadic parser combinator library inspired by Haskell's parsec

pest_generator_tmp

pest code generator

condex

Extract tokens by simple condition expression

test_eq

assert_eq!-like macros that return a Result instead

combine-regex-1

Re-export of regex 1.0 letting combine use both 0.2 and 1.0

nom-errors

Strong-typed errors support for nom parser combinator library

simple-interner

append-only interner

pest_grammars

pest popular grammar implementations

flexar

An extremely flexible lexer/parser (get it?) for writing your own programming language

tree-sitter-zig

Zig grammar for tree-sitter

tree-sitter-jsdoc

JSDoc grammar for tree-sitter

input-stream

IO streams similar to C++'s streams

somen-decode

A byte string decoder for somen

perplex-runtime

Runtime library for parsers generated by perplex

langlang_lib

langlang is a parser generator based on Parsing Expression Grammars (library)

peginator_codegen

Buildscript support for peginator (a PEG parser generator)

peg-pack

Versatile parser generator for PEG grammars

lighter

Macro for rewriting string matches as tries

pegy

A derive based parser generator