Lib.rs

nom

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

pest

The Elegant Parser

globset

Cross platform single glob and glob set matching. Glob set matching is the process of matching one or more glob patterns against a single candidate path simultaneously, and returning all of the globs that matched.

pom

PEG parser combinators using operator overloading without macros

combine

Fast parser combinators on arbitrary streams with zero-copy support

lexical

Lexical, to- and from-string conversion routines

logos

Create ridiculously fast Lexers

lalrpop

convenient LR(1) parser generator

pest_generator

pest code generator

tree-sitter

Rust bindings to the Tree-sitter parsing library

vte

Parser for implementing terminal emulators

evalexpr

A powerful arithmetic and boolean expression evaluator

glue

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

needletail

FASTX parsing and k-mer methods

pest_meta

pest meta language parser and validator

utf8parse

Table-driven UTF-8 parser

lrpar

Yacc-compatible parser generator

rusticata-macros

Helper macros for Rusticata

pest_consume

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

nom_locate

A special input type for nom to locate tokens

peg

A simple Parsing Expression Grammar (PEG) parser generator

source-span

Source code mapping and display utilities

gobble

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

sv-parser-syntaxtree

Helper crate of sv-parser

whiteread

Crate for easily reading whitespace-separated values from strings or input

pidgin

simple non-recursive grammars

lexical-core

Lexical, to- and from-string conversion routines

bitter

Swiftly extracts unaligned bit-level data from a byte slice

tfrecord

Serialize and deserialize TFRecord data format from TensorFlow

lexer

plugin based lexical reader

bitstream_reader

Reading bit sequences from a byte slice

btoi

Parse integers directly from ASCII byte slices

bnf

A library for parsing Backus–Naur form context-free grammars

asciimath

Mathematical expression parser and evaluator

tree-sitter-highlight

Library for performing syntax highlighting with Tree-sitter

pom-preview

PEG parser combinators using operator overloading without macros

abackus

Parser builder using EBNF

autumn

A recursive descent parser combinator library

ram

A library that helps to parse source code with finite state machines

unicode-bom

Unicode byte-order mark detection for files and byte arrays

parze

A clean, efficient parser combinator

nom-packrat

Extension of nom to apply Packrat Parsing

pomelo

Implementation of the Lemon parser generator as a Rust procedural macro

atoi

Parse integers directly from [u8] slices in safe code

hime_redist

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

xlformula_engine

A tool to parse and evaluate Excel formulas

ca-rules

Parsing rule strings of life-like cellular automata

oak

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

lip

Lip provides powerful parser combinators for creating reusable and flexible parsers

boolinator

Provides the Boolinator trait, which lets you use Option and Result-style combinators with bools

synattra

A Syn Attribute Parser Toolkit

rustlex

Lexical analysers generator for Rust, written in Rust

pest_tmp

The Elegant Parser

nifty

A library for generating Deterministic Finite State Automata (DFA)

binjs_meta

Part of binjs-ref. Tools for manipulating grammars. You probably do not want to use this crate directly unless you’re writing an encoder, decoder or parser generator for binjs.

logos-derive

Create ridiculously fast Lexers

gallop

General LL(1) Parser

pratt

A Pratt parser for Rust

rsc

A zero-dependency calculator for solving scientific math equations in strings

streamson-bin

A program which processess large JSON input and splits them into a small ones

rio_turtle

RDF Turtle, Trig, N-Triples and N-Quads parsers and serializers

chomp

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

dynparser

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

pest_derive

pest’s derive macro

lexers

Tools for tokenizing and scanning

honeycomb

A portable parser combinator library that does not require a runtime

scriptful

A minimalist, no_std stack machine library for interpreting domain specific interpreted languages

alder

Parser combinator library inspired by Elm parser error messages

turtle-syntax

RDF Turtle parser

lrlex

Simple lexer generator

char-lex

Create easy enum based lexers

recur-fn

A library that provides you a more flexible way to construct and extend the recursive function

pegtastic

A simple Parsing Expression Grammar (PEG) parser generator

rslua

Yet another Lua lexer and Lua parser for Lua 5.3

glsl-quasiquote

The glsl! procedural macro, providing quasiquoting of the glsl crate

parse_arg

Traits and implementations for parsing command-line arguments

cfgrammar

Grammar manipulation

rule

A rule engine written in rust

extract-frontmatter

A library that allows a user to extract an arbitrary number of lines of “front-matter” from the start of any string

d4t4

A JSON superset

linurgy

Manipulate the output of multiple newlines. Replace/Insert/Append newlines with any string. Input and output from stdio/files/buffers

read_token

A simple library to read tokens using look ahead

alder-derive

Parser combinator library inspired by Elm parser error messages

spell

Spell is a Streaming Parser for Event Logs using an LCS (Longest Common Subsequence)

endf_format

ENDF-6 Format Rust Library

nimbleparse

Simple Yacc grammar debugging tool

parser_fuck

A simple parser combinator library

cmdline_words_parser

Provides iterators over ‘words’ in a string, using command-line escaping rules. Intended for use where extra heap allocations are undesirable

svinst

Determines the modules declared and instantiated in SystemVerilog files, producing a YAML file as output

parse_int

Parse &str with common prefixes to integer values

reformation

Parsing via regular expressions

linereader

An efficient buffered line reader

nom-derive

Custom derive nom parsers from struct

bracket_parse

simple parser for bracketed lists with quoted and unquoted strings – Now deprecated, favouring Gobble instead which can do everything this does much tidier

sexpy

Automatically derivable s-expression parsers for simple programming languages

rstb

Rust library for manipulating Breath of the Wild’s resource size table

automata

An implementation of standard finite state automata such as DFA, NFA, Regex

muncher

Easy to use char muncher for writing a parser

munch

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

endian_codec

(De/En)code rust types as packed bytes with specific order

streamson-lib

Library for splitting large JSONs

enquote

Quotes and unquotes strings

nom5_locate

A special input type for nom to locate tokens

bulk_examples_generator

Create dozens/hundreds/thousands/millions of random examples based on a pest grammar (PEG). It can be used for generate string/structured data for training models in AI, or like a grammar fuzzer for find bugs.

bytelines

Read input lines as byte slices for high efficiency

gearley

An Earley parser engine

mexprp

A math expression parsing and evaluation library

fix_fn

Macro to create recursive closures (similar to the Y combinator)

rna

‘Loot-Table Script’ interpreter

scan-rules

This crate provides some macros for quickly parsing values out of text. Roughly speaking, it does the inverse of the print!/format! macros; or, in other words, a similar job to scanf from C.

pest_consume_macros

Macros for pest_consume

ipdb_rs

IPDB 地址库的 rust 非官方版本

commonregex

Rust port for CommonRegex. Find all times, dates, links, phone numbers, emails, ip addresses, prices, hex colors, and credit card numbers in a string. We did the hard work so you don’t have to.

peel

Dynamic packet parsing within trees

sv-parser-pp

Helper crate of sv-parser

esplugin-ffi

A wrapper library providing a C FFI for esplugin

lrtable

LR grammar table generation

utf8-decode

UTF-8 incremental decoding iterators

wee-peg

A simple Parsing Expression Grammar (PEG) parser generator

text-reader

Text reader

bitmatch

A macro to allow matching, binding, and packing the individual bits of integers

plex

A syntax extension for writing lexers and parsers

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

fast_io

Library crate to read and write &str and types implementing the copy trait into files

pest_meta_tmp

pest meta language parser and validator

untrustended

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

sbp

A quick-and-dirty crate that supports compactly defining parsable structs

codice_fiscale

Tools to calculate and verify Italian codice fiscale

sexp

A small, simple, self-contained, s-expression parser and pretty-printer

markab_parser

A simple, copy-less and rich-error-message parser combinator library

gramatica

A compiler compiler for Rust implementing Earley’s parser

purrchance

An unofficial Rust implementation of the Perchance grammar engine

comment-parser

Extract comments from code in various programming languages

parser-combinators

DEPRECEATED Parser combinators based on the Haskell library parsec. This library has been renamed to combine. See https://crates.io/crates/combine for more recent versions DEPRECEATED

rreplace

rreplace is a rust library designed to streamline string replacements. It can handle multiple unique replacements and iterates the string only once.

earlgrey

A library for parsing context-free grammars using Earley algorithm

parsell

Parsell LL(1) streaming parser combinators

antlr-rust

ANTLR4 runtime for Rust

servicefile

A rust crate for parsing /etc/services

bmfont_parser

Lightweight and easy-to-use bitmap font parser (.sfl and .fnt files)

yard

shunting yard implementation in rust

asn1rs-model

Rust, Protobuf and SQL model definitions for asn1rs

pest_fmt

gll-pg-core

A parser generator for GLL grammar, core library

ipv6_rs

网上分享的 ipv6 地址库解析

beatmap_parser

Parse beatmap information, the fast way

paw-raw

Traits to implement custom Paw implementations

gll-pg-macros

A parser generator for GLL grammar, macros part

parse_list

Parse files and lists of stringified things into lists of thingified things

entab

Record-format file reader

abortable_parser

A parser combinator library with an emphasis on error handling

endian_codec_derive

Macros implementation for endian_codec crate

input-stream

IO streams similar to C++’s streams

newbee

this is a rdb streamed parser

whatsapp-export-parser

A utility for parsing the text file you get when exporting a WhatsApp conversation

rusttyc

A library for writing type checkers with a lattice-like type system in rust. Provides a simple and intuitive interface to an underlying union-find implementation.

NameParser

A library for parsing person names into their individual components

list_flattener

Parses and flattens lists of integer values

get-random-const

Simple compile-time random generator

fancy_slice

A library that provides reflection for tree structures

rust_admob_ssv

A rust implementation for verifying admob ssv callback requests using openssl

grammar_tool

A tool for understanding LL(k) grammars

c3p0_pool_pg

A good friend for r2d2

dewey

version parser and comparator that works with non-semantic versions

prattle

General, configurable Pratt/TDOP parser

intoif

A small library for construction of an Option and Result from any type based on some user-specified condition

peruse

A small parser combinator library

cursortanium

A solid cursor for Rust

lindenmayer-system

Parametric Lindenmayer-Systems

xxcalc

Embeddable or standalone robust floating-point polynomial calculator

streamson-tokio

Tokio and streamson integration library

lalr

a library for creating LALR(1) parsers from context-free grammars

gmime

Bindings for gmime-3.0

prange2

Parse numeric ranges for indexing

aemo_mdff

AEMO compliant NEM12 and NEM13 parser

sexpy_derive

Derives sexpy trait definitions for types

proc-macro-util

Utilities to implement procedural macros

perplex-runtime

Runtime library for parsers generated by perplex

asn1rs-macros

Macros for asn1rs

san-rs

A library for parsing standard algebraic notation (SAN)

combpop

Type-based parser combinator

rusty-peg

A macro for defining PEG parsers

combine-proc-macro

Support for using combine parser combinators with the proc_macro API

shunting

A library for evaluating math expressions

c3

Complete C AST. Enables analysis and generation of code derived from C. Built using LLVM 4/Clang using some fragile C++ APIs to work around missing data and ambiguities in libclang.

lalrpop-snap

convenient LR(1) parser generator

chars_input

chars input

commonregex_rs

🔎 Find common expressions in a string

nom-trace

A tracer for nom parsers

indent-stack

Library for parsing off-side syntax like YAML or Python

sv-parser-error

Helper crate of sv-parser

skimmer

Simple streams reader

oak_runtime

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

scan

Crate for tokenizing and parsing delimitted input

lsystem

A Library for building L-Systems in rust

regex-lexer

A regex-based lexer (tokenizer)

combine-language

Extra parser combinators, useful for parsing programming languages

tree-sitter-tags

Library for extracting tag information

strom

A str-oriented, nom inspired zero-copy parser combinators library

rcombinators

A parser combinator library in rust