Lib.rs

pest

The Elegant Parser

nom

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

logos

Create ridiculously fast Lexers

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

lalrpop

convenient LR(1) parser generator

btoi

Parse integers directly from ASCII byte slices

minimal-lexical

Fast float parsing conversion routines

parol

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

bet

parsing and evaluating binary expression trees

nimbleparse

Yacc grammar debugging tool

lrtable

LR grammar table generation

oni-comb-parser-rs

parser combinators

pest_generator

pest code generator

yap

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

pomelo

Lemon parser generator as a Rust procedural macro

locspan

Code mapping utility types and traits

kparse

Tracking and better error handling for nom parsers

lelwel

Resilient LL(1) parser generator

kamo

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

cfg

manipulating context-free grammars

pest_consume

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

flexar

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

rusty_parser

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

splitty

a string splitter taking quotes into account

rusty_lr_parser

grammar line parser for rusty_lr

descape

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

lalrpop-util

Runtime library for parsers generated by LALRPOP

combi

A combinators library with an included rust token parsing implementation

whitehole

fast, intuitive parser combinator framework for Rust

posix-regex

parsing POSIX regular expressions

lexxor

A fast, extensible, greedy, single-pass text tokenizer for Rust

safe-regex

Safe regular expression library

chomp1

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

earlgrey

parsing context-free grammars using Earley algorithm

rustemo

A LR/GLR parser generator

matchete

A fast and flexible matcher for comparing and diffing data structures

antlr-rust

ANTLR4 runtime for Rust

hkid_ops

generating and validating Hong Kong Identity Card (HKID) numbers, supporting all official and custom prefixes, with correct check digit calculation

form_builder

building forms with various fields and validation

laps

Build lexers and parsers by deriving traits

bparse

parsing bytes

lrpar

Yacc-compatible parser generator

lieval

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

pidgin

non-recursive grammars

pdl-runtime

PDL's runtime library

herring

Lexer generator

inpt

A derive crate for dumb type-level text parsing

teleparse

bad_parsers

A parser combinator library written by myself, for myself

camxes-rs

A Parsing Expression Grammar (PEG) parser generator with zero-copy parsing and rich debugging capabilities

plain

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

pratt

parser for Rust

enquote

Quotes and unquotes strings

bitvec-nom2

Bit level parsing for nom with bitvec

gallop

General LL(1) Parser

untrustended

Untrusted Extended. A compilation of primitives for parsing values from untrusted input.

peginator

PEG parser generator for creating ASTs in Rust (runtime)

rusttyc

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

parcelona

minimalistic elegance parser combinator library

yggdrasil-rt

Yggdrasil Shared Structure

anpa

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

rflex

Fast lexer code generator for Rust

structview

Viewing binary data as high-level data structures, safely

fn-bnf

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

glue

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

snacks

more nom parser-combinators

kiki

A minimalist parser generator for Rust

flager

Ultra lightweight library to parse flags

bnf_rules

LR(1) parser generator

kinetics-parser

A parser used for Kinetics project

stack_maxima_parser

Parser for the Modified Maxima syntax used in STACK

tokenizer-lib

Tokenization utilities for building parsers in Rust

backyard-generator

Convert AST node back to PHP code

alkale

LL(1) lexer library for Rust

tuckey

lexer/parser generation framework

untwine

Declarative parsing with a BNF-like syntax

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.

lexers

Tools for tokenizing and scanning

shrimple-parser

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

pom-trace

PEG parser combinators using operator overloading without macros

udled

Tokenizer and parser

dsntk-feel-parser

dsntk | DecisionToolkit | FEEL parser

ruly2

parser generator from context free grammar

lrlex

lexer generator

mpl

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

pest_typed

A statically typed version of pest

pa-rs

Parsing library using concepts of Parser combinators

peg

Parsing Expression Grammar (PEG) parser generator

gobble

A Combinator based parser for strings that gets out of the way, and leaves your code looking like a grammer

winnow

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

logos-codegen

Create ridiculously fast Lexers

test_eq

assert_eq!-like macros that return a Result instead

apt-parser

A parser for the APT package manager's package lists

bitbite

trait that would help you interact bytes with flags easily

lemon-mint

Famous Lemon Parser Generator implemented in rust as library with API

dynparser

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

santiago

A lexing and parsing toolkit for Rust

paf

Parse PAF files

lib-lexin

lexer library

unscanny

Painless string scanning

pest_derive

pest's derive macro

komb

Low-level parsing utilities

pag-lexer

Parser-lexer fusion generator (derivative lexer)

pest_railroad_gen

Railroad (aka syntax) SVG diagram generator for Pest parsers. It supports most (but not all) Pest grammar rules.

rushell_deps_pom

PEG parser combinators using operator overloading without macros

take_sni

just parse sni from buf

lang_pt

A parser tool to generate recursive descent top down parser

binator

Parser Combinator

pkombi

Parser combinator library

d2-stampede

Dota 2 replay parser written in Rust

parser_fuck

parser combinator library

range-parser

parse ranges representation of any kind of numbers

peekread

Allows peeking ahead in Read streams

simple-tokenizer

A tiny no_std tokenizer with line & column tracking

rust-bison-skeleton

Bison skeleton for Rust

tokenise

A flexible tokeniser library for parsing text

grammarsmith

Common helpers for handwriting lexers and parsers

pest_debugger

pest grammar debugger

strp

string parsing utility crate, supporting no_std contexts

flussab

writing parsers

asciimath

Mathematical expression parser and evaluator

nbnf_language

A parser for the NBNF language itself, and the parser generator

nifty

generating Deterministic Finite State Automata (DFA)

parsa

a functional combinator parsing library

rusty_lr

parser generator that converts context-free grammars into IELR(1)/LALR(1) tables with deterministic LR and GLR parsing support

manger

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

pom-preview

PEG parser combinators using operator overloading without macros

nom-parse-macros

Procedural macros for generating parser functions for the nom libary

enso-automata

A finite-automata-based lexing engine

lip

powerful parser combinators for creating reusable and flexible parsers

bitstream_reader

Reading bit sequences from a byte slice

sprout

growing simple, but beautiful AST trees 🌳

expression_core

Core functionality for mathematical expression parsing

muncher

Easy to use char muncher for writing a lexer

saudi_id

Parse (validate) or randomly generate Saudi Arabian national IDs

unreferenced_files_lib

finding unused and unreferenced files

pegy

A derive based parser generator

tergo-tokenizer

R language tokenizer

combine_wasi

Fast parser combinators on arbitrary streams with zero-copy support

oak

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

lexer-rs

Lexical anaylzer framework for context-free text parsing into tokens

munch

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

lexr

Flexible, powerful and simple lexing in Rust

yz-string-utils

misc parsing-related string utils

number_range

parse list of numbers from/to human readable string

transduce

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

enumchar

Rust derive macro for enums where each variant is represented by a single char

langlang

parser generator based on Parsing Expression Grammars (tools)

parze

A clean, efficient parser combinator

zero

zero-allocation parsing of binary data

pest_typed_generator

Pest-typed's code generator

lexer

plugin based lexical reader

lexerus

annotated lexer

udled-tokenizers

Tokenizers for udled

kir

IR for parse/print def/use support

abortable_parser

A parser combinator library with an emphasis on error handling

fancy_slice

that provides reflection for tree structures

parser-compose

writing and composing parsers for arbitrary file or data formats

is_number

Check if a string can be parsed as a number

estring

way to parse a string using type annotations

uberbyte

Bit manipulation for dummies

nom-regex

regular expressions for nom parsers

gll-pg-core

A parser generator for GLL grammar, core library

autumn

A recursive descent parser combinator library

daisychain

a method chaining parsing library

bexeval

evaluating string formulas restricted to values as integers only

gll

GLL parsing framework

markab_parser

copy-less and rich-error-message parser combinator library

tuck5

A pragmatic lexer/parser generator

aott

Aspect Of The Tokens - a parser combinator framework

mexe

arithmetic expression evaluator

pest_tmp

The Elegant Parser

spain-vat-id

Spanish VAT ID numbers validation/verification

pretty_goodness

String to String prettification

pag-parser

Parser-lexer fusion generator (parser generator)

alder

Parser combinator library inspired by Elm parser error messages

nameless-peg-parser

PEG, still unstable

wee-peg

Parsing Expression Grammar (PEG) parser generator

cfgrammar

Grammar manipulation

do-not-use-antlr-rust

ANTLR4 runtime for Rust

abackus

Parser builder using EBNF

expression_parser_sympy

High-level API for mathematical expression parsing and evaluation

pex

A nightly parser combinator library for Rust

split-paragraphs

Iterator over paragraphs of a string

nyst

parser library

flexi-parse

flexible parsing

derive-finite-automaton

Procedural macro for generating finite automaton

ripeg

Incremental PEG parser Rust library

rusty-pkl

Lightweight Pkl parser for Rust

ielr

Table generation backend for LR parser generators

reformation

Parsing via regular expressions

marpa

Safe bindings to the libmarpa parsing engine

channels-packet

parse channels packets

synattra

A Syn Attribute Parser Toolkit

memoir

self-describing parser combinators

static-regular-grammar

Derive macro for static regular grammar

shared-string

Split a string without another allocation

gnaw

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

rustemo-compiler

Rustemo compiler and development tools

parslers

A Staged Selective Parser Combinator Library for the Rust Programming Language

gll-pg-macros

A parser generator for GLL grammar, macros part

parco

Zero-cost parser combinators

oom

One or Many types (Haskell NonEmpty)

kinetics-macro

A set of macros used in Kinetics project

parcours

Parser Combinators for Unique Results

textpos

A small library to track human-readable text positions

nommy

Type based parser

anni-artist

Artist parser for Project Anni

regex-lexer

A regex-based lexer (tokenizer)

css_forge

A robust and efficient CSS parsing library for Rust

pest_grammars

pest popular grammar implementations

lexgen

A fully-featured lexer generator implemented as a proc macro

combine-language

Extra parser combinators, useful for parsing programming languages

rusty_lr_buildscript

buildscipt tools for rusty_lr

gospel

Incremental byte munching

bnf_rules_parser

LR(1) parser generator

pacosso

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

glr

RNGLR parser generator

enso-flexer

A finite-automata-based lexing engine

parol-macros

Macros for LL(k) parser generator parol

num-parse

Generic, JavaScript-like parseInt() functions for Rust

fabparse

A minimized parser combinator library

syntacks

An opinionated parser library for Rust

clipv

Command line interpretor parser (and future validator)

logos-cli

Create ridiculously fast Lexers

pcomb

A tiny parser combinator library

cs-string-rw

create to read and write strings into or from binary format compatible with c# BinaryWriter and BinaryReader

keyword-parser

Keyword parser for combine

look_ahead_items

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

stap

Stateful parser

tinyparse

A tiny combinator parser library

safe-regex-compiler

Regex compiler for the safe-regex crate

shunting

evaluating math expressions

text-scanner

A UTF-8 char-oriented, zero-copy, text and code scanning library

valk-utils

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

zordon

low-level abstractions for zero-copy parsing and mutation

quake_infostring

Parse QuakeWorld info strings

noneifempty

Convert T to None if empty

ruly

parser generator from context free grammar

string-to-num

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

recordkeeper-data-model

Abstract data model for recordkeeper

combpop

Type-based parser combinator

rzcalc

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

jpar

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

lemon-tree

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

statemachine

working with statemachines

strtools

containing various string utilities

paco

parser combinator library

parsell

LL(1) streaming parser combinators

yap_streaming

Yap extension crate for parsing streams

or-rs

or-rs's enum types

read-from

Supplies the ReadFrom and WriteTo traits

unimarkup-inline

Compiler for Unimarkup inline elements

pm-lexer

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

rspg

LR(1) parser generator library

new-pkl

Fastest PKL-parsing crate out there!

wagon-ident

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

cursortanium

A solid cursor for Rust

ratatat

expressive parser combinators with caching

parsley-rs

My attempt at a Rust parsing and lexing library

somen-decode

A byte string decoder for somen

from-str-sequential

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

rcombinators

A parser combinator library in rust

blex

A lightweight lexing framework

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

pest_meta_tmp

pest meta language parser and validator

strum

macros for working with enums and strings

regex-lexer-lalrpop

A regex-based lexer (tokenizer)

thin-shunting

evaluating math expressions

pegtastic

Parsing Expression Grammar (PEG) parser generator

simple-parser-bootstrap

runtime recursive descent parser generator

regex-tokenizer

A regex tokenizer

enum_parse

Procedural macro generating boilerplate code for parsing enum variants

reproto-path-lexer

path lexer used with the reproto parser

laps_regex

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

pgs

structuring save files from the Birdiesoft classic game Pokémon Simulator

calculator-parser

calculation parser for user input

lalr

creating LALR(1) parsers from context-free grammars

lopal_core

Lossless Parser Library. Parses to rowan LSTs.

logos-iter

Extensions for Logos lexer

escafers

parser & generator for escape sequences

key-list

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

read-write-ext

ReadWriteExt trait with chain_after and take_rw for std::io::Read + Write structs

inin

written in Rust to parse and validate the Iranian national ID number

fhir-derive

FHIR-RS macro implementation

shelby

Data processing

nom8

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

oneparse

A one in all simple parser framework

peg-runtime

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

frithu

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

oak_runtime

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

parseit

text file parsing library powered by regex and glob patterns

relex

building a regex-based lexer

perplex-runtime

Runtime library for parsers generated by perplex

peruse

A small parser combinator library

simple-cursor

A super simple character cursor implementation geared towards lexers/tokenizers

noam

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

pag-compiler

Parser-lexer fusion generator (compiler interface)

envoke

ergonomic way to load environment variables into struct fields

husk

Rust bindings for the mvdan.cc/sh Golang library

prattle

General, configurable Pratt/TDOP parser

rslua_traits

Some traits for rslua

eles

ELES; Extensible Logical Expression Solver

flexi_func_declarative

exposes the fb! macro to create a function with a flexible signature

escape_it_lib

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

chars_input

chars input

peginator_codegen

Buildscript support for peginator (a PEG parser generator)

sashimi

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

in-place-string-map

An in-place string modification library

inference_core

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

nom-bufreader-rp

BufReader adapter for nom parsers

from-regex

Derive deserialization of structs and enums from regex patterns

simple-lexer

runtime lexer generator

tokenate

do some grunt work of writing a tokenizer

sentencepiece

Binding for the sentencepiece tokenizer

condex

Extract tokens by simple condition expression

frostwalker

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

grammar_tool

understanding LL(k) grammars

combine-proc-macro

Support for using combine parser combinators with the proc_macro API

peresil

simplistic string parsing library

lox-scanner

lexical scanner for Lox

nom-bufreader

BufReader adapter for nom parsers

regular-expression

parsing, compiling, and executing regular expressions

shiftkit

A quick & easy parser generator

ebml-iterable

iterator over EBML encoded data. The items provided by the iterator are Tags as defined in EBML. The iterator is spec-agnostic and requires a specification implementing specific traits to read files…

gratte

macros for working with enums and strings; forked from strum

strum-lite

Lightweight declarative macro for sets of strings

indented-blocks

parser for indented blocks

stringslice

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

binator_context

Group commun context handle to use with binator

charred

char checking

logos-nom-bridge

Implement nom parsers using logos tokens

attrs

An ergonomic parser library for #[attributes], built on parser combinators

pkenum

PKaiser's enum utilities

vcg

manipulating verification conditions

char-circle

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

mca

Read / Write Minecraft Region Files (mca)

parsit

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

folder_compare

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

input-stream

IO streams similar to C++'s streams

die-sir

A dice expression parser and evaluator

bitbite_derive

Adds Bitbite derive

rust-ipmi

IPMI client library for rust

yyjson-rs

Rust bindings for yyjson

epics_gen

macros for deserializing xlsx tables and serializing them as EPICS PVs

ggus

GGUF in Rust🦀

simple-interner

append-only interner

bitvec-nom

Bit level parsing for nom with bitvec

clippet

teeny way to have some nice byte structures that's easy to use

wagon-parser

Parser for the WAGon DSL

shtring

Split an input string into arguments by whitespace such that text between matching quotes is combined into a single argument

pest_railroad

Railroad (aka syntax) SVG diagram generator for Pest parsers. It supports most (but not all) Pest grammar rules.

sana

Create lexers easily

ibuilder

Interactive builder for Rust types

env-cast

Macro to parse an environment variable to a numeric type at compile time

pest_consume_macros

Macros for pest_consume

pdl-derive

PDL's derive macro

lighter

Macro for rewriting string matches as tries

postgres-from-row

Derivable trait that allows converting a postgres row to a struct

facet-peek

Read arbitrary Facet types safely

codec

trait to assist in making codecs

transliterate

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

peggle

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

bootsector

Read partitions from block devices or files

gnurx-sys

Regular expression functionality from glibc extracted into a separate library, for Win32

tonic-build-extend

extend tonic-build to support multiple types_attributes and fields_attributes

pest_generator_tmp

pest code generator

numsep

Adding thousands-seperators to numbers

runtime-lexer

regex based lexer

somen

An asynchronous parser combinator

frombytes

Defines a cursor over a slice of bytes

parser-test

Declarative tester for parsers

libbytestat

Randomness analyzer

lex-map_editor_std

standard types and parser for lex-map_editor

pprzlink

Rust library for pprzlink

ruminant

An exploration into implementing parser combinators

hex-magic

Macros for working with bytes and hexadecimal values

buffed

Traits & implementation of parsing buffered IO

pathbuf-ext

Extends PathBuf to handle replace and contains string methods

lalrpop-snap

convenient LR(1) parser generator

collections-fromstr

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

simple-parser

runtime recursive descent parser generator

dsntk-macros

dsntk | DecisionToolkit | Procedural and derive macros

nailgun

A PEG parser generator

dashu

set of big numbers

delve

number of macros that make working with enums and strings more convenient

source-span

Source code mapping and display utilities

kir-macros

The macros for kir

prexel

A math expression evaluator

cpc

evaluates math expressions, with support for units and conversion between units

parsimonious

parser combinators

tuker

A small tokenizer/parser library with an emphasis on usability

trim_matches_exactly

Extension trait for controlled trimming of prefixes and suffixes of &str and String

sea-strum

macros for working with enums and strings

pestast_gen

pestast code generator

nbnf_macro

nbnf's proc macro enabling ergonomic parser generation

rusty_lr_core

core library for rusty_lr

proclet

Proc macros made easy