Lib.rs

nom

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

logos

Create ridiculously fast Lexers

pest

The Elegant Parser

peg

Parsing Expression Grammar (PEG) parser generator

lalrpop

convenient LR(1) parser generator

chumsky

A parser library for humans with powerful error recovery

combine

Fast parser combinators on arbitrary streams with zero-copy support

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.

nom-derive

Custom derive nom parsers from struct

pest_meta

pest meta language parser and validator

lrpar

Yacc-compatible parser generator

yap

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

tree-sitter-swift

swift grammar for the tree-sitter parsing library

nimbleparse

Yacc grammar debugging tool

parol

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

rustlr

Bottom-Up Parser Generator with Advanced Options

nom-tracer

Extension of nom to trace parser execution

fast-float

Fast floating-point number parser

minimal-lexical

Fast float parsing conversion routines

lelwel

Resilient LL(1) parser generator

rustemo

A LR/GLR parser generator

rusty_lr_parser

macro line parser for rusty_lr

cfg

manipulating context-free grammars

splitty

a string splitter taking quotes into account

oni-comb-parser-rs

parser combinators

monch

Inspired by nom, but specifically for strings

gramatica

A compiler compiler for Rust implementing Earley's parser

antlr-rust

ANTLR4 runtime for Rust

locspan

Code mapping utility types and traits

pest_consume

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

supply-chain-trust-example-crate-000099

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

tree-sitter-html

HTML grammar for tree-sitter

descape

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

nom-recursive

Extension of nom to handle left recursion

safe-regex

Safe regular expression library

pidgin

non-recursive grammars

tree-sitter-elixir

Elixir grammar for the tree-sitter parsing library

laps

Build lexers and parsers by deriving traits

pest_generator

pest code generator

gallop

General LL(1) Parser

earlgrey

parsing context-free grammars using Earley algorithm

rusty_parser

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

lieval

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

yggdrasil-rt

Yggdrasil Shared Structure

pomelo

Lemon parser generator as a Rust procedural macro

tree-sitter-css

CSS grammar for tree-sitter

parcelona

minimalistic elegance parser combinator library

fn-bnf

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

syntax-parser-generator

Independent library for generating lexical-analyzers and LALR parsers

structview

Viewing binary data as high-level data structures, safely

rusttyc

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

cfgrammar

Grammar manipulation

chomp1

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

tokenizer-lib

Tokenization utilities for building parsers in Rust

tree-sitter-cpp

C++ grammar for tree-sitter

rusticata-macros

Helper macros for Rusticata

ndef-rs

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

logos-codegen

Create ridiculously fast Lexers

lexerus

annotated lexer

gramma

Generate a scannerless parser by declaring types

kiki

A minimalist parser generator for Rust

zero

zero-allocation parsing of binary data

parsa

a functional combinator parsing library

peg-runtime

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

pest_typed_generator

Pest-typed's code generator

cinputs

that simplifies the constraining of inputs

pa-rs

Parsing library using concepts of Parser combinators

tree-sitter-c

C grammar for tree-sitter

lib-lexin

lexer library

tree-sitter-r

R grammar for the tree-sitter parsing library

rust-bison-skeleton

Bison skeleton for Rust

rflex

Fast lexer code generator for Rust

lexer-rs

Lexical anaylzer framework for context-free text parsing into tokens

tuckey

lexer/parser generation framework

bnf_rules

LR(1) parser generator

pom-trace

PEG parser combinators using operator overloading without macros

lexers

Tools for tokenizing and scanning

rusty_lr_buildscript

buildscipt tools for rusty_lr

decodetree

parser and generator

strloin

copy on write slices of a string

transduce

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

mpl

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

lip

powerful parser combinators for creating reusable and flexible parsers

simple-tokenizer

A tiny no_std tokenizer with line & column tracking

winnow

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

flussab

writing parsers

langlang

parser generator based on Parsing Expression Grammars (tools)

byte-parser

Parse a str or a slice with a function style

nom-packrat

Extension of nom to apply Packrat Parsing

glue

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

shrimple-parser

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

lemon-mint

Famous Lemon Parser Generator implemented in rust as library with API

pag-lexer

Parser-lexer fusion generator (derivative lexer)

wagon-togll

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

parse_int

Parse &str with common prefixes to integer values

rushell_deps_pom

PEG parser combinators using operator overloading without macros

number_range

parse list of numbers from/to human readable string

stap

Stateful parser

lua_ir

lua runtime and IR generation

nameless-peg-parser

PEG, still unstable

parsit

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

pom-preview

PEG parser combinators using operator overloading without macros

lrlex

lexer generator

pkl-parser

Pkl Parser!

pest_vm

pest grammar virtual machine

manger

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

generator-combinator

Composes combinators to generate patterns of increasing complexity

pegy

A derive based parser generator

ruly2

parser generator from context free grammar

syntacks

An opinionated parser library for Rust

css_forge

A robust and efficient CSS parsing library for Rust

lang_pt

A parser tool to generate recursive descent top down parser

bitstream_reader

Reading bit sequences from a byte slice

peekread

Allows peeking ahead in Read streams

autumn

A recursive descent parser combinator library

nifty

generating Deterministic Finite State Automata (DFA)

chainchomp

Tinyest Opinionated parser combinator library for Rust

paresse

Parser generators for lazy people

pest_debugger

pest grammar debugger

binator

Parser Combinator

sprout

growing simple, but beautiful AST trees 🌳

fundu-systemd

Fast and precise systemd time span parser of rust strings to a Duration

lexer

plugin based lexical reader

enso-automata

A finite-automata-based lexing engine

indent_tokenizer

Generate tokens based on indentation

tree-sitter-fsharp

fsharp grammar for the tree-sitter parsing library

gll-pg-core

A parser generator for GLL grammar, core library

pratt-gen

Generate recursive-descent & precedence climbing parsers

parserc

Asynchronous-compatible parser combinator library for rust language

mexe

arithmetic expression evaluator

langlang_syntax

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

lexr

Flexible, powerful and simple lexing in Rust

tree-sitter-fortran

fortran grammar for the tree-sitter parsing library

daisychain

a method chaining parsing library

parol_runtime

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

fast_input

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

parse-display-with

Custom formatting/parsing utilities for parse-display

ielr

Table generation backend for LR parser generators

abortable_parser

A parser combinator library with an emphasis on error handling

valk-utils

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

nom_learn

WhileDB

blex

A lightweight lexing framework

unscanny

Painless string scanning

accept

My personal parser combinator library, deciding what tokens to accept

parze

A clean, efficient parser combinator

inpt

A derive crate for dumb type-level text parsing

changelog_document

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

oak

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

split-paragraphs

An iterator over the paragraphs of a string

shunting

evaluating math expressions

lrtable

LR grammar table generation

muncher

Easy to use char muncher for writing a lexer

somen

An asynchronous parser combinator

gll

GLL parsing framework

derive-finite-automaton

Procedural macro for generating finite automaton

wagon-ident

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

pest_typed

A statically typed version of pest

kilo

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

rspg

LR(1) parser generator library

combine-language

Extra parser combinators, useful for parsing programming languages

alder

Parser combinator library inspired by Elm parser error messages

combine_wasi

Fast parser combinators on arbitrary streams with zero-copy support

tuck5

A pragmatic lexer/parser generator

pest_tmp

The Elegant Parser

parcours

Parser Combinators for Unique Results

pex

A nightly parser combinator library for Rust

aott

Aspect Of The Tokens - a parser combinator framework

skimmer

streams reader

or-rs

or-rs's enum types

do-not-use-antlr-rust

ANTLR4 runtime for Rust

strp

string parsing utility crate, supporting no_std contexts

lalrpop-snap

convenient LR(1) parser generator

synattra

A Syn Attribute Parser Toolkit

rustemo-compiler

Rustemo compiler and development tools

munch

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

peginator-cli

Command line interface for peginator (a PEG parser generator)

glr

RNGLR parser generator

chomp

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

tree-sitter-hygen-template

Hygen Template grammar for tree-sitter

winnow-rule

A procedural macro for defining winnow combinators in simple DSL

parcos

minimal parser combinator library

abackus

Parser builder using EBNF

posix-regex

parsing POSIX regular expressions

marpa

Safe bindings to the libmarpa parsing engine

libreda-stream-parser

Very simple parser generator for parsing data streams

tree-sitter-fluentbit

fluent-bit grammar for tree-sitter

nyst

parser library

rzcalc

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

static-regular-grammar

Derive macro for static regular grammar

parco

Zero-cost parser combinators

chumsky-branch

branch combinator for the chumsky parsing library

safe-regex-compiler

Regex compiler for the safe-regex crate

laps_regex

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

gnaw

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

fabparse

A minimized parser combinator library

parslers

A Staged Selective Parser Combinator Library for the Rust Programming Language

quake_infostring

Parse QuakeWorld info strings

oom

One or Many types (Haskell NonEmpty)

parsed

Parser combinators library

strtoint

Parse integers from strings, with support for base prefixes

memoir

self-describing parser combinators

rusty-snowflake

generating and parsing Snowflake IDs

tree-sitter-rigz

Rigz grammar for tree-sitter

plex

A syntax extension for writing lexers and parsers

logos-cli

Create ridiculously fast Lexers

textpos

A small library to track human-readable text positions

pag-compiler

Parser-lexer fusion generator (compiler interface)

parse_me

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

bitvec-nom

Bit level parsing for nom with bitvec

relex

building a regex-based lexer

chonk

A lightweight parser combinator framework

re-set

Regular expression set parser at run time

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

pacosso

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

keyword-parser

Keyword parser for combine

char-lex

Create easy enum based lexers

kg-syntax

Runtime LR(1) parser generator library

logos-iter

Extensions for Logos lexer

look_ahead_items

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

flexi-parse

flexible parsing

honeycomb

A portable parser combinator library that does not require a runtime

tree-builder

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

regex-tokenizer

A regex tokenizer

calculator-parser

calculation parser for user input

estring

way to parse a string using type annotations

tinyparse

A tiny combinator parser library

destruct-lib

Destruct structs and enums for simpler combinator implementation

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

strtools

containing various string utilities

in-place-string-map

An in-place string modification library

char-circle

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

enquote

Quotes and unquotes strings

eles

ELES; Extensible Logical Expression Solver

string-to-num

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

fkl_ext_api

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

coolrule

A boolean expression evaluator. A Rust port of boolrule.

from-regex

Derive deserialization of structs and enums from regex patterns

combpop

Type-based parser combinator

statemachine

working with statemachines

read-from

Supplies the ReadFrom and WriteTo traits

lex-map_editor_std

standard types and parser for lex-map_editor

regex-lexer-lalrpop

A regex-based lexer (tokenizer)

nom-trace

A tracer for nom parsers

pct

ripeg

Incremental PEG parser Rust library

cursortanium

A solid cursor for Rust

tree-sitter-kotlin-ng

Kotlin grammar for tree-sitter

regular-expression

parsing, compiling, and executing regular expressions

pdl-derive

PDL's derive macro

regex-lexer

A regex-based lexer (tokenizer)

from-str-sequential

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

bnf_rules_parser

LR(1) parser generator

lld-pg

lld-script parser and generator

key-list

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

racc_runtime

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

noam

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

wop

An front-end to lrp

num-parse

Generic, JavaScript-like parseInt() functions for Rust

rxml_proc

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

simple-lexer

runtime lexer generator

escape_it_lib

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

rustylr

executable for rusty_lr

lox-scanner

lexical scanner for Lox

layered-amount

Amount plugin for layered-nlp

binator_context

Group commun context handle to use with binator

grammar_tool

understanding LL(k) grammars

jpar

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

pex-trie

A parser combinator library for Rust

escafers

parser & generator for escape sequences

ratatat

expressive parser combinators with caching

fhir-derive

FHIR-RS macro implementation

lemon-tree

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

shelby

Data processing

simple-cursor

A super simple character cursor implementation geared towards lexers/tokenizers

sas-lexer-macro

Internal macro for sas-lexer crate

peruse

A small parser combinator library

langlang_lib

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

nano_parser_gen

A parser generator inspired by yacc (types and functions)

perplex

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

tokenate

do some grunt work of writing a tokenizer

parsell

LL(1) streaming parser combinators

peginator_codegen

Buildscript support for peginator (a PEG parser generator)

pegtastic-runtime

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

sana

Create lexers easily

prattle

General, configurable Pratt/TDOP parser

goldsrc-rs

Collection of file's parsers for goldsrc engine

kamo

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

frostwalker

A TOML-like configuration language parser with zero dependencies outside of std

simple-parser-bootstrap

runtime recursive descent parser generator

inference_core

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

rslua_traits

Some traits for rslua

pag-parser

Parser-lexer fusion generator (parser generator)

wagon-parser

Parser for the WAGon DSL

pm-lexer

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

pest_consume_macros

Macros for pest_consume

parol-macros

Macros for LL(k) parser generator parol

nom-bufreader

BufReader adapter for nom parsers

nom-bufreader-rp

BufReader adapter for nom parsers

thisenum

Assign constant literals to enum arms

somen-language

somen parser combinator for languages

astray_core

Core functionality of the astray macro

ruly

parser generator from context free grammar

plain

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

parser-test

Declarative tester for parsers

test_eq

assert_eq!-like macros that return a Result instead

hime_redist

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

rosetta-build

Code generation for the Rosetta i18n library

condex

Extract tokens by simple condition expression

chars_input

chars input

combinedfun

A little nom-like parser combinator library which stays away from macros, while trying to achieve at least part of the expressiveness of nom

nom-errors

Strong-typed errors support for nom parser combinator library

combine-regex-1

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

rcombinators

A parser combinator library in rust

rematch

A procedural macro to generate simple FromStr implementation based on Regular Expression matching

stringslice

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

simple-interner

append-only interner

transliterate

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

indented-blocks

parser for indented blocks

perplex-runtime

Runtime library for parsers generated by perplex

thin-shunting

evaluating math expressions

combine-proc-macro

Support for using combine parser combinators with the proc_macro API

nom-bitvec

Bit level parsing for nom with bitvec

flexar

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

simple_config_parser

configuration file parser

pest_generator_tmp

pest code generator

input-stream

IO streams similar to C++'s streams

somen-decode

A byte string decoder for somen

lalry

creating LALR(1) parsers from context-free grammars

clip_core

Defines clip core traits

prexel

A math expression evaluator

pahs

A pahsing (parsing) library

peggle

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

bin_buffer

writing objects to binairy buffers

lighter

Macro for rewriting string matches as tries

shared-string

Split a string without another allocation

folder_compare

Compare two folders and get a list of changed and new files

parse-up

parsing combinators that help the user build up to a successful parse

oak_runtime

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

frithu

A robust, runtime parsing engine based on the Earley/Marpa algorithm

brzozowski-regex

Brzozowski regular expressions

sashimi

straightforward, zero-copy, general-purpose parsing library. Opinionated by default, with customizable rules.

parsimonious

parser combinators

collections-fromstr

Derives FromStr for collection types like Vec<T> or HashSet<T>