Lib.rs

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…

bytes

Types and traits for working with bytes

arrayvec

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

smallvec

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

generic-array

Generic types implementing functionality of arrays

either

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

hdrhistogram

A port of HdrHistogram to Rust

bitvec

A crate for manipulating memory, bit by bit

petgraph

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

linked-hash-map

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

bit-vec

A vector of bits

scroll

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

hashbrown

A Rust port of Google’s SwissTable hash map

ndarray

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

arc-swap

Atomically swappable Arc

slice-deque

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

predicates

An implementation of boolean-valued predicate functions

priority-queue

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

fixedbitset

FixedBitSet is a simple bitset collection

vec_map

A simple map based on a vector for small integer keys

heapless

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

im

Immutable collection datatypes

string

A UTF-8 encoded string with configurable byte storage

crdts

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

bit-set

A set of bits

starling

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

radix_trie

Generic radix trie data-structure

im-rc

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

id_tree

A library for creating and modifying Tree structures

bimap

A fast two-way bijective map implementation

generator

Stackfull Generator Library in Rust

string-interner

An efficient string interning data structure with minimal memory-footprint and fast access to the underlying contents

rpds

Persistent data structures with structural sharing

c_vec

Structures to wrap C arrays

shellexpand

Shell-like expansions in strings

hibitset

Hierarchical bit set structure

kdtree

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

rstar

R*-tree library for the rust ecosystem

sequence_trie

Trie-like data-structure for storing sequences of values

enumset

A library for creating compact sets of enums

indextree

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

rust_decimal_macros

Shorthand macros to assist creating Decimal types

tinystr

A small ASCII-only bounded length string representation

sized-chunks

Efficient sized chunk datatypes

intrusive-collections

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

sharded-slab

A lock-free concurrent slab

enum-map

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

array-init

Safe wrapper for initializing fixed-size arrays

smallbitvec

A bit vector optimized for size and inline storage

ndarray-stats

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

min-max-heap

An efficient, double-ended priority queue

typescript-definitions

serde support for exporting Typescript definitions

staticvec

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

suffix

Suffix arrays

vob

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

adapton

programming abstractions for general-purpose incremental computations

fraction

Lossless fractions and decimals; drop-in float replacement

treeflection

A library that provides reflection for tree structures

undo

Provides undo-redo functionality with dynamic dispatch and automatic command merging

rusty_ulid

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

path-tree

path-tree is a lightweight high performance HTTP request router for Rust

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.

sprs

A sparse matrix library

redo

Provides undo-redo functionality with static dispatch and manual command merging

array-macro

Array multiple elements constructor syntax

abi_stable

For doing Rust-to-Rust ffi,writing libraries loaded at program startup

plain

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

optional

This crate supplies a number of Option-like primitive types

bitlab

Extracting a range of bits from a binary data source

fixed-map

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

patricia_tree

Memory-efficient data structures based on patricia tree

roaring

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

ego-tree

Vec-backed ID-tree

num

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

histogram

histogram storage and percentile metrics with precision guarentees

treebitmap

Fast IPv4/IPv6 lookup trie

arr_macro

Initialize arrays with ease!

stackvector

StackVec: vector-like facade for stack-allocated arrays

enum-ordinalize

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

pagetable

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

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

hash_hasher

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

vec1

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

dinotree_alg

Dinotree algorithms

bcc

Idiomatic Rust bindings for BPF Compiler Collection (BCC)

merkle

Merkle tree implementation with support for generation of inclusion proofs

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.

llvm-ir

LLVM IR in natural Rust data structures

flat-tree

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

ternary-tree

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

rc-u8-reader

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

rust_decimal_macro_impls

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

qp-trie

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

graphlib

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

linear-map

A map implemented by searching linearly in a vector

alloc-wg

Attempt of collection several proposals of the allocators-wg

trk-io

TrackVis (*.trk) reader and writer

transit_model_collection

Manage collection of objects

blender-armature

Serialize / deserialize Blender armatures

structural

Abstractions over fields

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…

voluntary-servitude

Thread-safe appendable list with lock-free iterator

enum-map-derive

Macros 1.1 implementation of #[derive(Enum)]

hash-rings

Implementations of various hash rings

binary-heap-plus

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

splay_tree

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

trees

General purpose tree data structures

abi_stable_shared

Implementation detail of abi_stable

index_vec

Newtype-style helpers for Vec and usize

cmdtree

(Rust) commands tree

merkle-cbt

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

nanoset-py

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

tst

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

slab_tree

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

treez

A collection of useful tree data structures

treeflection_derive

#[derive(Node)] macro for the Treeflection library

smallstr

String-like container based on smallvec

circular-queue

A circular buffer-like queue

unstructured

Generic types for unstructured data

fp_rust

Implement fp features for Rust

transit_model_relations

Modeling the relations between objects

macaddr

MAC address types

intervaltree

A simple and generic implementation of an immutable interval tree

bitmaps

Fixed size boolean arrays

onigiri

This crate is a tool of handling chars

daab

DAG aware artifact builder

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.

bv

Bit-vectors and bit-slices

succinct_rs

Succinct Data Structures library for Rust

rc-writer

A tiny implement for writing data to a reference counted instance

user-error

Simple error type that display in a clear and beautiful manner to the user of a CLI application

compt

A complete binary tree visitor library

cedarwood

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

polytype

A Hindley-Milner polymorphic typing system

queues

Efficient FIFO Queue data structures

fid

FID (Fully Indexable Dictionary) implementation for Rust

cactus

Immutable parent pointer tree

packedvec

Store vectors of integers efficiently

bitrush-index

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

csv2json

Converts CSVs into JSON documents

uluru

A simple, fast, LRU cache implementation

succinct

Succinct data structures for Rust

tiled

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

tiny_ecs

A tiny ECS that tries to avoid unnecessary copy/clones

simd_aligned

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

outils

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

cidr-utils

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

rexsgdata

Scatter-Gather Data Descriptors

numeric-array

Wrapper around generic-array that adds efficient numeric trait implementations

thin-dst

Thin pointers to inline-slice dynamically sized types

rustfst

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

defaultmap

Provides a HashMap with an automatic default for missing keys

molecule

Rust bindings for molecule

nibble_vec

Vector data-structure for half-byte values

nested_intervals

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

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

sparsevec

Compress vectors using row displacement

histogram-sampler

Sampling from a distribution given by a histogram

bounded-spsc-queue

A bounded SPSC queue

stash

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

ordsearch

A data structure for efficient lower-bound lookups

rle_vec

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

progress-streams

Progress callbacks for types which implement Read/Write

modular-bitfield

Bitfields for structs that allow for modular use of enums

fwdlist

A simply linked (forward) list

linked_hash_set

HashSet with insertion ordering

arccstr

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

fingertrees

Immutable persisten finger trees

fm-index

FM index and its variant implementations for Rust

kserd

Kurt’s Self-Explanatory Rust Data

simple_endian

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

galemu

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

radix-tree

A radix tree implementation for router, path search

enum-set

A structure for holding a set of enum variants

atree

An arena based tree structure with removal support

crates-io-cli

Interact with crates.io from the command-line

binn-ir

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

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.

threshold

Threshold data structures

anymap

A safe and convenient store for one value of each type

normalize-line-endings

Takes an iterator over chars and returns a new iterator with all line endings (\r, \n, or \r\n) as \n

base_custom

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

exonum-merkledb

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

debt64

An implementation of Base64 - https://en.wikipedia.org/wiki/Base64

range

A library for range addressing

mucell

A cell with the ability to mutate the value through an immutable reference when safe

numas

numas library is implementation of multidimensional array for efficient computing

rahashmap

Fork of standard library HashMap with additional functionality

elsa

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

dashmap-shard

A Rust port of Google’s SwissTable hash map

nearly_eq

Nearly(Approximately) equal traits and assertion

rangemap

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

appro-eq

Approximately equal traits and assertion

guppy

Track and query Cargo dependency graphs

inspector

General purpose inspection for popular data structures

by_address

Wrapper for comparing and hashing pointers by address

imag-id-in-collection

Part of the imag core distribution: imag-ids command

disjoint-sets

Three union-find implementations

heaparray

Flexible support for dynamically-sized types, using heap-allocated array of structs

predicates-tree

Render boolean-valued predicate functions results as a tree

compare

Experimental comparators for collections to be generic over

libnv

Safe and rustic wrapper around libnv-sys

panoradix

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

multi_mut

Methods on HashMap and BTreeMap for safely getting multiple mutable references to the contained values

intmap

Specialized HashMap for u64 keys

usher

Parameterized routing for generic resources in Rust

idcontain

Generational (or tagged) ID-based containers

exponential-decay-histogram

A histogram which exponentially weights in favor of recent values

bpf-sys

Bindings for libbpf from BCC

sparseset

A Sparse Set

digits

Custom “numeric” incrementor without u64 MAX limit in size. Like a score flipper for a custom character set.

ternary-tree-wasm

A simplified Wasm binding to ternary-tree crate

orderbook

Orderbook for Rust

incremental-topo

Data structure to maintain an incremental topological ordering over a collection of values

map_vec

The Map and Set APIs backed by Vec

contest-algorithms

Common algorithms and data structures for programming contests

big_unsigned_ints

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

sorted-iter

Typesafe extensions for sorted iterators, including set and relational operations

arraystring

Fixed capacity stack based generic string

bit-matrix

Library for bit matrices and vectors

string-wrapper

A possibly-stack-allocated string with generic bytes storage

queue-file

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

crates-index-diff

Learn what’s changed in the crates.io index

bitwrap

pack/unpack data into byte array

fst-regex

Search finite state transducers with regular expression

data_structure_traits

data structure collection traits

guzzle

A derivable trait for consuming key value pairs into structs

diffus-derive

Finds the difference between two instances of any data structure. Supports derive on structs and enums.

snake_case

SnakeCase is a String-like type that can only contain valid non-empty snake_case

bipbuffer

A Rust implementation of Simon Cooke’s Bip-Buffer

wavelet-matrix

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

id-vec

Simplify Graphs in Rust. Introduces IdVec, which automatically creates Ids for each new object, reusing deleted Ids.

bip_handshake

Common handshaking interface as well as a default handshake implementation

smart-hash

partial queries in HashSets, the traits

json_dotpath

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

chainkov

HashMap / Tuple-backed Markov Chains

hashlink

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

avm1-tree

Abstract Syntax Tree (AST) for AVM1

modular-bitfield-impl

Bitfields for structs that allow for modular use of enums

docbook-index

Index a DocBook project in to an elasticlunr-compatible JSON index, for use in static-site XHTML sites

multiset

Multisets/bags

bip_metainfo

Parsing and building of bittorrent metainfo files

gridly

A library for managing fixed-size 2D spaces

tri-mesh

A triangle mesh data structure including basic operations

ensure

Ensure target state of an object

untagged-option

An unsafe Option type without discriminant. Nightly only.

manhattan-tree

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

fixed-vec-deque

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

backtracking_iterator

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

no_vec

A library for modifying sized arrays

bitmaptrie

Bitmapped vector trie (mutable, not persistent). Word-size path-cached indexing into essentially a sparse vector. Requires rust-nightly.

ejdict_rs

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

toolbox

Simple tools for daily use

bucket_queue

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

checked

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

sea-canal

Identifies patterns in sequences of integers

non-empty-collections

Non-empty hash-map and hash-set implementations

redbpf-macros

Procedural macros for redbpf

static_merkle_tree

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

fungi-lang

Fungi: A typed, functional language for programs that name their cached dependency graphs

floating_bar

Representing rational numbers using the floating-bar number type

keyed_priority_queue

Priority queue that support changing priority or early remove by key

free-ranges

An efficient data structure for keeping track of indices which are either free or not

bex

A rust library for working with boolean expressions (expression trees, decision diagrams, etc.)

sliding_extrema

Queue data structure with support for an O(1) extrema function over contents (for example, to obtain min and max over a sliding window of samples)

jyx

Command line tool for manipulating data structures

afi

Audio & video structures, plus encoder & decoder traits

gtrie

Generic trie implementation with a support of different key and value types

handy

A library providing handles and handlemaps

enum_vec

Efficiently store a vector of enum variants as a packed n-bit vec

matmath

Matrix and Vector Math with generic type elements

simple-matrix

A simple generic matrix library

divsufsort

Rust port of Yuta Mori’s divsufsort

mediumvec

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

trie

An ordered map and set based on a trie

watermark

A simple watermarking set for in-order insertions

vec3

vec3

radix-heap

Fast monotone priority queues

redbpf-probes

eBPF probe-related types for redbpf

ami

Useful data structures that are not in the standard library

moniker

Automatically derive variable binding and alpha equivalence for abstract syntax trees

kailua_env

Basic environments for Kailua

vec-tree

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

poisson

Poisson-disk distribution generator

hedge

An index based half-edge mesh implementation

osproto

Protocol structures for OpenStack API

isomorphism

2 directional hashmaps

trek-router

A flexible router for RESTful APIs

tiled-json-rs

A crate to parse and interact with Tiled editor JSON files

atomic-take

Atomically take a value out of a container once

atlatl

Double-array tries

region_buffer

A growable array allowing for multiple mutable non overlapping regions

tinyvec

Just, really the littlest Vec you could need. So smol.

big_enum_set

A library for creating sets of enums with a large number of variants

slice-of-array

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

semver-store

An HashMap structure that uses semver strings as keys

vec2

vec2

genmap

A simple generational map data structure with no dependencies

restor

A dynamic resource storage system in rust

json-trait-rs

Rust interface (aka trait) to deal with objects as they are JSON objects

lz_diet

An AVL balanced Discrete Interval Encoding Tree

mju-bits

no_std typed bitfield access for u8, u16, u32 and u64

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.

guzzle-derive

The derive macro for guzzle, please use that crate not this one

froggy

Froggy is a prototype for the Component Graph System programming model. It aims to combine the convenience of composition-style Object-Oriented Programming with the performance close to Entity-Component Systems

enum_set2

A bit-set indexed by enum variants

extindex

Persisted immutable index

bip_utracker

Communication with bittorrent UDP trackers

rust-fsm

A framework for building finite state machines in Rust

graphrepresentations

A crate providing efficient abstract implementations of different graph representations

uid

A crate for the creation of unique IDs

staticsort

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

minimal-id

A library that implements generating short, unique ids with minimal collisions and good locality

dia-i18n

ISO 3166-1 and ISO 639 codes

moving_min_max

Tracking minimum or maximum of sliding windows

resources

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

rep

A small tool for representation/class invariants

half_edge_mesh

A basic implementation of the half-edge mesh data structure. It has a bunch of the functions you probably want in a half-edge mesh, but probably not all of them. I’m intending to add more methods and mutation techniques…

stomp

A full STOMP 1.2 client implementation. Allows programs to interact with message queueing services like ActiveMQ and RabbitMQ.

ring_buffer

RingBuffer is a mix of a vector and a queue

data_reader

A data loading library for data scientist

segment-tree

Quickly perform interval queries or modifications

doubly

Doubly linked lists in rust

apint

Arbitrary precision integers library

jagged_array

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

restorable

An iterator adapter for saving and restoring iterator state

sprs-ldl

Sparse cholesky factorization

json-parser

JSON parser

indextree-ng

Arena based tree structure by using indices instead of reference counted pointers. Fork of indextree by Sascha Grunert which allows to remove nodes

prefix-tree

A map and set interfaces using trie data structure

skiplist

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

hex2d

Helper library for working with 2d hex-grid maps

fixed-map-derive

A fixed map where storage layout is calculated by a procedural macro. This crate contains the procedural macros

varuint

Variable length signed and unsigned integer types

lazy-init

Lazy initialization

strchunk

A utility library for working with UTF-8 text in I/O

mdbookshelf

Create epubs from a list of mdbook repositories

evobox

A pointer type which allows for safe transformations of its content without reallocation

graphsearch

A simple graph search and representation library

intervallum

Generic interval and interval set library

theban_interval_tree

A simple Interval Tree implementation

hash-chain

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

sortedvec

a sorted vector that enables quick lookups

lending-library

A key-value store that loans full ownership of items

beach_map

Implementation of a slotmap

ro

Helps make stuff read-only

bk-tree

A Rust BK-tree implementation

holyhashmap

A hash map with stable indices

linebuffer

ringbuffer for dynamic sized u8-elements

soak

Transform a struct into arrays of its fields

safe_index

Type-safe indexes

divbuf

Buffer object that can be recursively divided into smaller buffers

heatmap

time-series of histograms with precision guarantees

vec4

vec4

bailamos

Simple notification manager

tilecoding

Rust implementation of Dr. Richard S. Sutton’s tile coding software.

sqa-bounded-spsc-queue

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

ordered_iter

Ordered iterators

dense_bitset

A variably sized, heap allocated, dense bitset implemented using no unsafe code

simple_ringbuf

Simple Ringbuf is a speedy lightweight fixed-size infinite-use collection optimized for straightforward single threaded use

automerge

Rust implementation of the Automerge replicated JSON datatype

rtable

Generic Routing Table Library with Radix Tree

subset-map

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

cast-rs

A collection of types cast for Rust

dirty_static

A container for an immutable value that allows sneaky reloading in debug mode (via UnsafeCell) while keeping the data safe and constant in release mode. This allows you to tweak data while testing an application…

sacabase

Base types and functions for suffix arrays and longest substring search

webe_id

Unique ID generator based on Snowflake, but for us wizards

sprs_suitesparse_ldl

sprs bindings to the suitesparse ldl solver

darts

A double array trie, A Forward Maximum Matching Searcher

vec-collections

Rust collections that are newtype wrappers around vectors

version-lp

a version struct library for use with version comparing, and wildcard resolving

ensured_bufreader

A Bufreader ensures N bytes in buffer

gcollections

Generic traits over Rust collections library

visit_diff

Efficiently finding differences between data structures

sum

General-purpose sum types

street_index

street_index is a small utility crate for working with road name / street indexing for cartographic purposes

cons-list

An immutable singly-linked list, as seen in basically every functional language

mat4

matrix 4x4

eclectic

Experimental collection traits

another-option

Another option data type; useful when allocations are expensive

itree

An interactively navigable version of the Linux utility tree

fux_kdtree

K-dimensional tree implemented in Rust for fast NN querying

suitesparse_ldl_sys

Raw bindings to SuiteSparse’s LDL algorithm

quantized-density-fields

Rust implementation of Quantized Density Fields data structure

space

A library for working with spatial trees and point clouds

soa-vec

A simple Vec-like API over a struct of arrays layout

nfqueue

Netfilter NFQUEUE high-level bindings

rustz

A library for functional programming in Rust

hamt-rs

A Hash Array Mapped Trie implementation based on the Ideal Hash Trees paper by Phil Bagwell

iso7816-tlv

tools and utilities for handling TLV data as defined in ISO/IEC 7816-4

bit-long-vec

Vector with fixed bit sized values stored in long

iowrap

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

htmldom_read

HTML reader that parses the code into easy-use tree

bonzai

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

swaybar-types

A library for building swaybar status commands in rust

intrusive_splay_tree

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

egg

An implementation of egraphs

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

uset

An implementation of a set and a map designed for speed, with unsigned integers as keys

pod

Plain Old Data (POD) encoding and I/O

smallvec-stableunion

Fork of the crate smallvec. Uses unions in stable rust. Please note that it can only store Copy types. No functional differences apart from that.

pdatastructs

Simple probabilistic data structures

terms

Tree terms and patterns data structures

patricia_router

Radix Tree implementation for Rust

idlset

Fast u64 set operations library

sized-vec

Type level sized vectors

lhlist

Labeled heterogeneous lists

const-arrayvec

A vec-like type backed by an array on the stack

static_map

A static hashmap implementation, based on the Round-Robin hashing algorithm found in rustc

fral

Functional random-access lists

compacts

compact data structures

loader-rs

Rust interface to load generic objects from an URI

bitvec-rs

Bit vector with guaranteed [u8] representation and the ability to get safe immutable and mutable views into its internal vector for easy I/O

froop

A functional reactive stream library for rust

soak-derive

Custom derive macro for #[derive(Columns)]

hash_ring

Consistent Hashing library for Rust

aci_ppm

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

stack

DSTs and arrays on the stack!

ringbuffer

A fixed-size circular buffer

bisetmap

BisetMap is a fast and thread-safe two-way hash map of sets. It is best suited where you need to associate two collumns uniquely. Each key is associated to one or more other unique values…

infinibuffer

A buffer?

gvec

Very simple implementation of generational indexing for vectors written in Rust

linked-list

An alternative implementation of std::collections::LinkedList

reso_dd

Structures and Enumerations that implement the Real Estate Standards Organization (RESO) Data Dictionary

sesstype

An implementation of Multiparty Session Types

ornament

A helper to create decorated text

partial

Optional monad with fake variant

generic

Higher level serialization of rust values to rust values

neolistqueue

A buffer?

core_collections

This is a copy of libstd::collections with all the parts that don’t work in core removed. Most importantly, it provides HashMap and HashSet. This crate is (mostly) automatically generated from the rust git source…

chickenwire

A library for representing and manipulating hexagonal grids

ring_queue

A double-ended queue implemented using a vector that reuses space after elements are removed

flot

Generate HTML documents with embedded charts using Flot

dependy

Dependency resolution with variable dependency types

basic_tree

basic tree for rust, for now including only trie

depot

A (disk) persistent queue library

ball-tree

Ball-tree implementation for K-nearest neighbors

telegram-typings

Structs represents telegram bot typings

sbf

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

fenwick

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

higher_order_point

An experimental higher order data structure for 3D points

byte_trie

A compressed trie based on bytes with some weird child node bucket sizes

rtrees

A Bunch of completely safe augmented tree implementation in rust

gridd

A generic, dirt-simple, two-dimensional grid

appendix