Lib.rs

smallvec

‘Small vector’ optimization: store up to a small number of items on the stack

generic-array

Generic types implementing functionality of arrays

bytes

Types and traits for working with bytes

arc-swap

Atomically swappable Arc

arrayvec

A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.

predicates

An implementation of boolean-valued predicate functions

hashbrown

A Rust port of Google’s SwissTable hash map

hdrhistogram

A port of HdrHistogram to Rust

bit-vec

A vector of bits

priority-queue

A Priority Queue implemented as a heap with a function to efficiently change the priority of an item

bitvec

A crate for manipulating memory, bit by bit

num

A collection of numeric types and traits for Rust, including bigint, complex, rational, range iterators, generic integers, and more!

crdts

Practical serializable thoroughly tested CRDTs (ORSWOT, counters, LWW) ported from riak_dt

ndarray

An n-dimensional array for general elements and for numerics. Lightweight array views and slicing; views support chunking and splitting.

scroll

A suite of powerful, extensible, generic, endian-aware Read/Write traits for byte buffers

tinystr

A small ASCII-only bounded length string representation

staticvec

Implements a fixed-capacity stack-allocated Vec alternative backed by an array, using const generics

bimap

Bijective maps

linked-hash-map

A HashMap wrapper that holds key-value pairs in insertion order

rpds

Persistent data structures with structural sharing

radix_trie

Generic radix trie data-structure

merkle-cbt

A library for generating efficient Merkle tree and combined Merkle proof based on complete binary tree

im-rc

Immutable collection datatypes (the fast but not thread safe version)

array-init

Safe wrapper for initializing fixed-size arrays

enum-ordinalize

This crates provides a procedural macro to let enums not only get its variants’ ordinal but also be constructed from an ordinal

indextree

Arena based tree structure by using indices instead of reference counted pointers

sized-chunks

Efficient sized chunk datatypes

indexmap

A hash table with consistent order and fast iteration. The indexmap is a hash table where the iteration order of the key-value pairs is independent of the hash values of the keys. It has the usual…

enumset

A library for creating compact sets of enums

tinyvec

tinyvec provides 100% safe vec-like data structures

either

The enum Either with variants Left and Right is a general purpose sum type with two cases

spade

Spatial datastructures like r-trees and delaunay triangulations for rust

linked_hash_set

HashSet with insertion ordering

generator

Stackfull Generator Library in Rust

starling

This tree structure is a binary merkle tree with branch compression via split indexes

sharded-slab

A lock-free concurrent slab

rust_decimal_macros

Shorthand macros to assist creating Decimal types

heapless

static friendly data structures that don’t require dynamic memory allocation

modular-bitfield

Allows to easily define bitfield types with modular building blocks

bit-set

A set of bits

enum-map

A map with C-like enum keys represented internally as an array

bv

Bit-vectors and bit-slices

qp-trie

An idiomatic and fast QP-trie implementation in pure Rust, written with an emphasis on safety

molecule

Rust bindings for molecule

anymap

A safe and convenient store for one value of each type

llvm-ir

LLVM IR in natural Rust data structures

hdf5

Thread-safe Rust bindings for the HDF5 library

cidr-utils

This crate provides data structures and functions to deal with IPv4 CIDRs and IPv6 CIDRs

convenient-skiplist

Convenient and Performant SkipList with serde support

rusty_ulid

Rust ULID (Universally Unique Lexicographically Sortable Identifier) generation and processing

vec_map

A simple map based on a vector for small integer keys

user-error

UserFacingError is an error crate that allows you to pretty print your errors and error chain for consumption by the end user. If you implement the UFE trait, the default implementation…

ansi_term

Library for ANSI terminal colours and styles (bold, underline)

fraction

Lossless fractions and decimals; drop-in float replacement

id_tree

A library for creating and modifying Tree structures

binary-heap-plus

Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps

guppy

Track and query Cargo dependency graphs

daggy

A directed acyclic graph data structure library. It is Implemented on top of petgraph’s Graph data structure and attempts to follow similar conventions where suitable.

patricia_tree

Memory-efficient data structures based on patricia tree

roaring

http://roaringbitmap.org : A better compressed bitset - pure Rust implementation

rstar

R*-tree library for the rust ecosystem

landon

A collection of tools, data structures and methods for exporting Blender data (such as meshes and armatures) and preparing it for your rendering pipeline

typescript-definitions-ufo-patch

serde support for exporting Typescript definitions

slice-dst

Slice-based custom DSTs

string-interner

Efficient string interner with minimal memory footprint and fast access to the underlying strings

ucd-trie

A trie for storing Unicode codepoint sets and maps

kdtree

K-dimensional tree in Rust for fast geospatial indexing and nearest neighbors lookup

vob

Vector of Bits with Vec-like API and usize backing storage

wide

A crate to help you go wide

string

A UTF-8 encoded string with configurable byte storage

intrusive-collections

Intrusive collections for Rust (linked list and red-black tree)

typed-index-collections

Typed index version of Rust slice and Vec containers

abi_stable_shared

Implementation detail of abi_stable

sorted-iter

Typesafe extensions for sorted iterators, including set and relational operations

vec1

a std Vec wrapper assuring that it has at least 1 element

rc-u8-reader

A tiny implement for reading u8 data from a reference counted instance

index_vec

Newtype-style helpers for Vec and usize

defaultmap

Provides a HashMap with an automatic default for missing keys

uluru

A simple, fast, LRU cache implementation

hashlink

HashMap-like containers that hold their key-value pairs in a user controllable order

arr_macro

Initialize arrays with ease!

vec-collections

Rust collections that are newtype wrappers around smallvec

bloomfilter

Bloom filter implementation

hex2d

Helper library for working with 2d hex-grid maps

trk-io

TrackVis (*.trk) reader and writer

hash_hasher

A hasher which is designed to work with already-hashed or hash-like data

rangemap

Map and set data structures whose keys are stored as ranges. Contiguous and overlapping ranges that map to the same value are coalesced into a single range

trees

General purpose tree data structures

slice-deque

A double-ended queue that Deref’s into a slice

flatk

Flat layout abstraction toolkit

fid

FID (Fully Indexable Dictionary) implementation for Rust

arccstr

Thread-safe, reference-counted null-terminated immutable strings

codemap

A data structure for efficiently storing source code position and span information (e.g. in a compiler AST), and mapping it back to file/line/column locations for error reporting and suggestions.

retworkx

A python graph library implemented in Rust

bitlab

Extracting a range of bits from a binary data source

c_vec

Structures to wrap C arrays

redo

Provides advanced undo-redo functionality with static dispatch

threshold

Threshold data structures

fallible_collections

a crate which adds fallible allocation api to std collections

dync

An efficient alternative to dyn Trait for containerized types

flat-tree

Rust module for encoding/decoding varints that doesn’t do any IO. Inspired by the Node.js varint module

min-max-heap

An efficient, double-ended priority queue

ena

Union-find, congruence closure, and other unification code. Based on code from rustc.

graphlib

Graphlib is a simple and powerful rust library for the graph data-structure

cmdtree

(Rust) commands tree

hibitset

Hierarchical bit set structure

kstring

Key String: optimized for map keys

zbus_macros

proc-macros for zbus

json_dotpath

Dotted path access to nested JSON objects (serde_json::Value)

petgraph

Graph data structure library. Provides graph types and graph algorithms.

fixedbitset

FixedBitSet is a simple bitset collection

kserd

Kurt’s Self-Explanatory Rust Data

contest-algorithms

Common algorithms and data structures for programming contests

tiled

A rust crate for loading in maps created by the Tiled editor

toodee

A lightweight 2D wrapper around a Vec

egg

An implementation of egraphs

treeflection

A library that provides reflection for tree structures

stackvector

StackVec: vector-like facade for stack-allocated arrays

keyvi

Keyvi - the key value index. It is an in-memory FST-based data structure highly optimized for size and lookup performance.

rustfst

Library for constructing, combining, optimizing, and searching weighted finite-state transducers (FSTs)

griddle

A HashMap variant that spreads resize load across inserts

typescript-definitions

serde support for exporting Typescript definitions

cedarwood

efficiently-updatable double-array trie in Rust (ported from cedar)

abin

A library for working with binaries and strings. The library tries to avoid heap-allocations / memory-copy whenever possible by automatically choosing a reasonable strategy: stack for…

smallbitvec

A bit vector optimized for size and inline storage

ordered-multimap

Insertion ordered multimap

ndarray-stats

Statistical routines for ArrayBase, the n-dimensional array data structure provided by ndarray

ringbuffer

A fixed-size circular buffer

probabilistic-collections

Various implementations of collections that use approximations to improve on running time or memory, but introduce a certain amount of error

slab_tree

A vec-backed tree structure with tree-specific generational indexes

suff_collections

Fast realization of suffix array and suffix tree

ndsparse

Sparse structures for N-dimensions

intervaltree

A simple and generic implementation of an immutable interval tree

persist-o-vec

A Vec type that aims to have stable indices and memory location

plain

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

panoradix

A generic map and a set, both backed by a Radix tree

pagetable

simple wait-free two-level pagetable with 2mb pages

cactus

Immutable parent pointer tree

trie-root

In-memory patricia trie operations

bitvector

BitVector implementation in Rust

treez

A collection of useful data structures

nanoset-py

A memory-optimized wrapper for Python sets likely to be empty

diffus

Finds the difference between two instances of any data structure. Supports: collections, Strings, Maps etc. Uses LCS where applicable. Also supports derive via diffus-derive.

rust-fsm

A framework for building finite state machines in Rust

leveled-hash-map

A structure to separate values into different levels with keys. Every key-value entry which is not at the top level has a parent key at the superior level. Keys at the same level are unique…

macaddr

MAC address types

daab

DAG aware artifact builder

numeric-array

Wrapper around generic-array that adds efficient numeric trait implementations

sparse-bitfield

Bitfield that allocates a series of small buffers

optional

This crate supplies a number of Option-like primitive types

feattle

Featture toggles for Rust, extensible and with background synchronization and administration UI

rsdict

Fast static rank and select data structure

immutable-chunkmap

A cache efficient immutable map and set with lookup performance equivalent to BTreeMap and BTreeSet, fast batch insert and update methods, and efficient implementations of all set operations

voluntary-servitude

Thread-safe appendable list with lock-free iterator

ternary-tree

A Rust implementation of Ternary Search Trees, with no unsafe blocks

smartstring

Compact inlined strings

cervine

A slightly more flexible Cow; roughly to T: Borrow as alloc::borrow::Cow is to B: ToOwned

subset-map

A map where the keys are subsets of an initial set of elements

byte_set

Efficient sets of bytes

tri-mesh

A triangle mesh data structure including basic operations

histogram

histogram storage and percentile metrics with precision guarentees

outils

Graph and tree data structure library. Providing utilities which aren’t easily available in Rust.

vec-dimension-shift

N-Dimension shift features for Vec

yyid

Yyid generator (random tokens like UUIDv4, but using all the bits)

timely_communication

Communication layer for timely dataflow

intrusive_splay_tree

An intrusive splay tree implementation that is no-std compatible and free from allocation and moves

blender-armature

Serialize / deserialize Blender armatures

compt

A complete binary tree visitor library

circular-queue

A circular buffer-like queue

nibble_vec

Vector data-structure for half-byte values

concread

Concurrently Readable Data-Structures for Rust

ahtable

Array Hash Table implementation

dlv-list

Semi-doubly linked list implemented using a vector

im

Immutable collection datatypes

vmm-sys-util

A system utility set

ego-tree

Vec-backed ID-tree

queues

Efficient FIFO Queue data structures

beach_map

Implementation of a slotmap

array-macro

Array multiple elements constructor syntax

usher

Parameterized routing for generic resources in Rust

sum

General-purpose sum types

bit_mask_ring_buf

A fast ring buffer implementation with cheap and safe indexing

ibuilder

Interactive builder for Rust types

keyed_priority_queue

Priority queue that support changing priority or early remove by key

option_set

Bitflags on steroids

generational-indextree

Arena based tree structure by using indices instead of reference counted pointers

rle_vec

A vector like struct that stores data as runs of identical values. Useful for storing sparse data.

large_int

An ease-of-use unbounded signed integer

space

A library providing abstractions for spatial datastructures and search

exonum-merkledb

Persistent storage implementation based on RocksDB which provides APIs to work with Merkelized data structures

verify

A validation library

simple_endian

A create for defining endianness within your data structures, to make handling portable data structures simpler

gapbuf

Generic gap buffer

sortedvec

a sorted vector that enables quick lookups

fixed-map

A fixed map where storage layout is calculated by a procedural macro

fwdlist

A simply linked (forward) list

merkle

Merkle tree implementation with support for generation of inclusion proofs

misc_utils

A small collection of convenient and utility functions developed for personal use

binn-ir

An implementation of Binn - https://github.com/liteserver/binn

cast-rs

A collection of types cast for Rust

genmap

A simple generational map data structure with no dependencies

vec-utils

vector utilities

rust_decimal_macro_impls

Shorthand macros to assist creating Decimal types. Do not depend on this directly; use rust_decimal_macros

base_custom

Use any characters as your own numeric base and convert to and from decimal

disjoint-sets

Three union-find implementations

flatgeobuf

FlatGeobuf for Rust

designal

Procedural macro for use with futures-signals

floating_bar

Representing rational numbers using the floating-bar number type

exponential-decay-histogram

A histogram which exponentially weights in favor of recent values

identifier

Generate 128 bits id structs easily

pl-hlist

Provides support for heterogeneous lists (known as HLists), which are functional, tuple-like, strongly-typed data structures that can contain elements of differing types

lignin

A virtual DOM structure, primarily for web use

bitmaps

Fixed size boolean arrays

rc-borrow

Borrowed forms of Rc and Arc

signrel

Trait expressing relationship between integers of different signedness

hopscotch

A FIFO queue for efficiently hopping and skipping between tagged items

watermark

A simple watermarking set for in-order insertions

rustc-ap-rustc_data_structures

Automatically published version of the package rustc_data_structures in the rust-lang/rust repository from commit 4167d731dcaed3a37217f8850b27d30cbde5f15b The publishing script for this crate lives at: https://github…

patricia_router

Radix Tree implementation for Rust

broccoli

broadphase collision detection algorithms

sbitty

library defining bitwise operations on standard integers type

index-ext

Index slices with arbitrary ints and as arrays

vector-map

VecMap<K, V>: a Linear Search with Map API

undo

Provides simple undo-redo functionality with dynamic dispatch

nested

A memory efficient container for nested collections (like Vec<String> or Vec<Vec<T>>)

petal-clustering

A collection of clustering algorithms

fm-index

FM index and its variant implementations for Rust

granite

Generic backing storage framework for building data structures

tst

Ternary search trie collection in rust with similar API to std::collections as it possible

gridly

A library for managing fixed-size 2D spaces

rc-writer

A tiny implement for writing data to a reference counted instance

moving_min_max

Tracking minimum or maximum of sliding windows

big_unsigned_ints

A Crate For Big Unsigned Integers ranging from U256 to U2048 using u64 arrays all under a fixed-size of 32

bounded-spsc-queue

A bounded SPSC queue

intmap

Specialized HashMap for u64 keys

one_way_slot_map

An implementation of SlotMap with minimal restrictions on Keys and Values

scapegoat

Ordered set and map data structures via an arena-based scapegoat tree

iterable

An iterable library for Rust collection like types

charcoal

Implements tree data structures and interfaces to work with them

stash

An amortized O(1) table for cases where you don’t need to choose the keys and want something faster than a HashTable

kvdb-rocksdb

kvdb implementation backed by RocksDB

serde_single_or_vec

Type which can be deserialized from either a sequence or a single value

lz_diet

An AVL balanced Discrete Interval Encoding Tree

bitwrap

pack/unpack data into byte array

terms

Tree terms and patterns data structures

fenwick

Fenwick tree: data structure that efficiently calculates prefix sums in a changing array of numbers

typed_index_collection

Manage collection of objects

skiplist

Skiplist implementation in rust, providing fast insertion and removal. A normal skiplist is implemented, as well as an ordered skiplist and a skipmap.

buffer-trigger

A data collection trigger based on the maximum number and refresh time

xml-schema

Structure generator from XSD source file

slist

Algebraic lists with statically determined size that live on stack

slabmap

HashMap-like collection that automatically determines the key

ppar

Persistent immutable array

simd_aligned

Safe and fast SIMD-aligned data structures with easy and transparent ‘flat’ access

plum

Probabilistic data structures for rust

pair_macro

Create types consisting of the same type values such that Pair, Triplet, and so on

alloc-wg

Attempt of collection several proposals of the allocators-wg

simple_bitfield

Create bitfields with the same memory structure as integers using a simple macro

shortlist

An efficient data structure to track the largest items pushed to it

staticsort

Implements a macro providing a compile-time quicksort function for arrays of any length, containing any primitive Copy type with a PartialOrd implementation

sparsevec

Compress vectors using row displacement

chainkov

HashMap / Tuple-backed Markov Chains

multiref

Multireferences: a safe way to do [&T] -> &[T]

sea-canal

Identifies patterns in sequences of integers

vast

Verilog AST library

osproto

Protocol structures for OpenStack API

treers

Simple implementation of Sedgewick’s tree maps

cmp_wrap

Let you compare structes by context

onigiri

This crate is a tool of handling chars

rb_tree

A Red Black Tree implementation in Rust

nested_intervals

nested & overlapping interval set functions, overlap, union, etc

grid

Dynamic generic 2D data structure

strchunk

Data types for working with UTF-8 text in I/O

keylist

Elixir keyword list in Rust

mset

A mset / multiset / bag implementation

kd-tree

k-dimensional tree

numas

numas library is implementation of multidimensional array for efficient computing

mori

An orientation library built around commonly used orientation representations used in crystallography and engineering applications. It contains conversion, rotation, and data analysis…

csv2json

Converts CSVs into JSON documents

chainmap

A ChainMap with mutability of intermediate maps

bloom

Fast Bloom Filter and Counting Bloom Filter implementation

ulid

a Universally Unique Lexicographically Sortable Identifier implementation

galemu

Provides a workaround for generic associated types (GAT) limited to lifetimes (GAL)

jirachi

A collision resistant runtime agnostic key-generator

skiplist-rs

Skip list is a kind of ordered map and can store any value inside. See skip list wikipedia page to learn more about this data structure.

idlset

Fast u64 set operations library

webe_id

Unique ID generator based on Snowflake, but for us wizards

splay_tree

Splay Tree based Data Structures (map, set, heap)

bucket_vec

A vector-like data structure that guarantees to never move its contained elements

erasable

Type-erased thin pointers

orderbook

Orderbook for Rust

rexsgdata

Scatter-Gather Data Descriptors

succinct_rs

Succinct Data Structures library for Rust

bucket_queue

A Bucket Queue data structure that can be used as a Priority Queue

text-style

Types and conversions for styled text

flit

Bloom filter backed by xxHash

code_location

A library to automatically acquire a code location in a rust source code file

strict

NonEmptyVec, a vec guaranteed to hold at least one element

index-fixed

convert slices into arrays using indexes ([T] -> [T;N])

resources

Safe store for one value of each type, with interior mutability

avl

A map and a set implemented with an AVL tree

sgf-parse

A parser for the SGF file format for Go games

mofurun

Multi variant Optimized Fun U….okay Mofu is just a cute name okay. Experimental implementation of Vec that stores the state of the underlying array through its enum.

sbf

Spatial Bloom Filter, a probabilistic data structure that maps elements of a space to indexed disjoint subsets of that space

idcontain

Generational (or tagged) ID-based containers

grammers-tl-types

Rust definitions for Telegram’s API types and functions

enso-data

A collection of useful data structures

safe_index

Type-safe indexes

midas_cli

Rust port of MIDAS (Microcluster-Based Detector of Anomalies in Edge Streams)

slack-blocks

Models + clientside validation for Slack’s JSON Block Kit

stable-vec

A Vec-like collection which guarantees stable indices and features O(1) element deletion (semantically similar to Vec<Option<T>>). Useful for allocations in graphs or similar data structures.

succinct

Succinct data structures for Rust

building_blocks_storage

Efficient storage for maps on sparse or dense, 2D and 3D integer lattices

predicates-tree

Render boolean-valued predicate functions results as a tree

simple-matrix

A simple generic matrix library

wccg-models

WCCG Data

boolvec

A vector of boolean stored contiguously in memory

radix-tree

A radix tree implementation for router, path search

liblet

Library for learning about formal languages and grammars

uuid-rs

A Simple Universally Unique IDentifier (UUID)

higher_order_functions

A small collection of traits for implementing higher order functions

quickscope

Multi-layer HashMap and HashSet implementations for performant representation of variable scopes

modular-bitfield-impl

Bitfields for structs that allow for modular use of enums

passive

A trio of marker traits to classify passive data structures

stack

DSTs and arrays on the stack!

minivec

A version of Vec that’s only the size of a single pointer

mediumvec

Vector types optimized for space, including a 32-bit Vec

tiny_ecs

A tiny ECS that tries to avoid unnecessary copy/clones

alg_ds

Algorithms & data structures

static_type_map

A type map that works over all types implementing Any

unstructured

Generic types for unstructured data

rudac

A crate for common data structures and algorithms

libnv

Safe and rustic wrapper around libnv-sys

attr

attr is a library to provide external access to a datastructure through a typed path object, using all type information known about the data structure at hand

theban_interval_tree

A simple Interval Tree implementation

swaybar-types

A library for building swaybar status commands in rust

todo_lib

Collection of utilities for todo.txt format

gen-vec

Vector indexed with generational indices

bittyset

A BitSet type for manipulating bit sets

ic-types

Types related to the Internet Computer Public Specification

moniker

Automatically derive variable binding and alpha equivalence for abstract syntax trees

smart_access

A minimalistic “lazy bidirectional pointer” framework

fingertrees

Immutable persisten finger trees

elsa

Append-only collections for Rust where borrows to entries can outlive insertions

polytype

A Hindley-Milner polymorphic typing system

multipath

A library to split file path, like /home/{user,admin}/file.txt

vec-tree

A safe tree using an arena allocator that allows deletion without suffering from the ABA problem by using generational indices

k2_tree

A space-efficient representation of sparsely populated bit-matrices

pvec

RRB-Tree based persistent vector implementation

arraystring

Fixed capacity stack based generic string

mown

Maybe owned values. Wrappers for values that can be either owned or borrowed.

queue-file

queue-file is a lightning-fast, transactional, file-based FIFO

ensure

Ensure target state of an object

imag-id-in-collection

Part of the imag core distribution: imag-ids command

guppy-summaries

Build summaries for Cargo, created by guppy

intervallum

Generic interval and interval set library

hash-rings

Implementations of various hash rings

trie-bench

Standard benchmarking suite for tries

wavelet-matrix

A wavelet matrix implementation. Supports various near-O(1) queries on large number of symbols or integers.

extindex

Persisted immutable index

iset

This crates implements map and set with interval keys

smallstr

String-like container based on smallvec

growable-bitmap

A growable (and shrinkable) compact boolean array

hashable_rc

Hashable wrappers for reference countings

chainbuf

Fast chained buffers

hash-chain

A tiered hashmap and hashset implementation that allows for easily representing lexically scoped variables

friendly_id

The FriendlyID library converts a given UUID to a URL-friendly ID which is based on Base62

exprz

An Expression Library

derive_wrapper

Rust custom derive macro for wrapping types

bip_metainfo

Parsing and building of bittorrent metainfo files

manhattan-tree

A spatial tree which can effiently find closest key to a point, by manhattan distance

backtracking_iterator

A simple implementation of a generic iterator with an item history, capable of backtracking and forgetting

bex

A rust library for working with boolean expressions (syntax trees, decision diagrams, algebraic normal form, etc.)

radix-heap

Fast monotone priority queues

block-grid

A quick, cache-conscious, tiled 2D array

isolanguage-1

ISO 639-1 library with optional Serde support

poisson

Poisson-disk distribution generator

atone

A VecDeque and Vec variant that spreads resize load across pushes

cow_vec_item

Copy-on-write Vec, available on stable rust

nave

Thinking about the construction of distributed systems starting from the consistent hash algorithm

multiset

Multisets/bags

thin-slice

An owned slice that packs the slice storage into a single word when possible

version-rs

A struct for Versions, with the methods you expect

packed-integers

A growable array for integer types in the range u1 to u31

sequencetree

a new type of collection to store keys and their corresponding values

aligned-bytes

A continuous fixed-length byte array with a specified alignment

guzzle

A derivable trait for consuming key value pairs into structs

dcc-lsystem

An implementation of a Lindenmayer system together with some rendering tools

static_merkle_tree

Static Merkle Tree is dedicated for generating Merkle Root and Merkle Proof for a static list of items

ffi-convert

A collection of utilities to ease conversion between Rust and C-compatible data structures

simple-rate-limit

Rate limit enforcement as simple data structures, no atomics

path-value

Universal type and access property(s) by path

pl-lens

Provides support for lenses, which are a mechanism in functional programming for focusing on a part of a complex data structure

packedvec

Store vectors of integers efficiently

rbl_circular_buffer

A zero-allocation, fast, circular buffer implementation in Rust

collectable

Fallible, no_std-friendly collection traits

kvdb

Generic key-value trait

ejdict_rs

This library is an English-Japanese dictionary that can be used via implemented API by Rust language

pciids

A library to parse the pci.ids data file

cvrdt-exposition

Understanding Convergent Replicated Data Types

slice-of-array

Extension traits for casting between slices and slices of arrays. (&[T] <-> &[[T; n]])

iowrap

Small helpers for using io::Read/io::Write

dicom-dictionary-std

Standard DICOM attribute dictionary

lending-library

A key-value store that loans full ownership of items

rustz

A library for functional programming in Rust

multiformats

Multiformat specifications in rust-lang

hat_trie

A hat-trie implementation that support prefix match iteration

string_map

Create a record to store any type of value

atree

An arena based tree structure with removal support

spool

Simple object pool for upfront allocation!

sqa-bounded-spsc-queue

A bounded SPSC queue (temporary version so I can publish sqa-engine)

handy

A library providing handles and handlemaps

containers

Containers

string-wrapper

A possibly-stack-allocated string with generic bytes storage

relational_types

Manage relations between objects

gsrs

Generic Self Referencing Struct

dary_heap

A d-ary heap

checked

Implements a wrapper over the primitive Rust types that better indicates overflow during arithmetic

Project2

Implementations of red black tree and AVL tree

inspector

General purpose inspection for popular data structures

hash_ring

Consistent Hashing library for Rust

const-buffer

A fixed-capacity memory buffer allocated on the stack using const generics

bonzai

An abstraction for optimizing the memory layout and pointer aliasing of trees

range

A library for range addressing

jagged_array

Owned [[T]]-like 2D array where each row can differ in length

alphabet-macro

Provides a macro that can be used to easily create const alphabets

xi-rope

A generic rope data structure built on top of B-Trees

pour

Optionally consed radix tries for fast set operations

bet

Helps parsing and evaluating binary expression trees

om2

A set of classes generated from the OM2 RDF schema (mainly Unit)

stable_bst

An ordered map and set based on a binary search tree. Works with stable Rust 1.9.0.

smart-hash

partial queries in HashSets, the traits

array_ext

Extra functionality for Rust arrays

mop-structs

Low-level structures for MOP

aci_ppm

Encode and decode PNM image files (TODO: so far only PPM)

fixed-vec-deque

A fixed-size, zero-allocation circular buffer for Rust

grafana-dashboard

grafana import/export data serializable structures

watchface

A smartwatch watchface implementation

puruda-macro

proc macro for puruda

python-packed-resources

Manage data structures containing Python resources

data_reader

A data loading library for data scientist

isomorphism

2 directional hashmaps

bitrush-index

A serializable bitmap index library able to index millions values/sec on a single thread

zerobuf

A growable chunk of zeroed memory

fuzzy_trie

Key-value collection to make fuzzy searches

dusk-kelvin-map

BST Map implementation with Microkelvin backend

indexed_vec