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

logos

Create ridiculously fast Lexers

combine

Fast parser combinators on arbitrary streams with zero-copy support

lexical

Lexical, to- and from-string conversion routines

tree-sitter

Rust bindings to the Tree-sitter parsing library

pest_consume

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

vte

Parser for implementing terminal emulators

evalexpr

A powerful arithmetic and boolean expression evaluator

peg

A simple Parsing Expression Grammar (PEG) parser generator

needletail

FASTX parsing and k-mer methods

jomini

Low level, performance oriented parser for save and game files from EU4, CK3, HOI4, Imperator, and other PDS titles

atoi

Parse integers directly from [u8] slices in safe code

lalrpop

convenient LR(1) parser generator

pest_generator

pest code generator

lrpar

Yacc-compatible parser generator

sv-parser-syntaxtree

Helper crate of sv-parser

glue

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

utf8parse

Table-driven UTF-8 parser

nom_locate

A special input type for nom to locate tokens

pest_derive

pest’s derive macro

bnf

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

rusticata-macros

Helper macros for Rusticata

streamson-lib

Library for processing large JSONs

source-span

Source code mapping and display utilities

btoi

Parse integers directly from ASCII byte slices

lexer

plugin based lexical reader

adapton

programming abstractions for general-purpose incremental computations

lexical-core

Lexical, to- and from-string conversion routines

bitter

Swiftly extracts unaligned bit-level data from a byte slice

pest_meta

pest meta language parser and validator

antlr-rust

ANTLR4 runtime for Rust

rusttyc

A library for writing type checkers with a lattice-like type system in rust

pomelo

Implementation of the Lemon parser generator as a Rust procedural macro

tree-sitter-highlight

Library for performing syntax highlighting with Tree-sitter

gobble

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

synattra

A Syn Attribute Parser Toolkit

lemon-mint

Famous Lemon Parser Generator implemented in rust as library with API

whiteread

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

dangerous

Safely and explicitly parse untrusted / dangerous data

lrlex

Simple lexer generator

nmea-parser

NMEA 0183 parser for AIS and GNSS sentences

bitstream_reader

Reading bit sequences from a byte slice

boolinator

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

tokenizers

Provides an implementation of today’s most used tokenizers, with a focus on performances and versatility

abackus

Parser builder using EBNF

autumn

A recursive descent parser combinator library

pidgin

simple non-recursive grammars

gramatica

A compiler compiler for Rust implementing Earley’s parser

hime_redist

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

pratt

A Pratt parser for Rust

oak

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

ram

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

rustlex

Lexical analysers generator for Rust, written in Rust

asciimath

Mathematical expression parser and evaluator

pom-preview

PEG parser combinators using operator overloading without macros

pcre

Rust wrapper for libpcre

unicode-bom

Unicode byte-order mark detection for files and byte arrays

nlsd

Natural Language Structured Documents

lip

Lip provides powerful parser combinators for creating reusable and flexible parsers

parze

A clean, efficient parser combinator

rspg

Simple LR(1) parser generator library

gnaw

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

sv-parser-error

Helper crate of sv-parser

pest_tmp

The Elegant Parser

dynparser

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

logos-derive

Create ridiculously fast Lexers

dinotree_alg

Dinotree algorithms

nom-packrat

Extension of nom to apply Packrat Parsing

rattle_items_match

Matching is not limited to character strings. I’m trying to make a game AI.

chomp

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

char-lex

Create easy enum based lexers

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.

enso-automata

A finite-automata-based lexing engine

pest_consume_macros

Macros for pest_consume

sitewriter

A sitemap writing library

kanaria

This library provides functions such as hiragana, katakana, half-width and full-width mutual conversion and discrimination

inputparser

Terminal inputs made psuedo code like simple, like Python like simple …… probably xD

gallop

General LL(1) Parser

nom-derive

Custom derive nom parsers from struct

fast_input

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

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.

unbounded-interval-tree

An interval tree working with inclusive/exclusive bounds, as well as unbounded intervals. Provides helpers to fetch overlapping intervals, and difference of intervals.

alder-derive

Parser combinator library inspired by Elm parser error messages

c3p0_pg

A good friend for r2d2

bytelines

Read input lines as byte slices for high efficiency

lib_tcstring

IAB TCF (v1, v2) TCString utilities

stb

Safe Rust API for stb libraries

nifty

A library for generating Deterministic Finite State Automata (DFA)

enquote

Quotes and unquotes strings

lexers

Tools for tokenizing and scanning

entab

Record-format file reader

rsc

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

rule

A rule engine written in rust

tch-serde

Serialize/Deserialize tch-rs types with serde

glsl-tree

Print a GLSL AST to stdout

honeycomb

A portable parser combinator library that does not require a runtime

read_token

A simple library to read tokens using look ahead

endf_format

ENDF-6 Format Rust Library

muncher

Easy to use char muncher for writing a parser

extrablatt

News, articles and text scraper

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

cnf-parser

Efficient and customizable CNF parser for SAT solving

parse_int

Parse &str with common prefixes to integer values

escape_string

Very efficiently parse backslash-escaped strings

nimbleparse

Simple Yacc grammar debugging tool

recur-fn

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

eu4save

Ergonomically work with all EU4 saves (ironman and multiplayer)

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.

rtlola-frontend

A parser and analyzer for RTLola specifications

spell

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

ll

rust logging library

parsers

Parser combinators library

tree-sitter-ruby

Ruby grammar for the tree-sitter parsing library

automata

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

linurgy

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

fix_fn

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

plex

A syntax extension for writing lexers and parsers

peresil

A simple and simplistic string parsing library

scriptful

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

linereader

An efficient buffered line reader

parser_fuck

A simple parser combinator library

yajlish

An event-based json parser with json-ndjson parser

cini

A small callback based library for parsing ini files

pegtastic

A simple Parsing Expression Grammar (PEG) parser generator

nom5_locate

A special input type for nom to locate tokens

peel

Dynamic packet parsing within trees

fdtdump

A implementation of fdtdump in Rust using the fdt-rs library

thin-shunting

A library for evaluating math expressions

str-reader

Simple reader/parser for formatted strings

lrtable

LR grammar table generation

wee-peg

A simple Parsing Expression Grammar (PEG) parser generator

cfgrammar

Grammar manipulation

arma_preset_parser

A simple parser for ArmA 3 HTML launcher presets

get-random-const

Simple compile-time random generator

kwp

An input parser for positive and negative keywords input (e.g: +foo,-bar,+baz)

statemachine-macro

Provides the statemachine!() macro for easily creating statemachines

pretok

A string pre-tokenizer for C-like syntaxes

sexp

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

munch

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

advancedresearch-max_tree

A utility maximizer library based on a maximum tree structure

vtd_xml

VTD-XML, fast XML parser

fast_io

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

utf8-decode

UTF-8 incremental decoding iterators

rflex

Fast lexer code generator for Rust

gearley

An Earley parser engine

sexpy

Automatically derivable s-expression parsers for simple programming languages

streamson-extra-matchers

Extra matchers for streamson library

untrustended

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

markab_parser

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

ipdb_rs

IPDB 地址库的 rust 非官方版本

endian_codec

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

argparse-rs

A simple argument parser, meant to parse command line input. It is inspired by the Python ArgumentParser

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.

look_ahead_items

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

regex2fat

Turn your favourite regex into FAT32

rpmrepo

Crate containing definitions for parsing yum repositry data structures

text-reader

Text reader

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

bmfont_parser

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

mexprp

A math expression parsing and evaluation library

pest_meta_tmp

pest meta language parser and validator

paw-raw

Traits to implement custom Paw implementations

gll-pg-macros

A parser generator for GLL grammar, macros part

yard

shunting yard implementation in rust

ogma

Ogma DSL builder

newbee

this is a rdb streamed parser

nom-tracable

Extension of nom to trace parser

generic-lexer

A generic lexer using a simple match function

asn1rs-macros

Macros for asn1rs

luthor

A collection of lexers for various languages/formats, and the tools required to build them

patternscan

Searches for a contiguous array of bytes determined by a wild-carded pattern

purrchance

An unofficial Rust implementation of the Perchance grammar engine

lemon-tree

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

reformation

Parsing via regular expressions

ytnef

A Rust binding for libytnef. A C library for parsing the TNEF file format used by Microsoft Outlook and Exchange Server.

input-stream

IO streams similar to C++’s streams

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

rreplace

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

fancy_slice

A library that provides reflection for tree structures

char_combinator

An iterator to create all combination of a given char range

sbp

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

obex

A library that handles retrieval, parsing, and updating a copy of the Parallax Obex

substrs

A crate for substring functionality for the str type in Rust

dewey

version parser and comparator that works with non-semantic versions

bitmatch

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

parse_list

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

xxcalc

Embeddable or standalone robust floating-point polynomial calculator

abortable_parser

A parser combinator library with an emphasis on error handling

peruse

A small parser combinator library

tree-sitter-tags

Library for extracting tag information

comment-parser

Extract comments from code in various programming languages

number_words

Parse a number into possible words

lf2_parse

Parses Little Fighter 2 (LF2) data files

tree-sitter-python

Python grammar for the tree-sitter parsing library

gchemol-parser

Text parsing made simple

cursortanium

A solid cursor for Rust

treeline

a library for visualizing tree structured data

earlgrey

A library for parsing context-free grammars using Earley algorithm

pm-lexer

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

lalr

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

parsell

Parsell LL(1) streaming parser combinators

beatmap_parser

Parse beatmap information, the fast way

streamson-generator

A library which integrates streamson with generators

intoif

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

prange2

Parse numeric ranges for indexing

lalrpop-snap

convenient LR(1) parser generator

alder

Parser combinator library inspired by Elm parser error messages

endian_codec_derive

Macros implementation for endian_codec crate

pest_fmt

mathlang

Parse and modify mathematical expressions

simple-parser

A simple, runtime recursive descent parser generator

perplex-runtime

Runtime library for parsers generated by perplex

san-rs

A library for parsing standard algebraic notation (SAN)

lindenmayer-system

Parametric Lindenmayer-Systems

gmime

Bindings for gmime-3.0

rusty-peg

A macro for defining PEG parsers

NameParser

A library for parsing person names into their individual components

shunting

A library for evaluating math expressions

whatsapp-export-parser

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

regular-expression

A library for parsing, compiling, and executing regular expressions

ck3save

Ergonomically work with all CK3 saves (regular and ironman)

list_flattener

Parses and flattens lists of integer values

hexdecode

This crate provides a simple function for parsing hex-encoded strings as a vec

rspg-macros

Macros for rspg

prattle

General, configurable Pratt/TDOP parser

swf-headers

A library for parsing the headers of a swf file

indent-stack

Library for parsing off-side syntax like YAML or Python

enso-flexer

A finite-automata-based lexing engine

combpop

Type-based parser combinator

oak_runtime

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

grammar_tool

A tool for understanding LL(k) grammars

pest-typed-tree

Generates typed tree, based on grammar, allowing reduce .unwrap() count :)

chars_input

chars input

lsystem

A Library for building L-Systems in rust

zig-lexer

Zig lexer

pvm

A parsing virtual machine with a focus on expressibility of grammars

skimmer

Simple streams reader

simple-lexer

A simple, runtime lexer generator

nloq

Natural Language Object Query

combine-proc-macro

Support for using combine parser combinators with the proc_macro API

stdin_parser

Parse stdin by defining a struct

proc-macro-util

Utilities to implement procedural macros

vmfparser

Parser for the Valve Map File format

stb-sys

Low level bindgen generated wrappers for stb libraries

lorawan

Crate lorawan provides structures and tools for reading and writing LoRaWAN messages from and to a slice of bytes

commonregex_rs

🔎 Find common expressions in a string

scan

Crate for tokenizing and parsing delimitted input