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

peg

Parsing Expression Grammar (PEG) 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.

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.

parol

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

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

nom-tracer

Extension of nom to trace parser execution

nom-derive

Custom derive nom parsers from struct

minimal-lexical

Fast float parsing conversion routines

splitty

a string splitter taking quotes into account

lelwel

Resilient LL(1) parser generator

cfg

manipulating context-free grammars

fast-float

Fast floating-point number parser

antlr-rust

ANTLR4 runtime for Rust

tree-sitter-elixir

Elixir grammar for the tree-sitter parsing library

oni-comb-parser-rs

parser combinators

supply-chain-trust-example-crate-000099

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

locspan

Code mapping utility types and traits

rustemo

A LR/GLR parser generator

tree-sitter-cpp

C++ grammar for tree-sitter

tree-sitter-scala

Scala grammar for tree-sitter

nom-recursive

Extension of nom to handle left recursion

pidgin

non-recursive grammars

pest_consume

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

monch

Inspired by nom, but specifically for strings

gramatica

A compiler compiler for Rust implementing Earley's parser

safe-regex

Safe regular expression library

cfgrammar

Grammar manipulation

bitvec-nom2

Bit level parsing for nom with bitvec

laps

Build lexers and parsers by deriving traits

peginator

PEG parser generator for creating ASTs in Rust (runtime)

gramma

Generate a scannerless parser by declaring types

descape

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

rusty_lr_parser

macro line parser for rusty_lr

earlgrey

parsing context-free grammars using Earley algorithm

gallop

General LL(1) Parser

lieval

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

tree-sitter-c

C grammar for tree-sitter

inpt

A derive crate for dumb type-level text parsing

yggdrasil-rt

Yggdrasil Shared Structure

fn-bnf

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

pest_vm

pest grammar virtual machine

pomelo

Lemon parser generator as a Rust procedural macro

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

parcelona

minimalistic elegance parser combinator library

chomp1

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

lrtable

LR grammar table generation

tree-sitter-css

CSS grammar for tree-sitter

tokenizer-lib

Tokenization utilities for building parsers in Rust

rusticata-macros

Helper macros for Rusticata

lexerus

annotated lexer

logos-codegen

Create ridiculously fast Lexers

alkale

LL(1) lexer library for Rust

cinputs

that simplifies the constraining of inputs

zero

zero-allocation parsing of binary data

kiki

A minimalist parser generator for Rust

parsa

a functional combinator parsing library

peg-runtime

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

pa-rs

Parsing library using concepts of Parser combinators

ndef-rs

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

pratt

parser for Rust

lib-lexin

lexer 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

lexers

Tools for tokenizing and scanning

tuckey

lexer/parser generation framework

pom-trace

PEG parser combinators using operator overloading without macros

bnf_rules

LR(1) parser generator

thisenum

Assign constant literals to enum arms

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

lip

powerful parser combinators for creating reusable and flexible parsers

lrlex

lexer generator

winnow

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

flussab

writing parsers

nameless-peg-parser

PEG, still unstable

byte-parser

Parse a str or a slice with a function style

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

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

simple-tokenizer

A tiny no_std tokenizer with line & column tracking

wagon-togll

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

parse_int

Parse &str with common prefixes to integer values

tree-sitter-r

R grammar for the tree-sitter parsing library

rushell_deps_pom

PEG parser combinators using operator overloading without macros

is_number

Check if a string can be parsed as a number

nom-packrat

Extension of nom to apply Packrat Parsing

langlang

parser generator based on Parsing Expression Grammars (tools)

stap

Stateful parser

parsit

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

pkl-parser

Pkl Parser!

generator-combinator

Composes combinators to generate patterns of increasing complexity

manger

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

ruly2

parser generator from context free grammar

syntacks

An opinionated parser library for Rust

take_sni

just parse sni from buf

pest_derive

pest's derive macro

paresse

Parser generators for lazy people

peekread

Allows peeking ahead in Read streams

bitstream_reader

Reading bit sequences from a byte slice

autumn

A recursive descent parser combinator library

fundu-systemd

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

number_range

parse list of numbers from/to human readable string

chainchomp

Tinyest Opinionated parser combinator library for Rust

lang_pt

A parser tool to generate recursive descent top down parser

css_forge

A robust and efficient CSS parsing library for Rust

lexer

plugin based lexical reader

enso-automata

A finite-automata-based lexing engine

parserc

Asynchronous-compatible parser combinator library for rust language

gll-pg-core

A parser generator for GLL grammar, core library

oak

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

pratt-gen

Generate recursive-descent & precedence climbing parsers

indent_tokenizer

Generate tokens based on indentation

lua_ir

lua runtime and IR generation

nom-regex

regular expressions for nom parsers

nimbleparse

Yacc grammar debugging tool

lexr

Flexible, powerful and simple lexing in Rust

daisychain

a method chaining parsing library

binator

Parser Combinator

sprout

growing simple, but beautiful AST trees 🌳

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

mexe

arithmetic expression evaluator

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

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

pom-preview

PEG parser combinators using operator overloading without macros

pest_generator

pest code generator

changelog_document

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

split-paragraphs

An iterator over the paragraphs of a string

shunting

evaluating math expressions

somen

An asynchronous parser combinator

wagon-ident

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

derive-finite-automaton

Procedural macro for generating finite automaton

nom_learn

WhileDB

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

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

tuck5

A pragmatic lexer/parser generator

combine_wasi

Fast parser combinators on arbitrary streams with zero-copy support

strp

string parsing utility crate, supporting no_std contexts

tree-sitter-fortran

fortran grammar for the tree-sitter parsing library

glr

RNGLR parser generator

do-not-use-antlr-rust

ANTLR4 runtime for Rust

lalrpop-snap

convenient LR(1) parser generator

thin-shunting

evaluating math expressions

aott

Aspect Of The Tokens - a parser combinator framework

new-pkl

Fastest PKL-parsing crate out there!

synattra

A Syn Attribute Parser Toolkit

parcours

Parser Combinators for Unique Results

skimmer

streams reader

nom8

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

rustemo-compiler

Rustemo compiler and development tools

munch

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

ripeg

Incremental PEG parser Rust library

pest_debugger

pest grammar debugger

parcos

minimal parser combinator library

langlang_syntax

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

pest_tmp

The Elegant Parser

chomp

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

winnow-rule

A procedural macro for defining winnow combinators in simple DSL

marpa

Safe bindings to the libmarpa parsing engine

or-rs

or-rs's enum types

libreda-stream-parser

Very simple parser generator for parsing data streams

tree-sitter-fsharp

fsharp grammar for the tree-sitter parsing library

pest_typed

A statically typed version of pest

nyst

parser library

pag-parser

Parser-lexer fusion generator (parser generator)

parco

Zero-cost parser combinators

memoir

self-describing parser combinators

chumsky-branch

branch combinator for the chumsky parsing library

pex

A nightly parser combinator library for Rust

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

abackus

Parser builder using EBNF

safe-regex-compiler

Regex compiler for the safe-regex crate

oom

One or Many types (Haskell NonEmpty)

parsed

Parser combinators library

strtoint

Parse integers from strings, with support for base prefixes

ruminant

An exploration into implementing parser combinators

static-regular-grammar

Derive macro for static regular grammar

rusty-snowflake

generating and parsing Snowflake IDs

peginator-cli

Command line interface for peginator (a PEG parser generator)

plex

A syntax extension for writing lexers and parsers

laps_regex

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

textpos

A small library to track human-readable text positions

logos-cli

Create ridiculously fast Lexers

tree-sitter-embedded-template

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

rzcalc

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

parse_me

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

posix-regex

parsing POSIX regular expressions

pcomb

A tiny parser combinator library

estring

way to parse a string using type annotations

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

kombi

A Parser Combinator Library

flexi-parse

flexible parsing

chonk

A lightweight parser combinator framework

keyword-parser

Keyword parser for combine

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.

honeycomb

A portable parser combinator library that does not require a runtime

regex-tokenizer

A regex tokenizer

calculator-parser

calculation parser for user input

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

char-lex

Create easy enum based lexers

strtools

containing various string utilities

tree-builder

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

char-circle

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

pacosso

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

enquote

Quotes and unquotes strings

bitvec-nom

Bit level parsing for nom with bitvec

coolrule

A boolean expression evaluator. A Rust port of boolrule.

relex

building a regex-based lexer

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

in-place-string-map

An in-place string modification library

lex-map_editor_std

standard types and parser for lex-map_editor

cursortanium

A solid cursor for Rust

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

bnf_rules_parser

LR(1) parser generator

lld-pg

lld-script parser and generator

rustylr

executable for rusty_lr

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

tree-sitter-hygen-template

Hygen Template grammar for tree-sitter

noam

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

wop

An front-end to lrp

rxml_proc

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

escape_it_lib

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

tree-sitter-regex

Regex grammar for tree-sitter

layered-amount

Amount plugin for layered-nlp

binator_context

Group commun context handle to use with binator

lemon-tree

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

regex-lexer

A regex-based lexer (tokenizer)

pex-trie

A parser combinator library for Rust

escafers

parser & generator for escape sequences

fhir-derive

FHIR-RS macro implementation

lox-scanner

lexical scanner for Lox

tree-sitter-fluentbit

fluent-bit grammar for tree-sitter

ratatat

expressive parser combinators with caching

jpar

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

sas-lexer-macro

Internal macro for sas-lexer crate

peruse

A small parser combinator library

nano_parser_gen

A parser generator inspired by yacc (types and functions)

perplex

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

nom-bufreader

BufReader adapter for nom parsers

re-set

Regular expression set parser at run time

parsell

LL(1) streaming parser combinators

simple-parser-bootstrap

runtime recursive descent parser generator

peggle

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

tree-sitter-rigz

Rigz grammar for tree-sitter

somen-language

somen parser combinator for languages

sana

Create lexers easily

prattle

General, configurable Pratt/TDOP parser

kamo

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

simple-cursor

A super simple character cursor implementation geared towards lexers/tokenizers

frostwalker

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

inference_core

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

rslua_traits

Some traits for rslua

from-regex

Derive deserialization of structs and enums from regex patterns

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

ruly

parser generator from context free grammar

parol-macros

Macros for LL(k) parser generator parol

oak_runtime

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

nom-bufreader-rp

BufReader adapter for nom parsers

tokenate

do some grunt work of writing a tokenizer

regex-lexer-lalrpop

A regex-based lexer (tokenizer)

astray_core

Core functionality of the astray macro

hime_redist

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

grammar_tool

understanding LL(k) grammars

dsntk-macros

dsntk | Decision Toolkit | Procedural and derive macros

simple-lexer

runtime lexer generator

nailgun

A PEG parser generator

oni-comb-toys-rs

toys parser

plain

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

nom-errors

Strong-typed errors support for nom parser combinator library

pegtastic-runtime

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

pag-compiler

Parser-lexer fusion generator (compiler interface)

condex

Extract tokens by simple condition expression

string-to-num

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

chars_input

chars input

pest_generator_tmp

pest code generator

rcombinators

A parser combinator library in rust

stringslice

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

simple-interner

append-only interner

indented-blocks

parser for indented blocks

pct

test_eq

assert_eq!-like macros that return a Result instead

anpa

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

tree-sitter-kotlin-ng

Kotlin grammar for tree-sitter

transliterate

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

flexar

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

combine-proc-macro

Support for using combine parser combinators with the proc_macro API

combine-regex-1

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

peginator_codegen

Buildscript support for peginator (a PEG parser generator)

parser-test

Declarative tester for parsers

pest_grammars

pest popular grammar implementations

input-stream

IO streams similar to C++'s streams

somen-decode

A byte string decoder for somen

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

perplex-runtime

Runtime library for parsers generated by perplex

clip_core

Defines clip core traits

peg-pack

Versatile parser generator for PEG grammars

pegy

A derive based parser generator

lighter

Macro for rewriting string matches as tries

bin_buffer

writing objects to binairy buffers

langlang_lib

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