-
hashbrown
port of Google's SwissTable hash map
-
bitvec
Addresses memory by bits, for packed collections and bitfields
-
indexmap
A hash table with consistent order and fast iteration
-
phf
Runtime support for perfect hash function data structures
-
half
Half-precision floating point f16 and bf16 types for Rust implementing the IEEE 754-2008 standard binary16 and bfloat16 types
-
smallvec
'Small vector' optimization: store up to a small number of items on the stack
-
priority-queue
A Priority Queue implemented as a heap with a function to efficiently change the priority of an item
-
ndarray
An n-dimensional array for general elements and for numerics. Lightweight array views and slicing; views support chunking and splitting.
-
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
-
tinyvec
tinyvecprovides 100% safe vec-like data structures -
slotmap
data structure
-
bit-set
A set of bits
-
arrayvec
A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.
-
roaring
A better compressed bitset - pure Rust implementation
-
generic-array
Generic types implementing functionality of arrays
-
enum-map
A map with C-like enum keys represented internally as an array
-
hashlink
HashMap-like containers that hold their key-value pairs in a user controllable order
-
zerovec
Zero-copy vector backed by a byte array
-
rpds
Persistent data structures with structural sharing
-
tinystr
A small ASCII-only bounded length string representation
-
bimap
Bijective maps
-
bit-vec
A vector of bits
-
croaring
Rust wrapper for CRoaring
-
string-interner
Efficient string interner with minimal memory footprint and fast access to the underlying strings
-
bio
A bioinformatics library for Rust. This library provides implementations of many algorithms and data structures that are useful for bioinformatics, but also in other fields.
-
elsa
Append-only collections for Rust where borrows to entries can outlive insertions
-
intrusive-collections
Intrusive collections for Rust (linked list and red-black tree)
-
wide
help you go wide
-
trie-rs
Memory efficient trie (prefix tree) and map library based on LOUDS
-
im
Immutable collection datatypes
-
vec1
a std Vec wrapper assuring that it has at least 1 element
-
ena
Union-find, congruence closure, and other unification code. Based on code from rustc.
-
generator
Stackfull Generator Library in Rust
-
ego-tree
Vec-backed ID-tree
-
linked_hash_set
HashSet with insertion ordering
-
rowan
generic lossless syntax trees
-
indextree
Arena based tree structure by using indices instead of reference counted pointers
-
crdts
Practical, serializable, thoroughly tested CRDTs
-
petgraph
Graph data structure library. Provides graph types and graph algorithms.
-
histogram
A collection of histogram data structures
-
enumset
creating compact sets of enums
-
either
The enum
Eitherwith variantsLeftandRightis a general purpose sum type with two cases -
ringbuffer
A fixed-size circular buffer
-
smallbitvec
A bit vector optimized for size and inline storage
-
bloomfilter
Bloom filter implementation
-
smartstring
Compact inlined strings
-
yrs
High performance implementation of the Yjs CRDT
-
litemap
A key-value Map implementation based on a flat, sorted Vec
-
fixedbitset
bitset collection
-
radix_trie
Generic radix trie data-structure
-
bitmaps
Fixed size boolean arrays
-
hybrid-array
Hybrid typenum-based and const generic array types designed to provide the flexibility of typenum-based expressions while also allowing interoperability and a transition path to const generics
-
yada
double-array trie library aiming for fast search and compact data representation
-
ndarray-stats
Statistical routines for ArrayBase, the n-dimensional array data structure provided by ndarray
-
fraction
Lossless fractions and decimals; drop-in float replacement
-
index_vec
Newtype-style helpers for
Vecandusize -
ecow
Compact, clone-on-write vector and string
-
patricia_tree
Memory-efficient data structures based on patricia tree
-
biodivine-lib-bdd
thread-safe implementation of basic binary decision diagrams
-
typed-index-collections
Typed index version of Rust slice and Vec containers
-
indxvec
Vecs sorting, merging, indexing, ranking, searching, reversing, intersecting, printing, etc
-
intmap
Specialized HashMap for integer keys
-
index_list
A doubly linked list implemented in safe Rust using vector indexes
-
thin-vec
A vec that takes up less space on the stack
-
guppy
Track and query Cargo dependency graphs
-
egg
egraphs
-
imbl
Immutable collection datatypes
-
dlv-list
Semi-doubly linked list implemented using a vector
-
linked-hash-map
A HashMap wrapper that holds key-value pairs in insertion order
-
smallbox
Small Boxoptimization: store small item on stack and fallback to heap for large item -
sorted-vec
Create and maintain sorted vectors and vector-backed sets
-
range-set-blaze
Integer sets as fast, sorted, integer ranges with full set operations
-
barcoders
A barcode-encoding library
-
bytes-utils
Additional utilities for working with the bytes crate
-
orx-split-vec
An efficient dynamic capacity vector with pinned element guarantees
-
narrow
Apache Arrow
-
growable-bloom-filter
Scalable Bloom Filters with serde support
-
circular-buffer
Efficient, fixed-size, overwriting circular buffer
-
hashbag
An unordered multiset implementation using a hash bag
-
multimap
A multimap implementation
-
algorithm
about algorithm data structure, now has ttl with lru/lru-k/lfu/arc and slab/rbtree/roaring_bitmap/timer_wheelss, 关于算法常用的数据结构
-
cita_trie
Modified Patricia Tree (aka Trie)
-
av-data
Multimedia data structures
-
qp-trie
An idiomatic and fast QP-trie implementation in pure Rust, written with an emphasis on safety
-
modql
Model Query Language support
-
spade
Delaunay triangulations for the rust ecosystem
-
jaq-json
JSON values for jaq
-
arrow-array
Array abstractions for Apache Arrow
-
esaxx-rs
Wrapping around sentencepiece's esaxxx library
-
newtype-uuid
Newtype wrapper around UUIDs
-
fastbloom
The fastest Bloom filter in Rust. No accuracy compromises. Compatible with any hasher.
-
louds-rs
High performance LOUDS (Level-Order Unary Degree Sequence) library
-
slice-ring-buffer
A double-ended queue that Deref's into a slice
-
fixed-map
A fixed map where storage layout is calculated by a procedural macro
-
array-macro
Array multiple elements constructor syntax
-
binary-heap-plus
Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps
-
array-init
Safe wrapper for initializing fixed-size arrays
-
immutable-chunkmap
A fast immutable map and set with batch insert and update methods, COW operations, and big O efficient implementations of set and merge operations
-
bounded-vec
Non-empty rust Vec wrapper with type guarantees on lower and upper bounds for items quantity
-
fastdivide
partial port of libdivide. It makes it possible to reduce the cost of divisions.
-
merkle-search-tree
A data structure for efficient state-based CRDT replication and anti-entropy
-
slice-dst
Slice-based custom DSTs
-
string
A UTF-8 encoded string with configurable byte storage
-
qfilter
Efficient bloom filter like datastructure, based on the Rank Select Quotient Filter (RSQF)
-
tree_iterators_rs
built to provide you with the iterators to easily work with tree data structures in Rust
-
atone
A VecDeque and Vec variant that spreads resize load across pushes
-
dary_heap
A d-ary heap
-
nonempty-collections
Correct-by-construction non-empty collections
-
orx-linked-list
A linked list implementation with unique features and an extended list of constant time methods providing high performance traversals and mutations
-
bloom2
Fast, compressed, 2-level bloom filter and bitmap
-
sqrid
Square coordinates and grid-like arrays, with zero dependencies, in a single file
-
bridgetree
A space-efficient Merkle tree designed for linear appends with witnessing of marked leaves, checkpointing & state restoration
-
keyed_priority_queue
Priority queue that support changing priority or early remove by key
-
grid
Dynamic generic 2D data structure
-
iset
Map and set with interval keys (x..y)
-
caches
popular caches (support no_std)
-
crop
A pretty fast text rope
-
range-set
Smallvec-backed containers of sorted integer ranges
-
equivalent
Traits for key comparison in maps
-
modular-bitfield
Allows to easily define bitfield types with modular building blocks
-
gix-pack
Implements git packs and related data structures
-
arraydeque
A ring buffer with a fixed capacity, which can be stored on the stack
-
vers-vecs
A collection of succinct data structures supported by fast implementations of rank and select queries
-
deep_causality
Computational causality library. Provides causality graph, collections, context and causal reasoning.
-
lattices
Lattice data types for simplifying distributed state by providing associativity, commutativity, and idempotence
-
blart
adaptive radix tree packaged as a BTreeMap replacement
-
walker-common
Common functionality for SBOM and CSAF walker
-
indexset
A two-level BTree with fast iteration and indexing operations
-
fastbloom-rs
Some fast bloom filter implemented by Rust for Python and Rust!
-
any_vec
Type erased vector. Most operations can be done without type knowledge. Mostly zero overhead.
-
vob
Vector of Bits with Vec-like API and usize backing storage
-
phf_codegen
Codegen library for PHF types
-
simple_endian
A create for defining endianness within your data structures, to make handling portable data structures simpler
-
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. -
fqdn
FQDN (Fully Qualified Domain Name)
-
tinyset
Size-optimized sets
-
rust_dynamic
Support for dynamically-typed values in run-time
-
cdg_api
interact with api.congress.gov
-
typed_floats
Types for handling floats with type checking at compile time
-
lib-sokoban
Sokoban: compact, efficient data structures packed into contiguous byte arrays
-
intervallum
Generic interval and interval set library
-
hibitset
Hierarchical bit set structure
-
lsm-tree
A K.I.S.S. implementation of log-structured merge trees (LSM-trees/LSMTs)
-
v_frame
Video Frame data structures, originally part of rav1e
-
queue-file
lightning-fast, transactional, file-based FIFO
-
portgraph
Data structure library for directed graphs with first-level ports
-
idlset
Fast u64 set operations library
-
range-collections
Sets and maps of ranges, backed by smallvec
-
fm-index
FM index and its variant implementations for Rust
-
xsd-types
XSD data types
-
vecmap-rs
A vector-based map and set implementation
-
cc-traits
Common collection traits
-
zerofrom
trait for constructing
-
vortex-dtype
Vortex's core type system
-
array2d
A fixed sized two-dimensional array
-
docker-compose-types
Deserialization and Serialization of docker-compose.yml files in a relatively strongly typed fashion
-
trees
General purpose tree data structures
-
uluru
fast, LRU cache implementation
-
hi_sparse_bitset
Hierarchical sparse bitset. Incredibly high performance. Compact memory usage.
-
vortex-scalar
Vortex Scalars
-
keyvi
key value index. It is an in-memory FST-based data structure highly optimized for size and lookup performance.
-
toodee
A lightweight 2D wrapper around a Vec
-
i256
Optimized implementations of 256-bit signed and unsigned integers
-
tree-ds
manipulate tree data structures
-
cow_hashbrown
port of Google's SwissTable hash map with copy-on-write support
-
bitfield-struct
Struct-like procedural macro for bitfields
-
xml-builder
Easy and highly-configurable XML builder/writer
-
broccoli
broadphase collision detection algorithms
-
hdf5
Thread-safe Rust bindings for the HDF5 library
-
iptrie
IPv4/v6 prefixes lookup structures (based on tries)
-
vec_map
map based on a vector for small integer keys
-
btree-range-map
B-tree range map implementation
-
differential-dogs3
Advanced join patterns in differential dataflow
-
imbl-sized-chunks
Efficient sized chunk datatypes
-
id_tree
creating and modifying Tree structures
-
timed-map
Lightweight map implementation that supports expiring entries and fully compatible with both std and no_std environments
-
diff-struct
A trait for diffing and applying diffs to types
-
xor_name
Xor Type
-
metatensor
Self-describing sparse tensor data format for atomistic machine learning and beyond
-
array-concat
Macros for concatenating const arrays
-
map_vec
The Map and Set APIs backed by Vec
-
oxidd
A safe, concurrent, modular, and performant decision diagram framework
-
baby_shark
Geometry processing library
-
tracker
A macro to track changes on structs
-
gix-traverse
gitoxide project
-
iso7816
Types for ISO 7816
-
validated
The cumulative sibling of
ResultandEither -
tagged-pointer
Platform-independent space-efficient tagged pointers
-
ordered-multimap
Insertion ordered multimap
-
starlark_map
Map implementation with starlark-rust specific optimizations
-
bitm
bit and bitmap (bit vector) manipulation
-
cordyceps
Mycelium intrusive data structures
-
honeycomb-core
Core structure implementation for combinatorial maps
-
slice_ring_buf
A ring buffer implementation optimized for working with slices
-
iso7816-tlv
tools and utilities for handling TLV data as defined in ISO/IEC 7816-4
-
parsable
A trait to easily parse data structures
-
rust_decimal_macros
Shorthand macros to assist creating Decimal types
-
kempt
Ordered collection types with no unsafe code and no_std support
-
uguid
GUID (Globally Unique Identifier) no_std library
-
cactus
Immutable parent pointer tree
-
elusion
modern DataFrame library that combines the familiarity of DataFrame operations (like those in PySpark, Pandas, and Polars) with the power of SQL query building. It provides flexible…
-
spatialtree
A fast and flexible generic spatial tree collection (Octree, Quadtree, etc)
-
chat-prompts
Chat prompt template
-
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.
-
griddle
A HashMap variant that spreads resize load across inserts
-
bitfield-rle
A run-length-encoder that compresses bitfields
-
base-traits
base traits (for Rust)
-
zarray
Cache-optimized 2D and 3D arrays using Morton order (aka Z-order) Z-indexed storage, with a convenient API for common 2D and 3D access patterns. Use of zarray in place of a Vec of Vecs often improves performance…
-
prio-graph
A lazily populated directed acyclic graph with top-level priority ordering
-
phf_shared
Support code shared by PHF libraries
-
polars-ops
More operations on Polars data structures
-
scapegoat
Safe, fallible, embedded-friendly ordered set/map via a scapegoat tree. Validated against BTreeSet/BTreeMap.
-
arrow-ord
Ordering kernels for arrow arrays
-
pyinrs
type library that is as easy to use as Python built-in types
-
ordered
A wrapper for adding arbitrary partial/total order to a type
-
slotmap-careful
Wrap the slotmap crate and prevent key reuse
-
tar-no-std
read Tar archives (by GNU Tar) in
no_stdcontexts with zero allocations. The crate is simple and only supports reading of “basic” archives, therefore no extensions, such as GNU Longname… -
mhgl
Matts HyperGraph Library (MHGL). A straightforward library for hypergraph datastructures.
-
orx-fixed-vec
An efficient fixed capacity vector with pinned element guarantees
-
etc-os-release
Parse /etc/os-release file
-
adflib
handle amiga disk files
-
reactive_stores
Stores for holding deeply-nested reactive state while maintaining fine-grained reactive tracking
-
rsdict
Fast static rank and select data structure
-
chronologic
Time constraint reasoning (scheduling...)
-
warg-transparency
transparency data structures
-
datalogic-rs
A fast, type-safe Rust implementation of JSONLogic for evaluating logical rules as JSON. Perfect for business rules engines and dynamic filtering in Rust applications.
-
hypergraph
data structure library to create a directed hypergraph in which an hyperedge can join any number of vertices
-
slabmap
HashMap-like collection that automatically determines the key
-
beap
Bi-parental heap data structure implementation in Rust
-
ergo_avltree_rust
cryptographically authenticated dictionary based on AVL tree
-
scalable_cuckoo_filter
A variant of Cuckoo Filter whose size automatically scales as necessary
-
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…
-
roadmap
model a project roadmap as a directed acyclic graph
-
number-general
A generic number type for Rust which supports basic math and (de)serialization
-
simple-grid
2d-grid structure
-
ggapi
communicating with start.gg's API
-
short-uuid
generate and parse short uuids
-
xmltv
electronic program guide (EPG) parser and generator using serde
-
plain
A small Rust library that allows users to reinterpret data of certain types safely
-
postman2openapi
Convert a Postman collection to an OpenAPI definition
-
extindex
Persisted immutable index
-
more_collections
Additional collections not found in std::collections
-
orange-trees
Tree data structure with several methods to query and manipulate nodes
-
rt_ref
Internal
Reftypes forrt_refandrt_vec -
valkyrie-ast
Strong typed abstract syntax tree of valkyrie language
-
smallstr
String-like container based on smallvec
-
matrixable
Traits and structs extending capabilities of matrix-like structures
-
utote
Stack allocated uint multiset, with optional SIMD implementations
-
grovedbg-types
Common type definitions for data exchange over GroveDBG protocol
-
boa_interner
String interner for the Boa JavaScript engine
-
libwebnovel
enabling users to get chapters of a webnovel, with multiple available backends
-
simd_aligned
Safe and fast SIMD-aligned data structures with easy and transparent 'flat' access
-
frozen-collections
Fast partially-immutable collections
-
stacked_errors
high level error propogation with software controlled backtraces
-
stack-map
constant-size associative container for building higher-level data structures out of
-
sparsevec
Compress vectors using row displacement
-
nodit
Discrete Interval Tree Data-Structures, which are based off BTreeMap
-
rc-u8-reader
A tiny implement for reading
u8data from a reference counted instance -
span-map
A data structure for efficiently managing sets of values over spans/ranges
-
tailcall-chunk
persistent data structure for efficient append and concatenation operations
-
tetengo_trie
A trie library implemented with a double array
-
mut_set
A safe implementation for HashSet with iter_mut and get_mut
-
authenticode
working with Authenticode (no-std)
-
differential-dataflow-master
An incremental data-parallel dataflow platform
-
cbsk_base
locked version cargo crates
-
sn_registers
Safe Network Register Logic
-
avltriee
Customized version of AVLTree library.Process the same value in the third branch. One data is immovable from one row, and positional relationships such as left, right, and parent are all referenced by row numbers…
-
json-number
JSON number parsing and storage
-
optional
supplies a number of Option-like primitive types
-
atelier
a Computational Workshop for Market Microstructure Modeling, Synthetic Simulation and Historical Replay
-
csaf-walker
work with CSAF data
-
podded
Zero-copy types for constraint environments
-
symbol_table
A symbol table that's fast, concurrent, and gives stable references
-
hashslab
A hash table with data accessible by index
-
xorf
implementing xor filters - faster and smaller than bloom and cuckoo filters
-
bittle
Zero-cost bitsets over native Rust types
-
flatk
Flat layout abstraction toolkit
-
vart
An immutable versioned adaptive radix trie
-
numeric-array
Wrapper around generic-array that adds efficient numeric trait implementations
-
clone_cell
A Cell that works with a restrictive form of Clone
-
bumparaw-collections
A small set of bumpalo-backed collections for low-level operations
-
dot2
generating Graphviz DOT language files for graphs
-
bc-envelope
Gordian Envelope for Rust
-
tmflib
Interface library for processing TMF payloads
-
avl
A map and a set implemented with an AVL tree
-
oxidd-rules-zbdd
Zero-suppressed decision diagrams (ZBDDs) for OxiDD
-
ux-primitives
Graphics Primitives for Angular Rust
-
edtui-jagged
A jagged array data structure for the edtui editor
-
ordsearch
A data structure for efficient lower-bound lookups
-
cbsk_socket
socket callback tool
-
flatcontainer
A flat container representation for Rust
-
vortex-error
Vortex errors
-
sync-ptr
Sync & Send wrappers for raw pointer's
-
truc
Rust code generator for safe, fixed size, evolving records
-
bevy_spatial
tracking bevy entities in spatial indices
-
fastset
Fast set implementation for dense, bounded integer collections, optimized for quick updates and access
-
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. -
pin-list
A safe
Pin-based intrusive doubly linked list -
i_shape
iShape is a compact and efficient library specifically designed for representing 2D data structures using IntPoint
-
pasture-algorithms
Point cloud algorithms for pasture
-
variadics
Variadic generics on stable Rust using tuple lists
-
array-object
Self-describing binary format for arrays of integers, real numbers, complex numbers and strings, designed for object storage, database and single file
-
disjoint
Fast and safe implementation of the disjoint-set data structure
-
intervals-general
enabling general representation of and operations on intervals over generic types (e.g. supporting units of measure or arbitrary built-in types, or any type with PartialOrd implementation).
-
h3o-ice
Frozen{Map,Set} for H3 cells, based on finite state transducers
-
either_of
working with enumerated types that contain one of 2..n other types
-
ball-tree
K-nearest neighbors
-
odht
hash tables that can be mapped from disk into memory without the need for up-front decoding
-
snowflake_me
A distributed unique ID generator inspired by Twitter's Snowflake
-
validit
Validate data structures internal state
-
btree_experiment
implements a BTreeMap similar to std::collections::BTreeMap
-
spacetimedb-data-structures
Assorted data structures used in spacetimedb
-
delay_map
HashMap collections whose entries expire after a given time
-
vsmtp-config
Next-gen MTA. Secured, Faster and Greener
-
weak-table
Weak hash maps and sets
-
enum-collections
Collections data structures optimized for Enum, initializable at runtime
-
frunk_laws
contains laws for algebras declared in Frunk
-
tea-core
Core data structures and traits for tevec
-
form_builder
building forms with various fields and validation
-
sized-chunks
Efficient sized chunk datatypes
-
enum2egui
derive macro that creates a set of egui ui databindings from arbitrary data structures. Supports egui v0.29.1
-
hash_hasher
A hasher which is designed to work with already-hashed or hash-like data
-
rbitset
A bit set, being able to hold a fixed amount of booleans in an array of integers
-
ordinal-map
Ordinal trait to map values to integers and efficient maps and sets for such types
-
fingertrees
Immutable persisten finger trees
-
alot
A forbid-unsafe, generational slot map with usize-sized IDs
-
hotel
Collection Data-structure to associate values with keys
-
std-macro-extensions
A collection of macro extensions for Rust's standard library data structures, simplifying the creation and manipulation of common collections such as HashMap, Vec, and more
-
polytype
A Hindley-Milner polymorphic typing system
-
datas
data structures and algorithms and data analisys
-
mikufans-proto
gRPC APIs for Mikufans
-
lean_string
Compact, clone-on-write string
-
bitboard64
A 64-bit bitboard useful for chess programming
-
jaggedarray
Multidimensional jagged array
-
rust_multistack
Support for two-dimentional stacks for the Rust programming language
-
typeid_prefix
that implements a type-safe version of the TypePrefix section of the
TypeIDSpecification -
unordered-pair
A tuple struct representing an unordered pair
-
c_vec
Structures to wrap C arrays
-
tuplez
Tuples represented in recursive form
-
cmsketch
A count min sketch implementation in Rust
-
normalize_interval
Normalizing interval library
-
json_dotpath
Dotted path access to nested JSON objects (serde_json::Value)
-
nam-sparse-merkle-tree
(Namada fork) Sparse merkle tree implement in rust
-
sync42
synchronization tools
-
orx-iterable
Defines and implements Iterable, Collection and CollectionMut traits to represent types that can be iterated over multiple times
-
matreex
matrix implementation
-
livestock-rs
managing and identifying livestock breeds
-
ocpp_rs
Protocol implementation for Open Charge Point Protocol (OCPP) in Rust
-
av-codec
Multimedia format decoding and encoding
-
velcro
Convenience macros for initializing vectors, hash maps and other Rust collections
-
combo_vec
A blazingly fast no-std vector-like ADT using the stack (and optionally heap for overflow)
-
minimizer-iter
Iterate over minimizers of a DNA sequence
-
flatten_objects
A container that stores numbered objects. Each object can be assigned with a unique ID.
-
wipe-on-fork
A replacement to OnceCell, LazyCell, Once, OnceLock, LazyLock that wipes itself when being forked in Unix
-
min-max-heap
An efficient, double-ended priority queue
-
pdatastructs
probabilistic data structures
-
edgefirst-schemas
Maivin EdgeFirst Services Schemas
-
sigma-types
Types checked for an invariant
-
v_queue
file based queue
-
defer-drop
Defer dropping large types to a background thread
-
loro-rle
A internal library of loro for storing and manipulating run-length encoded data. Do not use it directly.
-
skiplist
in rust, providing fast insertion and removal. A normal skiplist is implemented, as well as an ordered skiplist and a skipmap.
-
lctree
Link-Cut-Tree: self-balancing data structure to maintain a forest of rooted trees
-
cantrip
Practical extension methods for standard Rust collections
-
field_access
Dynamically access struct fields
-
rdf-model
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
ofdb-boundary
Serializable, anemic data structures for accessing the OpenFairDB API in a type-safe manner
-
rust_flightweather
Decodes METAR and TAF
-
qutee
A quadtree implementation
-
wavltree
An intrusive Weak AVL Tree
-
smallvec-wrapper
Macro and common structs to play with
smallvec -
mago-ast
Supplies the data structures and types for representing PHP code as an Abstract Syntax Tree (AST)
-
std-ext
Extend the standard library functionality
-
endpoints
A collection of data structures for the OpenAI-compatible endpoints
-
signalk
parse signalk maritime data
-
smart_led_effects
A collection of effects for LED strips
-
entity_data
A container for entity component data
-
sucds
Succinct data structures in Rust
-
horizon_data_types
The Horizon data types library for third-party integrations
-
enontekio
solve problems with data extraction and manipulation, like Advent of Code puzzles
-
prost-unwrap
A procedural macro for prost-generated structs validation and type-casting
-
fiftyonedegrees
A wrapper around the 51Degrees device detection C library
-
pas
strided slice
-
list-fn
A generic lazy list
-
undo
An undo-redo library
-
structured
Data structures to handle large, structured data
-
raft-log
Raft log implementation
-
radixmap
Rust-based Radix Tree for fast prefix lookup, supporting named param, glob, regex
-
blas-array2
Parameter-optional BLAS wrapper by ndarray::Array (Ix1 or Ix2)
-
pi_slotmap
Slotmap data structure
-
rbtree
the rbtree for Rust
-
mapgraph
A directed graph that can also be used as an arbitrary map
-
suggest
A minimal library to provide similar name suggestions like "Did you mean?"
-
pfds
Purely Functional Data Structures
-
bitstring-trees
Trees based on bitstrings
-
do-notation
Monadic do syntactic sugar
-
bitpack-vec
A vector for arbitrary bitwidth integers, densely packed
-
primitive_fixed_point_decimal
Primitive fixed-point decimal types
-
data_reader
A data loading library for data scientist
-
nestac
access nested structures using path-like string format
-
binary-util
A panic-free binary utility crate to read/write binary streams over the wire
-
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.
-
epsg
EPSG Coordinate Reference System tools & data
-
value-ext
Serde Json Value Extension Trait (more Value type later)
-
pipebuf
Efficient byte-stream pipe buffer
-
trane
An automated system for learning complex skills
-
btree-slab
A memory compact Slab-based B-tree implementation
-
jumprope
fast rope (fancy string) library built on top of Skiplists
-
rdf-types
Data-structures and traits definitions for RDF
-
cuckoofilter
Cuckoo Filter: Practically Better Than Bloom
-
trie-hard
Fast implementation of trie data structure
-
fvm_ipld_kamt
Sharded IPLD Map implementation with level skipping
-
tskit
rust interface to tskit
-
lsph
Learned Spatial HashMap
-
to_markdown_table
An easy way to format any data structure into a Markdown table
-
typemap_rev
A hashmap, but stores types as keys
-
easy-tree
efficient tree structure library for Rust with recursive traversal
-
compact-rc
Low-memory reference-counting pointers
-
ladata
& modular data model
-
map-macro
Declarative macros for statically initializing collections
-
any-rope
A fast and robust arbitrary rope for Rust. Based on Ropey.
-
boomerang_tinymap
A tiny, fast, and simple Slotkey-type map implementation for Boomerang
-
stack-queue
Heapless auto-batching queue
-
HArcMut
mutable arc
-
golomb-coded-set
BIP158 Golomb-Coded Set data structure
-
ndata
Thread-safe, self-owned JSON-like data with manual garbage collection
-
kollect
Collections made ergonomic for gamedev usecases
-
beach_map
slotmap
-
relend
A generalized reborrowing mechanism that extends beyond simple references. It also allows for implementing traits that work with reborrowing for custom types.
-
hibit_tree
Hierarchical bitmap tree. Prefix tree without memory overhead that act as herarchical bitmap.
-
hvec
A Vec-like structure that can store different types of different sizes contiguous with each other in memory
-
every_variant
EveryVariant trait that provides the every_variant method on types. Allows you to easily generate every combination of variants in structures that contains Enums, or in nested enum trees…
-
libreda-db
Layout and netlist datastructures for chip design
-
populated
Collection types that are guaranteed to be populated (i.e. non-empty). Based on std::collections types.
-
ffi-convert
A collection of utilities to ease conversion between Rust and C-compatible data structures
-
ttgraph
Typed/Transactional Graph container
-
plain_trie
Classic trie implementation capable of mapping any T to char iterator
-
small-fixed-array
providing fixed length immutable collections with a low memory footprint
-
rust-box
odd set of tools for Rust programming
-
persian-rug
Framework for bringing together disparate objects with inconvenient relationships
-
intrusive-lru-cache
An LRU cache implementation using intrusive data structures
-
sharded
Safe, fast, and obvious concurrent collections
-
hello_egui
A collection of useful crates for egui
-
balanced-tree-index
constant-time manipulation of a complete binary tree with a flat in-memory representation
-
ninjabook
A lightweight and high performance orderbook
-
strict
collections with strict bounds
-
bondrewd
Bit-Level field packing with proc_macros
-
among
The enum
Amongwith variantsLeft,MiddleandRightis a general purpose sum type with three cases -
fixed-macro
Macros for creating fixed-point constants for types in the
fixedcrate -
exponential-decay-histogram
A histogram which exponentially weights in favor of recent values
-
exhaustive-map
An exhaustive map for types with finite inhabitants
-
gtfs-geojson
converter for GTFS to GeoJSON formats
-
singletonset
SingletonSetdata structure, which makes it easy to store a single instance each of various types within a single set -
gix-diff
Calculate differences between various git objects
-
named_colors
that provides named colors in RGB and Hexadecimal formats
-
bao-tree
BLAKE3 verfiied streaming with custom chunk groups and range set queries
-
phf_generator
PHF generation logic
-
packed-uints
Array of uints that scales from u4 to u32 to minimize wasted space while still being fast
-
prefix-sum-vec
Compressed storage for highly repeating elements, with
O(log n)lookups -
heavykeeper
finding the top-k elements of a stream of data
-
mmdb
A std-collection-like database
-
libpna
PNA(Portable-Network-Archive) decoding and encoding library
-
cell-grid
2d grid container
-
type-map
typemap container with FxHashMap
-
parametrized
Supply useful iterating methods for user-defined types which are parametrized by type parameters
-
decomp
Components of a decompilation pipeline
-
supply-chain-trust-example-crate-000006
port of Google's SwissTable hash map
-
statiki
Static friendly data structures
-
settrie
Fast subset and superset queries
-
basic_trie
Trie implementation in Rust
-
binary-greedy-meshing
A port of https://github.com/cgerikj/binary-greedy-meshing to Rust
-
markov-generator
Highly customizable library for building Markov chains and generating random data
-
rust_redux
A Redux-like state management library for Rust
-
taskchain
A block-based, non-circular double-linked list implementation for Rust
-
linkedin-csv
Structs defined to hold the data as exported from LinkedIn
-
dia-i18n
-
small-map
An inline SIMD accelerated hashmap designed for small amount of data
-
snowflake-ng
Dead easy and high performance
snowflakeimplemented in Rust -
nam-indexmap
(Namada fork) A hash table with consistent order and fast iteration
-
adapton
programming abstractions for general-purpose incremental computations
-
scope-cell
temporary, scope-bound, and thread-safe mutation of data in Rust
-
gridava
2D coordinate systems
-
chemrust-core
The core modules defining the flow and structs of data in computational chemistry routines
-
kg-tree
Generic object tree with Opath query language, similar to XPath
-
surface-grid
providing data structures for square-tiled grids wrapped around the surface of certain objects
-
superintervals
Interval overlap library
-
uid_store
Generate random uid strings containing letters, numbers, or base62 values
-
a-tree
A dynamic data structure for efficiently indexing arbitrary boolean expressions
-
tld
Top Level domain static hash map, tld list is obtained from of iana.org
-
hifa-xml-schema
Structure generator from XSD source file
-
ftree
A very fast fenwick tree implementation
-
canopydb
Transactional key-value storage engine
-
token-parser
parsing texts into data structures
-
grovedb-path
Path extension crate for GroveDB
-
doubloon
Money datatype that supports both statically and dynamically typed currencies
-
bv
Bit-vectors and bit-slices
-
atomic_ptr_cell
Safe no_std repr(transparent) wrapper for AtomicPtr and &AtomicPtr with an api similar to a cell
-
aliasable
Basic aliasable (non unique pointer) types
-
mediumvec
Vector types optimized for space, including a 32-bit Vec
-
hora-id
A 64-bit time-based sorted unique ID generator that includes the current time in the ID
-
fast-graph
A fast, lightweight and extensible implementation of a graph data structure
-
damped-springs
damped springs for smooth and springy motion
-
nybbles
Efficient nibble-sized (4-bit) byte sequence data structure
-
ligature
Ligature's data model in Rust
-
grit-data-prison
providing the struct Prison<T>, a Generational Arena that allows full interior mutability to each and every element
-
historian
a high performance zero-config histogram implementation
-
cve
Mappings for parsing the CVE JSON files
-
enumoid
Enum Indexed Containers
-
reqray
Log ‘request x-rays’ for rust programs instrumented with
tracing -
threshold
data structures
-
csf
compressed static functions (maps) that use perfect hashing and value compression
-
bit_ops
Common bit-oriented operations on primitive integer types with a focus on
no_stdandconstcompatibility. Unlike other crates that provide tooling to create sophisticated high-level types with bitfields… -
hightorrent
High-level torrent library which supports Bittorrent v1, v2 and hybrid torrents
-
shortguid
Short URL-safe Base64 encoded UUIDs
-
space
providing abstractions for spatial datastructures and search
-
pi_spatial
sparial octtree quadtree
-
wasmedge-types
The common data structures for WasmEdge Rust bindings
-
identified_vec
Like HashSet but retaining INSERTION order and without
Hashrequirement on the Element type -
blaze-common
Blaze common shared types
-
pfx
A prefix tree (map and set), implemented without any unsafe
-
digit-sequence
Sequence of u8 digits
-
es-entity
Event Sourcing Entity Framework
-
tri-mesh
A triangle mesh data structure including basic operations
-
smooth-json
opinionated, customizable utility to flatten serde_json Value variants into serde_json Objects ready for use in columnar or table-like usages
-
graphplan
planning algorithm from Avrim L. Blum and Merrick L. Furst in Rust
-
code_generator
A code generator (Currently only targets C)
-
orx-selfref-col
SelfRefCol is a core data structure to conveniently build safe and efficient self referential collections, such as linked lists and trees
-
roussillon-type-system
A type system for a programming language
-
hextree
Location to value mapping
-
queues
Efficient FIFO Queue data structures
-
get-full-year
An unofficial Rust client for getfullyear.com that helps you get the full year
-
btree_monstrousity
a code port of BTreeMap but with comparator functions
-
rstmt-neo
focuses on building a music theory library that can be used to generate music theory data structures and algorithms
-
divbuf
Buffer object that can be recursively divided into smaller buffers
-
gctree
cache-friendly, graph-like, arena-allocated datastructures
-
chinese-rand
Random generation of data structures in Chinese, using Rust
-
lox
Fast polygon mesh library with different data structures and traits to abstract over those
-
flammkuchen
Some data structures for fun and flammkuchen (e.g. a 2d grid which permits negative indices)
-
rtree_rs
R-tree for Rust
-
shardtree
A space-efficient Merkle tree with witnessing of marked leaves, checkpointing & state restoration
-
bit_mask_ring_buf
A ring buffer implementation with cheap indexing
-
radicle-cob
Radicle Collaborative Objects library
-
slice-of-array
Extension traits for casting between slices and slices of arrays. (&[T] <-> &[[T; n]])
-
linearize
Types that are enumerable and an array-backed map
-
smodel
Symbol semantic modeling for Rust
-
cdll
A circular doubly linked list
-
value-log
Value log implementation for key-value separated LSM storage
-
linker-set
Declarative programming via linker-constructed arrays
-
vizia_storage
The storage data structures of vizia
-
trie-root
In-memory patricia trie operations
-
sigmars
sigmahq rule collections
-
flatbuffers-owned
that enables a more flexible usage of FlatBuffers
-
seq-set
A Set collection that maintains insertion order
-
pstd
parts of Rust std library ( different implementations, features not yet stabilised etc )
-
rpds-pathtree
Immutable, path-addressable tree data structure
-
splay-safe-rs
Splay implemented with safe rust
-
microkelvin
tree traversal over annotated data structures
-
standard_card
A Lightweight Library for Efficient Card Representation
-
datafrost
Data format and acceleration structure management
-
erased_set
A set of erased types
-
mem_btree
A Data Structure of BTree Implemented with Rust, support snapshot. not use any unsafe lib.
-
ztimer
A block-based, non-circular double-linked list implementation for Rust
-
beat_saber_map
Read and write Beat Saber maps with Rust
-
stash
An amortized
O(1)table for cases where you don’t need to choose the keys and want something faster than a HashTable -
slack-blocks
Models + clientside validation for Slack's JSON Block Kit
-
seoul
trait Isomorphism
-
rb_tree
A Red Black Tree implementation in Rust
-
rs42
collection of utilities to make programming in Rust more enjoyable
-
data_registry
An unordered data structure with immediate insertion, removal and access
-
madeleine
Transparent object persistence with predefined operations and state containers
-
nt-list
Compatible, type-safe, and idiomatic Rust implementations of Windows NT Linked Lists
-
task-group
manage groups of tokio tasks
-
starling
This tree structure is a binary merkle tree with branch compression via split indexes
-
delta-collections
Data structures with revertable operations called deltas
-
codas
Compact and streamable data format that works anywhere--from web apps to robots
-
host-port-pair
Host-port pair type
-
miny
Box<T> with small value optimization
-
hylo-fix
Fixed-point number types with Solana Anchor support
-
mown
Maybe owned values. Wrappers for values that can be either owned or borrowed.
-
know
Framework for Rust
-
vortex-bytebool
Vortex byte-boolean array
-
jupyter-serde
Serialization and Deserialization for Jupyter related data structures
-
rasn-smi
Data types for handling Structure for Management Information
-
opt_struct
Optional collections
-
whirlybird
generic type implementations for RedMaple library, that offers workflows for different events compatible with common contents like todos, blogs and etc
-
hashheap
data structures that combine a hashmap and a min/max priority heap, with main operations requiring O(1) or O(log n) time
-
sk-store
SimKube trace store library
-
search_trail
manager of variables that can save and restore their values
-
crdt-lite
CRDT library for Rust
-
expiringdict
A dict / HashMap whose items expire over time
-
iter-tree
Convert between iterators and tree structures in both directions
-
compact_strings
A more compact but limited representation of a list of strings or bytestrings
-
mssmt
Merkle-Sum Sparse Merkle Tree (MS-SMT)
-
gridly
managing fixed-size 2D spaces
-
linear_collections
Map and Set types backed by linear data structures
-
ic-verifiable-credentials
Verifiable credentials issuing and verification for IC canisters
-
egui-multiwin
that allows for multiple windows with egui
-
digits
Custom “numeric” incrementor without u64 MAX limit in size. Like a score flipper for a custom character set.
-
mantra-rust-trace
Collects requirement traces from rust code for the
mantraframework -
vector
The package provides a vector database allowing for efficient search of nearest neighbors
-
python-packed-resources
Manage data structures containing Python resources
-
lambda-runtime-types
Common structures for lambda architecture
-
cistring
A string type that preserve case, but compares insensitiveley
-
awint
Arbitrary width integers
-
bitstring
traits and implementations
-
const_sized_bit_set
A bitset with a const generic size parameter indicating the number of 64 bit words to use
-
akita
Mini orm for rust
-
oca-presentation
Lib providing struct for OCA presentation
-
mule-map
A hybrid between a HashMap and a lookup table
-
i24
working with 24-bit integers
-
supply-chain-trust-example-crate-000039
Parser and evaluator for Cargo's flavor of Semantic Versioning
-
slabigator
A linked list that doesn't do dynamic memory allocations
-
multidict
Python MultiDict implementation
-
semver-eq
Parser and evaluator for Cargo's flavor of Semantic Versioning
-
value_pool
implements a ValuePool struct that makes the creation of self-referential data structures easier and safer
-
dachshund
graph mining library written in Rust. It provides high performance data structures for multiple kinds of graphs, from simple undirected graphs to typed hypergraphs. Dachshund also provides…
-
orx-pseudo-default
PseudoDefault trait allows to create a cheap default instance of a type, which does not claim to be useful
-
re_string_interner
string interning library
-
awid
Small, simple, universally unique identifiers
-
type-set
A set of heterogeneous types
-
rustc_data_structures
Reuse rustc_data_structures for compiler_base
-
tf-semver
Parser and evaluator for Cargo's flavor of Semantic Versioning
-
fixed-capacity-vec
Variable-length buffer backed by a fixed-size heap array
-
regroup
regrouping arrays
-
arrayset
An array-backed ordered set type
-
non_empty_continuous
Non-empty continuous collections
-
iterable
collection like types
-
stavec
Stack-allocated vector with static capacity
-
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.
-
makods
The Jostle Tree, a data structure for working with long sequences of variable-width items
-
array_list
A dynamic container that combines the characteristics of a Vec and a LinkedList
-
permafrost
Write. Macros. Everywhere.
-
keyed-set
Keyed Set: a hashbrown-based HashSet that indexes based on projections of its elements
-
lru-mem
An LRU cache implementation bounded by memory
-
mikel_binary_tree
search binary tree implementation
-
mc-oblivious-ram
Implementations of Oblivious RAM data structures
-
walker-extras
Additional functionality for SBOM and CSAF walker
-
messaging
two-way messaging crate
-
twovec
A data structure for storing 2 types of data in a packed, heap allocated array
-
unionfind
A union find library made for building type inference engines. Can be used as general purpose datastructure.
-
tdx-guest
The tdx-guest provides a Rust implementation of Intel® Trust Domain Extensions (Intel® TDX) Guest APIs, supporting for TDX Guest specific instructions, structures and functions
-
mapack
mapbox vector tiles
-
interavl
An optimised interval tree for efficient interval stabbing
-
influxdb-dispatcher
Batch metrics collection using influxdb
-
ptrie
Generic trie data structure implementation (prefix tree) with support for different key and value types, and functions to search for common prefixes or postfixes
-
orx-pinned-vec
PinnedVectrait defines the interface for vectors which guarantee that elements added to the vector are pinned to their memory locations unless explicitly changed -
fixed-vec-deque
A fixed-size, zero-allocation circular buffer for Rust
-
sstable
Sorted String Tables, an on-disk format for storing immutable maps consisting of string,string pairs, and retrieving values by key efficiently. This crate also features bloom filters…
-
cbsk_timer
rayon thread runtime
-
garnish_lang_annotations_collector
organize garnish annotations with related tokens
-
logisheets_controller
the core of LogiSheets
-
oxidd-manager-index
Index-based manager implementation for OxiDD
-
etwin_dinoparc_store
Dinoparc store implementation
-
trybox
stable,
no_std-compatible, fallible heap allocation -
fibis
fixed range bitset
-
no_std_collections
Auxiliary structures and traits for using dynamically resizable arrays (Vectors) in flexible environments, supporting both std and no_std contexts
-
artie_common
Common Library for Artie Rust Projects
-
aircraft_icao_country
aircraft ICAO codes and their country of origin
-
maelstrom-base
Fundamental data structures used by all Maelstrom code
-
cedarwood
efficiently-updatable double-array trie in Rust (ported from cedar)
-
daggy2
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.
-
iowrap
Small helpers for using io::Read/io::Write
-
ndim
N-dimensional array for numerals in Rust similar to NumPy
-
singletonThread
thread in a singleton
-
moniker
Automatically derive variable binding and alpha equivalence for abstract syntax trees
-
im_ternary_tree
Structural sharing ternary tree, i.e. immutable data structure
-
block-grid
A quick, cache-conscious, tiled 2D array
-
quadtree_simple
quadtree implementation
-
indexical
indexed collections
-
aatree
in Rust
-
lp-pack-scanner
scanner library
-
competitive-programming-rs
Competitive Programming Library in Rust
-
yyid
Yyid generator (random tokens like UUIDv4, but using all the bits)
-
floating_bar
Representing rational numbers using the floating-bar number type
-
mirl
Miners Rust Lib - A collection of ever growing functions and structs
-
quickselect
基于rust的选择算法
-
iterlist
Linked list with a cursor based api
-
palettevec
A palette compressed vector library for potentially insane runtime compression ratios
-
ndstruct
Structures for N-dimensions
-
set_genome
A genetic data structure for neuroevolution algorithms
-
mini-rx
bare-bones "reactive programming" (change propogation) using a central data dependency graph
-
entoli
A functional programming library inspired by haskell
-
magnetise
asses the similarity between SQL queries
-
eventio
A collection of event I/O processors for event-processing applications
-
itybity
An itty bitty crate providing bit iterators and bit iterator accessories
-
usize-set
Set data structures optimized to store sparsely distributed usize values
-
pasture-core
A framework for working with point cloud data
-
variant-rs
VARIANT support for Rust. Clean, idiomatic handling of WinAPI/COM results.
-
expiremap
Key-Value map where each value has a custom expiry time
-
irange
A data structure to store and manipulate ranges of integers with set operations
-
color-operators
Color data structures, converters, and arithmetic operators
-
disjoint-sets
Three union-find implementations
-
index-ext
Index slices with arbitrary ints and as arrays
-
ux-dataflow
Data Processing Library
-
ibuilder
Interactive builder for Rust types
-
sbbf-rs
Split block bloom filter implementation
-
ds-ext
Extensions to standard Rust data structures which provide additional capabilities
-
atomicow
A
Cow-like data structure where owned data is stored inside anArc -
ankurah-core
Core state management functionality for Ankurah
-
xsd
XSD.rs
-
trk-io
TrackVis (*.trk) reader and writer
-
ordes
treating arrays and tuples a little bit more like vectors
-
dusa_collection_utils
A common library with standardized functions that the ais_platform, dusa, recs and others will depend on
-
minivec
A version of Vec that's only the size of a single pointer
-
convenient-skiplist
Convenient and Performant SkipList with serde support
-
nested_intervals
nested & overlapping interval set functions, overlap, union, etc
-
libwebnovel-storage
A complement to libwebnovel: this package handles downloading and organizing collections of followed webnovels
-
commitlog
Sequential, disk-backed commit log library
-
coca
Data structures with constant capacity
-
grovedb-epoch-based-storage-flags
Epoch based storage flags for GroveDB
-
td-shim-interface
TD-shim metadata data structures and related functions. UEFI Platform Initializaiton data structures and accessors
-
anchors
async incremental computations
-
tord
Data structure to store transitive relations
-
stable-map
A hash map with temporarily stable indices
-
confiner
A config language for things that look like trees
-
micro_autotile
LDTK autotiling
-
coalesced_intervals
Data structure for maintaining maximally-coalesced 1D intervals
-
rust-tls-duplex-stream
Full Duplex stream Wrapper around rust-tls
-
sbwt
Indexing sets of DNA k-mers with the spectral Burrow-Wheeler transform
-
pi_append_vec
Only supports append vectors, lock free
-
lapce-xi-rope
A generic rope data structure built on top of B-Trees
-
ux-dx
3D Graphics Primitives for Angular Rust
-
hit-data
Hierarchical Indexed Typed data structure
-
loaned
Safely move values with live inner borrows
-
scribe
Text editor toolkit
-
lum_libs
Serves as a central collection and re-export of all external crates used in the lum framework to ensure consistent dependency versions across the framework
-
bytering
A ring buffer specialized for vectored reading and writing in blocking and async I/O
-
bin-it
efficient Rust library for binary serialization and deserialization
-
idbag
A bag of integers
-
super-struct
structofRustin the same way thatdictofPython -
defaultmap
HashMap with an automatic default for missing keys
-
indexedlinkedhashmap
An indexable LinkedHashMap. The user defines the data structure that controls order.
-
foyer-intrusive-collections
Intrusive collections for Rust (linked list and red-black tree)
-
scryer-modular-bitfield
Allows to easily define bitfield types with modular building blocks. This is a forked version of the modular-bitfield crate with tweaks for use by Scryer Prolog.
-
nintypes
Nintondo shared types
-
flat-tree
Series of functions to map a binary tree to a list
-
cmus-status
structure cmus status data
-
merkle-heapless
Statically-allocated Merkle Tree and Mountain Range
-
arraystring
Fixed capacity stack based generic string
-
school_library
structures to manage school-related data, including students, classes, and schools
-
israeli_queue_etc
various queues
-
gpt_disk_types
GPT (GUID Partition Table) disk data types no_std library
-
vec-btree-map
Basically just a sorted Vec that can be used as a HashMap
-
plane-2d
Continuous 2D data structure representing infinite 2d plane
-
cfpyo3_rs_core
a collection of performant utilities
-
timeless
storing in-memory timeseries data
-
arr-rs
arrays library
-
hdf5-dst
DST extensions for HDF5
-
pinocchio-token
Pinocchio helpers to invoke Token program instructions
-
mset
/ multiset / bag implementation
-
flo_rope
An attributed and streaming implementation of the rope data structure
-
enso-data
A collection of useful data structures
-
multi_index_map
MultiIndexMap: A generic multi index map inspired by boost multi index containers
-
penumbra-sdk-num
Numerical data structures and implementations used by Penumbra
-
vf-rs
A set of classes generated from the ValueFlows RDF schema
-
exact-covers
Knuth's algorithm for solving the exact cover problem with colors
-
fdec
A collection of macros for generating fixed-size fixed-point numeric types for Rust
-
gw_signal
Package with signal processing tools for graviational waves studies
-
leveled-hash-map
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…
-
parallel_vec
A generic contiguous collection of heterogenous values
-
bitvector
in Rust
-
rtdlib
TDLib for rust
-
probabilistic-collections
Various implementations of collections that use approximations to improve on running time or memory, but introduce a certain amount of error
-
ascent-byods-rels
data structures for Ascent relations, made possible by Ascent's BYODS feature
-
incrstruct
Build self-referencing structs using two-phase initialization
-
range_minimum_query
Range Minimum Query (RMQ) is used on arrays to find the position of an element with the minimum value between two specified indices
-
enum_meta
Add metadata to Enum Variants
-
incrementalmerkletree-testing
Common types, interfaces, and utilities for testing Merkle tree data structures
-
ndarray-ndimage
Multidimensional image processing for ArrayBase, the n-dimensional array data structure provided by ndarray
-
mphf_benchmark
The program for benchmarking Minimal Perfect Hash Functions
-
serde-request-envelope
A serde request envelope with named type and data fields
-
sampling-tree
sampling tree implementation for sampling discrete distributions with sparse dynamic updates. This allows us to sample efficiently from a distribution given the relative importance of each datapoint…
-
forest-ds
secure tree structure
-
im-lists
Persistent unrolled linked lists and vlists
-
cmdtree
(Rust) commands tree
-
laurier
ratatui helper library
-
linked-list
An alternative implementation of std::collections::LinkedList
-
swaybar-types
building swaybar status commands in rust
-
sweetrpg-model-core
Core model definitions for SweetRPG
-
hash_histogram
HashHistogram creates histograms with keys of any hashable data type. Features include rank ordering and mode.
-
validiter
Iterator adapters for validating iterations
-
token-lists
token list representation
-
nostd-bv
Bit-vectors and bit-slices
-
json-flat-parser
Parse JSON document into a flat data structure
-
lace_stats
Contains component model and hyperprior specifications
-
sparse_set_container
A container based on sparse set. Stable keys, O(1) lookup, cache-friendly iterations, and no hashing.
-
shiftnanigans
contains different iteration data structures for either iterating or for shifting iteratively forward and backward
-
genmap
generational map data structure with no dependencies
-
lodtree
help create octrees and quadtrees for chunked level of detail
-
dyn_list
A linked list that can hold dynamically sized values in its nodes
-
sequential_gen
sequential generator
-
onebuck
An efficient unordered dynamically-sized data structure
-
vec-collections
Rust collections that are newtype wrappers around smallvec
-
td-wavegen
Tower Defense mob wave generator
-
dipa
dipa makes it easy to efficiently delta encode large Rust data structures
-
im-rc
Immutable collection datatypes (the fast but not thread safe version)
-
strumbra
Umbra-style strings (also known as German strings)
-
try-lazy-init
Fallible lazy initialization
-
ofilter
fast thread-safe Bloom filter
-
anndata-memory
Thread-safe AnnData-like structure for single-cell genomics data in Rust. Provides controlled mutability, efficient memory management, and flexible data manipulation. Ideal for concurrent bioinformatics applications.
-
safer_owning_ref
creating references that carry their owner with them
-
tuple_list
macro-free variadic tuple metaprogramming
-
uuidv7
UUIDv7 implementation
-
higher
Functors, Applicatives, Monads and other bad ideas
-
phylo
An extensible Phylogenetics library written in rust
-
pi_densevec
重定向映射表，一个使用usize作为key的映射表
-
hprtree
A Hilbert-Packed-R-Tree implementation for rust
-
hrtb-lending-iterator
A lending iterator trait based on higher-rank trait bounds (HRTBs)
-
safe_index
Type-safe indexes
-
leetcode-trees-rs
Tree Node LeetCode problems
-
half-2
Half-precision floating point f16 and bf16 types for Rust implementing the IEEE 754-2008 standard binary16 and bfloat16 types. Fork of half by Kathryn Long
-
spenso
A tensor (n-dim array) network, iterating, and contraction (using automatic abstract index matching) library
-
dcl_data_structures
Data structures for for deep_causality crate
-
text-style
Types and conversions for styled text
-
modern-multiset
A hash multiset implementation
-
mago-token
Defines the data structures and enumerations representing PHP tokens
-
big_unsigned_ints
Big Unsigned Integers ranging from U256 to U2048 using u64 arrays all under a fixed-size of 32
-
depends
Ergonomic, performant, incremental computation between arbitrary types
-
fenwick
tree: data structure that efficiently calculates prefix sums in a changing array of numbers
-
nlist
inline-allocated list with statically tracked length
-
tree-mapper
generating a hierarchical mapping of files and directories represented as a HashMap. The mapping reflects the directory structure and file levels, allowing for efficient retrieval and…
-
any-range
AnyRange<T> enum can hold any Range*<T> type
-
rexsgdata
Scatter-Gather Data Descriptors
-
cbsk_mut_data
ref mut tool
-
range_bounds_map
[
RangeBoundsMap] and [RangeBoundsSet], Data Structures for storing non-overlapping intervals based of [BTreeMap] -
tensorism
Multidimensional arrays with bounds included in the type system
-
codes-iso-639
This package contains an implementation of the ISO 639 (Parts 1, 3, and 5) Language Code specifications
-
sentry-contrib-breakpad
Unopinionated crash collection for Sentry reporting purposes
-
crater
Very generic containers including KD trees, fibonacci heaps, minmax heaps,
-
slablit
Literal for slab creation
-
malwaredb-api
Common API endpoints and data types for MalwareDB components
-
non-random-state
Deterministic HashMap and HashSets
-
emap
A map with a fixed capacity and integers as keys
-
pi_slot
lock free Slotmap data structure
-
flat_collections
Lightweight and memory-efficient associative data structures
-
chesspos
Basic structs for representing chess squares
-
frunk-enum-core
Implemenation of genericized enums for use with frunk
-
cow_vec_item
Copy-on-write Vec, available on stable rust
-
vec-string
To print Vec<Display>
-
rust_twostack
Support for two-dimentional stacks for the Rust programming language
-
ssd-data
A service and data description format + a code generator based on rhai scripts and templates
-
riddance
retiring, recyclable, reservable IDs
-
gecs
A generated entity component system
-
code_location
UNMAINTAINED! Use std::panic::Location instead!
-
point-nd
flexible no-std struct to model points on axes of any dimensions
-
suff_collections
Fast realization of suffix array and suffix tree
-
text-document
Text document structure and management
-
sweep-bptree
In memory locality aware b+ tree, faster for ordered access
-
smallbitset
series of allocation free sets capable of holding small integer values
-
i_tree
Red-black tree implementation for rust. Only for uniq elements
-
chronofold
A conflict-free replicated data structure (a.k.a CRDT) for versioned text
-
itc
Interval Tree Clocks as described in the itc2008 paper
-
modular-bitfield-msb
Allows to easily define bitfield types with modular building blocks. MSB-first version.
-
histogram-sampler
Sampling from a distribution given by a histogram
-
data_model
[highly unstable] data model for virtualization
-
generic-btree
Generic BTree for versatile purposes
-
orchestrator
Orchestration sequences
-
wasmrs-frames
WasmRS RSocket frame decoding, encoding, and data structures
-
dayendar
advanced days calendar operations
-
expanding_slice_rb
A self-expanding ring buffer similar to VecDeque optimized for working with slices of data
-
hicollections
C-liked Collections
-
arraysetcell
A fixed-capacity, vector-like array with interior mutability and no ordering guarantees
-
twice-cell
Like
once-cell, except you set the value twice -
canadensis_dsdl_frontend
Compiler front-end for the Cyphal Data Structure Description Language
-
prefix-tree-rs
A Trie (prefix tree) implementation
-
dartlib
Disk backed concurrent Adaptive Radix Tree implementation, with optional generations
-
vecdeque-stableix
Deque with stable index values
-
loaded_dice
sampler for loaded dices, implementing the alias method
-
rt_map
Runtime managed mutable borrowing from a map
-
msg-store
A fast and light-weight message store designed to work as a priority queue in low hardware equiped devices
-
typeslice
type-level slices
-
scored_set
A scored sorted set data structure for Rust
-
float16
Half-precision floating point f16 and bf16 types for Rust implementing the IEEE 754-2008 standard binary16 and bfloat16 types
-
rive
ecosystem crate
-
rep
A small tool for representation/class invariants
-
mist-lib
Juniper Mist Schema Definitions
-
sif-kdtree
immutable, flat k-d tree
-
zk-kit-smt
Sparse Merkle Tree
-
xot
Full-featured XML tree library for Rust
-
tc-value
TinyChain's representation of a value which can be collated and stored
-
zond
standard rust collections but with collecting statistics
-
string_manipulation_utf8
String manipulation functions using character indexing (UTF-8) instead of bytes
-
committable
Keccak256-based structured commitments
-
ioc
An Inversion-of-Control library in Rust
-
rdf-format
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
ndarray-histogram
Histogram support for n-dimensional arrays
-
alignment-exporter
Proc macro providing alignment info for a user-defined struct
-
medianheap
A median heap for keeping track of a running median
-
codas-flow
Low-latency, high-throughput bounded queues ("data flows") for (a)synchronous and event-driven systems
-
gen_value
indexes and values with generations for vectors
-
anymap2
A safe and convenient store for one value of each type
-
type-rules
easily constrain a struct
-
output_iter
An iterator that performs calculation during iteration
-
arbutus
Trees
-
fixed_deque
A fixed size VecDeque to match Python Deque
-
write_x86_64
help you write x86_64 assembly code
-
ttmap
Trivial implementation of type map
-
pimalaya-tui
Collection of crossterm widgets shared accross Pimalaya projects
-
indexed_json
Index json files like a database
-
wplot
Plot interface
-
mikufans-proto-intl
gRPC APIs for Mikufans (Intl)
-
retaker
ecs implementation
-
gdsl
graph data-structure library including graph containers, connected node strutures and efficient algorithms on those structures. Nodes are independent of a graph container and can be used as connected smart pointers
-
ast2str
pretty-printing ASTs and other recursive data structures
-
easy_collections
Wrappers around standard collections for ease of use and quick prototyping
-
lru-st
A package providing a Vec based doubly linked list implementation and related data structures
-
sortedvec
a sorted vector that enables quick lookups
-
croaring-sys
Raw bindings to CRoaring
-
msgpack_simple
Simplified, easy to use, pure Rust MessagePack implementation focused on handling dynamic data structures
-
mago-reflection
Offers data structures and APIs to represent and inspect PHP code elements—like classes, functions, and interfaces—enabling introspection and analysis
-
circbuf
A growable circular buffer for working with bytes
-
uniquevec
A
Vec-like datastructure which only contains unique entries. It is no_std and has optional serde support. -
jsonmap
store values of multiple types value in one Map
-
default-vec2
Vec-like data structure with default elements and a bitset built using it -
automerge-test
testing automerge libraries
-
bytesbox
ByteBox is a high-performance hash map implementation optimized for byte slices. It efficiently maps keys and values of type Vec<u8>, providing full ownership of the data. ByteBox uses…
-
sql-json-path
SQL/JSON Path implementation in Rust
-
sparse-merkle-tree
Sparse merkle tree implement in rust
-
spatialize
collection of spatial data structures used for efficent spatial partitioning
-
deinterleave
your datastructures
-
rust-3d
2D/3D library written in rust
-
rc-writer
A tiny implement for writing data to a reference counted instance
-
alt-std
Alternative Lightweight Std library for making small executables and shared objects
-
loro-delta
Loro internal library. It's used as a delta between two versions of text or lists. It's also an efficient Rope.
-
touch-selection
Selection data structure intended for touch and single button devices
-
tinybox
Like
Box, but with an optimization that avoids allocations for small data-structures -
hdf5-hl
High level bindings to HDF5 High Level API
-
cow_hashmap
Hashmap with copy-on-write semantics that requires no locks
-
rj
reactive json
-
compare
Experimental comparators for collections to be generic over
-
mih-rs
Multi-index hashing (MIH) for neighbor searches on binary codes in the Hamming space
-
tree-sitter-traversal2
Traversal of tree-sitter Trees and any arbitrary tree with a TreeCursor-like interface
-
byteview
Thin, immutable zero-copy slice type
-
plexus
2D and 3D mesh processing
-
owning_ref
creating references that carry their owner with them
-
netcrab
creating and exporting Petri nets
-
higher-free-macro
macro that creates a (naive) Free Monad type based on a user-supplied Functor. It uses the traits from the "higher" crate. This macro is a port of the Control.Monad.Free part of the…
-
deepmesa
fast Data Structures and Algorithms in Rust. Every data structure is hand crafted for performance, well tested and has an extensive API.
-
bittyset
A BitSet type for manipulating bit sets
-
tuco
Tuco can automatically generate tuple representations of simple types. This is helpful if you want to create an API using plain types. Or if you want to provide an easy way to convert between types.
-
entity
that provides entity-like constructs
-
pax-properties-coproduct
Static container for program-variable data structures and polymorphic components
-
gix-hashtable
that provides hashtable based data structures optimized to utilize ObjectId keys
-
galemu
workaround for generic associated types (GAT) limited to lifetimes (GAL)
-
open-coroutine-timer
The time utils
-
rs_filter
filter library for matching on complex data structures
-
bit-int
An arbitrary fixed bit-width integer library
-
packed_ptr
A configurable & generic tagged pointer implementation in Rust
-
pointcloud
An accessor layer for goko
-
structures
collection data structures
-
syzlang-parser
Parse Syzlang language
-
minsize
Collections with a statically known minimum size (using const generics)
-
bdaddr
Bluetooth Device Address
-
contack
easy contact library
-
rle_vec
A vector like struct that stores data as runs of identical values. Useful for storing sparse data.
-
union-fn
Proc. macro for creating efficient "inline closures".
-
zngur-def
Data types that define the structure of a zng file
-
seq-map
Sequential Map
-
sweetrpg-kv-objects
Objects for Key-value store
-
timer_list
A list of timed events that will be triggered sequentially when the timer expires
-
latestmap
latest map
-
xbinser
binary structure transporation
-
kv6
Collection of structs to allow reading of Ken Silverman's voxel formats
-
ordmask
To check if a value is included efficiently
-
range_map_vec
range map data structure backed by a Vec
-
implies
A parser for logical formulas
-
proptest-recurse
Helper for defining mutually recursive strategies with proptest
-
sum
General-purpose sum types
-
diffogus
calculate the difference between 2 instances of a type
-
product-os-openapi
Product OS : OpenAPI provides a set of structs for defining the structure of an OpenAPI / Swagger specification. This crate is intended to be used with Product OS : Connector.
-
valser
Structure schema library for Rust
-
median-heap
A median heap implementation in Rust, used to keep track of a running median of a sequence of numbers
-
timer-queue
Pure, minimal, and scalable timers
-
streaming_algorithms
SIMD-accelerated implementations of various streaming algorithms, including Count–min sketch, Top k, HyperLogLog, Reservoir sampling
-
mco-gen
Stackfull Generator Library in Rust
-
mqfilters
Highly optimized approximate membership query filters (bloom, cuckoo, xor, quotient) with SIMD support
-
flex-alloc
Data structures with extra flexible storage
-
comparer
track changes in a HashMap over several iterations
-
varlen
Ergonomic variable-length types
-
mut-rc
Temporarily mutable
Rc<T>that decays intoRc<T> -
intervaltree
generic implementation of an immutable interval tree
-
arc-bytes
A reference-counted byte buffer
-
kdtree-simd
K-dimensional tree in Rust for fast geospatial indexing and nearest neighbors lookup
-
atomic_lifo
Lock free thread-safe lifo for rust
-
pin_array
Tiny crate providing an array with structurally projected pinning
-
sbom-walker
work with SBOM data
-
ordered_hash_map
HashMap which preserves insertion order
-
pi_ordmap
Ord Map
-
compt
A complete binary tree visitor library
-
indexmap-nostd
A no_std compatible implementation of the indexmap crate
-
honeycomb-kernels
Meshing kernel implementations using combinatorial maps
-
collect-rs
Special and custom Collections and Containers (for Rust)
-
boolvec
A vector of boolean stored contiguously in memory
-
gw2timers
Iterate and collect Guild Wars 2 map meta event times
-
mini_uuid
A small and URL-safe UUID crate for Rust
-
small-world-rs
The easiest HNSW vector index you'll ever use
-
phf_mut
Perfectly hashed mutable containers
-
voxtree
A sparse voxel octree for rust & rust-gpu
-
is_affected_lib
checking and listing the affected resources across a range of commits, useful when working with monorepos
-
bitlab
Extracting a range of bits from a binary data source
-
broomdog
A type-erased map with 'indefinite loanership'
-
steiner-tree
Fast construction of rectilinear steiner minimal trees (RSMT) in two dimensions
-
spaceindex
-
expiringmap
a HashMap-backed TTL map
-
clonelicious
macro library that simplifies cloning and closure execution. The
clone!macro automatically clones variables and immediately executes the closure with the cloned values, streamlining… -
rs-car
CAR v1 and v2 specifications
-
optempty
Tools for working types that may be empty. E.g., an empty
String,Vec,HashMap, etc. -
bgp-models
Structs and other building blocks for BGP and MRT related Rust projects
-
sparseset
A Sparse Set
-
grdf
Generalized RDF graphs and datasets
-
alist
Association list offering fast lookups while preserving insertion order
-
supertrees
Supervision trees for Tokio-based services inspired by Erlang/OTP
-
rmat
minimal implementation of two-dimensional matrix algebra
-
sliding_tree
A tree that grows from the leaves and recedes from the root
-
froop
A functional reactive stream library for rust
-
superset_map
Map that stores distinct supersets based on the total order defined
-
art-tree
The Adaptive Radix Tree
-
copse
Direct ports of the standard library’s BTreeMap, BTreeSet and BinaryHeap collections, but that sort according to a specified total order rather than the
Ordtrait -
tan-lints
A collection of lints for the Tan Language
-
tracing-rc
Cycle-aware reference-counted pointers with a safe, simple api
-
hashstash
It's like git but for your Rust data structures
-
bit-parallelism
Small integer specialized, word level, parallel algorithms and data structures
-
quickscope
Multi-layer HashMap and HashSet implementations for performant representation of variable scopes
-
crdt_tree
Tree Conflict-free Replicated Data Type (CRDT)
-
meminterval
interval-tree in Rust made to store memory mappings
-
serde_either
set to enums to deserialize and serialize data that can either be string, struct or vec
-
aversion
Versioned data structures with auto-upgrading
-
smart_access
A minimalistic "lazy bidirectional pointer" framework
-
osmgraph
Convert OSM queries into graphs
-
triangle_matrix
Triangle matrix indexing operations
-
omango-util
Utililites
-
bloom-filter-yss
bloom filter for me or you
-
bevy_tiles
Bevy library for working with entities in grids
-
uintx
Unaligned unsigned integers with exact size in memory and arithmetic operations for them
-
oxidd-cache
Apply cache for OxiDD
-
word-dictionary
data structure for word mapping. It can be used for language translation.
-
holyhashmap
A hash map with stable indices
-
segment-tree
Quickly perform interval queries or modifications
-
orn
A general implementation of the sum type. Meant to be a generic counterpart to tuples.
-
specs-hierarchy
Scene graph type hierarchy abstraction for use with specs
-
validbr
data structure and validation for Brazilian Registries, such as CPF, CNPJ and CNH (currently only CPF and CNPJ is supported)
-
evento-store
A collection of libraries and tools that help you build DDD, CQRS, and event sourcing
-
array-const-fn-init
Initializes an array with constant values calculated by a
const fn -
radix-heap
Fast monotone priority queues
-
incremental-map
combinators for incremental immutable maps (see crate
incremental) -
disk-ringbuffer
lock free on disk ringbuffer to be used in the implementation of Franz
-
twitter/rustcommon-time
getting current and recent timestamps
-
ldtk_map
reading ldtk maps for usage in games
-
fixed_bitmaps
A small crate implementing bitmap functionality around primitive Rust unsigned integers
-
raw-btree
Generic B-Tree implementation
-
tpntree
A N-dimensional generalization of region quad/oc-trees
-
spaghetto
making double-ended data structures, like an always-contigouous double-ended queue (deque) and double-ended string
-
div-int
Rational numbers with a compile-time denominator
-
rotated-array-set
An ordered set supporting O(1) rank and O(√n) inserts and deletes
-
redmaple
offers an oppinionated yet extremely flexible data modeling system based on events for backend applications
-
grid2d
Two dimensional grid of runtime-defined, but unchangable size
-
merkle
tree implementation with support for generation of inclusion proofs
-
signvec
Vector implementation for fast, sign-based manipulation of dynamic collections
-
membuffer
A very fast flat memory buffer used to deserialize at a fast speed
-
pulz-arena
A generational arena allocator with compact generational indices
-
kampu
Generic byte array parser function where you can define the structure/tree of the bytes in JSON, send it a byte array and get the parsed output in JSON
-
vortex-runend
Vortex run end encoded array
-
wolf-graph
Data structures and algorithms for working with graphs with reference or value semantics
-
lurk-elsa
Append-only collections for Rust where borrows to entries can outlive insertions
-
vlcb-defs
VLCB protocol core library containing important value definitions and data structures
-
inplace-vec-builder
Build a vec from a vec, in place
-
grids
2D grid data structure for games
-
light-curve-interpol
Interpolations tools for time series
-
fixstr
fixing strings
-
sif-itree
immutable, flat interval tree
-
hash-chain
A tiered hashmap and hashset implementation that allows for easily representing lexically scoped variables
-
v9
A slim data engine for Data Oriented Design
-
big-tuple
providing trait implementations for tuples of up to 128 elements
-
bayesic
A string matching library similar to NaiveBayes but optimized for many small classifications
-
manhattan-tree
A spatial tree which can effiently find closest key to a point, by manhattan distance
-
wccg-models
WCCG Data
-
egui_suspense
Automatically show loading and error uis for egui
-
rstmt
focuses on building a music theory library that can be used to generate music theory data structures and algorithms
-
limq
Queue with optional maximum number of elements constraint
-
eastl-rs
EASTL binary-compatible Rust implementations
-
penumbra-sdk-transaction
Core transaction data structures for Penumbra
-
overtone
An API for creation and management of rich (as in rich-text) musical-ish projects
-
villa01-data-structures
Personal crate of me trying to implement data structures and algorithms in Rust
-
netlist
generic netlist data structure for VLSI design
-
fenwick-bit-tree
Slighly over-engineered FenwickTree implmentation
-
arbitrary-chunks
An iterator that allows specifying an input array of arbitrary chunk-sizes with which to split a vector or array
-
small_iter
A 3-pointer iterator that moves out of a
Vec<T>orBox<[T]> -
b-tree
A persistent B+ tree using freqfs
-
sorted_vector_map
maps and sets backed by sorted vectors
-
llist
Lisp-style singly-linked list
-
neighborhood-diversity
computing the neighborhood diversity of simple, undirected graphs
-
slice-rbtree
A slice-based Red-black tree
-
rive-models
Revolt API models for the Rive ecosystem
-
giftbox
A fun Rust crate called
giftboxto help Rustlings learn and explore generics -
zhifeng_impl_barnes_hut_tree
implements Barns-Hut Tree for accelerated N-body force calculation
-
fn-map
Abstraction around HashMap. Uses closure to compute and store value.
-
hst-tw-images
working with Twitter profile images
-
intervals-rs
intervals
-
pvec
RRB-Tree based persistent vector implementation
-
debug_match
debugging and matching patterns in data structures
-
moving_min_max
Tracking minimum or maximum of sliding windows
-
array_map
Map backed array for fixed size keys with O(1) performance
-
kvv-efa-api
Rust bindings for the KVV (Karlsruher Verkehrs Verbund) "EFA"-API
-
relational_types
Manage relations between objects
-
rutenspitz
А procedural macro to be used for testing/fuzzing stateful models against a semantically equivalent but obviously correct implementation
-
memvec
Memory-backed vector, not buffer. Designed for for mmap. Not MemMap, but MemVec!
-
groupex
Syncronization primitive that allows acquire lock by index
-
header-vec
Vector with user-specified header, length, capacity, and array elements all stored on the heap together
-
resizing-vec
An automatic resizing vector for data with linear increasing ids
-
multiset
Multisets/bags
-
succinct
data structures for Rust
-
tryingarraylist
arraylist implementation
-
grid-tree
Pixel quadtrees and voxel octrees
-
thinset
A data structure for sparse sets of unsigned integers that sacrifices space for speed
-
valord-map
A dictionary sorted by values
-
pi_sinfo
used to describe the 'structure', that is, the meta information of the structure
-
supply-chain-trust-example-crate-000048
Types and traits for working with bytes
-
purse
Bag data structure implementation in Rust
-
veho
a iterable toolset
-
cseq
compact sequences
-
panoradix
A generic map and a set, both backed by a Radix tree
-
lignin
A virtual DOM structure, primarily for web use
-
grit-bitvec
BitVec, a vector type that can store fixed-width data with irregular bit widths
-
nakadi-types
A connector for the Nakadi Event Broker
-
predicates-tree
Render boolean-valued predicate functions results as a tree
-
ra-ap-rustc_data_structures
Automatically published version of the package
rustc_data_structuresin the rust-lang/rust repository from commit 5113ed28ea1451a13eae3a05dca0dbabfd56f587 The publishing script for this crate lives at:… -
teardown_tree
A binary search tree that supports fast clone and delete-range operations
-
flange-flat-tree
A tree that can be expanded by attaching new values to the node without mutability of the old ones
-
total-maps
Maps where every possible key has an associated value
-
smolset
" An unordered set of elements optimized for small sizes. This is a fork of the original library with overhauled internals, better fallback perforamance (O(1) insert and find) and more features!
-
xsparseset
sparse set
-
find-all-the-kitty-cats-in-charlotte
A collection of crates for working with cats
-
thot-core
Core functionality and types for Thot data management and analysis software
-
grovedb-visualize
Debug prints extension crate for GroveDB
-
pbloom
A portable bloom filter implementation in Rust
-
tinybitset
Generic implementation of small, fixed size, copyable bitsets
-
recursive_reference
way to walk on recursive structures easily and safely
-
cervine
A slightly more flexible Cow; roughly to T: Borrow<R> as alloc::borrow::Cow is to B: ToOwned
-
scoped_stack
A scoped stack data structure
-
flatbuffers-retained
allows a user to validate a flatbuffer once and the move it around or store it in a data structure without keeping the buffer borrowed. Then later it can be used again without re-validation.
-
typerat
Type-level rational numbers based on
typenum -
chainmap
mutability of intermediate maps
-
zetacore
in-memory vector store library with Python bindings
-
kushi
A queue built for the Dango Music Player and Oden Music Bot
-
supply-chain-trust-example-crate-000019
A hash table with consistent order and fast iteration
-
diamond-types
The world's fastest text CRDT
-
equivalent-flipped
Similar to
equivalentcrate, but flipsKandQ -
kd-tree-rs
k-d tree
-
myopic
A possibly bad lens library for Rust
-
extensions-rs
File extension types in Rust
-
orbweaver
designed for effortless construction and analysis of graph data structures
-
generational-indextree
Arena based tree structure by using indices instead of reference counted pointers
-
staticvec
Implements a fixed-capacity stack-allocated Vec alternative backed by an array, using const generics
-
cast-rs
A collection of types cast for Rust
-
dsa_sport
revision material for undergrads
-
oxidd-rules-tdd
Ternary decision diagrams (TDDs) for OxiDD
-
prototty_common
Definition of common ui elements and views for use with prototty
-
beehive
collections for 3D hexagonal maps
-
chain-map
A chain of maps with a single view into the aggregated values
-
dakv_skiplist
skiplist for dakv
-
stealth-lib
functions for ZKP
-
fns
add common fn, eg: debounce, throttle
-
attr
attris 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 -
sidex
A format- and language-agnostic data structure and API definition language
-
takeable
Container type that allows for temporarily moving out of the container, or permanently moving out and invalidating the container
-
bitset-core
Straightforward, no-std compatible, simd optimized, BitSet API
-
extended-rational
implementations of high-accuracy projectively-extended rational numbers and macros for creating them
-
dade
data definition for Rust structures
-
screech
A collection of helpers for handling audio data in real time
-
driftdb
A real-time data backend for browser-based applications (core library)
-
enum-tag
Proc. macro for generating enum discriminant types.
-
numas
multidimensional array for efficient computing
-
supply-chain-trust-example-crate-000058
Generic types implementing functionality of arrays
-
luthor
A collection of lexers for various languages/formats, and the tools required to build them
-
rosary
About Rose Trees
-
rdc
generating Java code from rust structs
-
tilecoding
Dr. Richard S. Sutton's tile coding software.
-
double-map
A HashMap with double key to single data/value
-
crio
An easy to use persistent data storage library
-
id_collections
Index-oriented programming in Rust
-
rustz
functional programming in Rust
-
range_union_find
A union-find data structure for ranges
-
prefix_array
A generic container for searching on prefixes of keys
-
seq_watcher
A pair of structures for monitoring a stream of data for one or more sequences
-
nanotweaks-proc
moved to https://crates.io/crates/spread_macros
-
bitvek
bit vector implementation
-
cycle_map
Implementations of bi-directionally accessible hashmaps
-
slice-find
SliceFind trait add .find() method (for search sub-slice in slice) to Vec, slice, fixed-length-slice in standard library
-
comprende
Python-style collection comprehensions in Rust
-
pac_cell
Parent and child cell
-
hydroperfox-smodel
Semantic modeling for Rust
-
lumberjack
Read and modify constituency trees
-
wavelet-matrix
A wavelet matrix implementation. Supports various near-O(1) queries on large number of symbols or integers.
-
billios
A soil library
-
tst
Ternary search trie collection in rust with similar API to std::collections as it possible
-
acme-types
Types for implementing ACME (RFC 8555) providers and clients
-
esl01-indexedlog
Append-only on-disk storage with integrity checks and indexing support
-
persist-o-vec
A Vec type that aims to have stable indices and memory location
-
constructivism
Simplify the construction of structured data
-
varflags
exporting varflags macro, allowing to use unit-like enums in conjunction with Varflags struct to create easy to use bitflags data structure defined over enum variants
-
nanovec
Arrays and Vec-likes of small integers packed in an integer or two
-
pciids
parse the pci.ids data file
-
evicting_cache_map
An Evicting LRU cache supporting prune hooks
-
fid
FID (Fully Indexable Dictionary) implementation for Rust
-
modupipe
A modular and extensible ETL-like pipeline builder
-
make-message-bus
Generate a pub-sub bus for use in async applications
-
vicardi
JSON VCardArray Generator that uses Serde
-
serde_single_or_vec
Type which can be deserialized from either a sequence or a single value
-
pl-lens
support for lenses, which are a mechanism in functional programming for focusing on a part of a complex data structure
-
mine_sweeperr
Minimalist interface to manage the backed of a mine sweeper game
-
grovedb-version
Versioning library for Platform
-
ultragraph
Hypergraph data structure
-
tudelft-dsmr-output-generator
Companion library for the TU Delft Software Fundamentals individual assignment
-
ndshape
fast linearization of N-dimensional array indices
-
python-objects
that implements the architecture of the CPython objects. with this crate you can crate a list with any data type from rust
-
statemachine-rs
A statemachine crate which have zero dependencies
-
aabel-multihash-rs
extends Hasher trait. The added functionality allows users to get sequeces of hash values. It can be used inside of implementations of probabilistic data structures such bloom filter or count-min.
-
unicase_collections
Collection of UniCase datastructures
-
st2-logformat
Adapter-agnostic definitions for data types used by ST2
-
colibri
Rust data structures for Jitsi Meet Colibri messages
-
skog
Adobe's stlab::forest data structure
-
landfill
Various types for dealing with on-disk data
-
chainbuf
Fast chained buffers
-
nimbusqueue
fifo collection
-
arc-string-interner
An efficient cuncurrent string interning data structure with minimal memory-footprint and fast access to the underlying contents
-
caffeine
Collection of data structures I'm writing for fun. Originally written for use with my crafting interpeters tutorial implementation.
-
google-contacts-csv
Struct defined to hold the contact information from the Google contact file
-
periodic-rs
Bounded datastructures
-
clap_flags
Collection of reusable flags for Clap
-
stonks
Sets that allow borrowing while inserting entries
-
finite-automata
A collection of extendable finite automata with immutable state and transition data
-
actions
Software without side-effects. Redo and Undo. Macro's.
-
ternary-tree
Ternary Search Trees, with no unsafe blocks
-
upair
Unordered pair data structure
-
win-variant
that aims to provide a more ergonomic way of working with variants in winapi based projects
-
rk-utils
A collection of utility functions and data structures for rust
-
nslice
Structures for interpreting slices of variable length as arrays
-
range-mutex
A
Mutex<[T]>-like type, that allows locking different ranges separately -
libreda-splay
Splay map and splay set data structures
-
splay_tree
Splay Tree based Data Structures (map, set, heap)
-
weak-lists
Lists with weak references and concurrent iteration and modification
-
vec-with-gaps
A data structure that behaves like a vec of vecs, but where the subvecs are kept in one contiguous section of memory, which improves cache performance for some workloads
-
generic_event_queue
generic event-queue API
-
atree
An arena based tree structure with removal support
-
simple-vec-collections
Collections implemented using Vec
-
linear-hashtbl
Linear probing hash table
-
symbolic-sets
Sets that are stored symbolically
-
canadensis_bit_length_set
A bit length set type used to calculate data type sizes when processing Cyphal data structure description language files
-
associated_list
An associated list, for cases when the key implements neither Hash nor Ord
-
learn_together
Curated collection of lists of useful resources to learn Rust together
-
im-pathtree
Immutable, path-addressable tree data structure
-
insrcdata
Embed static data as source code
-
queued_rust
queue type for better privacy managment and data orginization
-
crfsuite-sys
Rust binding to crfsuite
-
mergle
A data structure with fast merging and comparison
-
shogiutil
A collection of tools to handle shogi data
-
aleo-agent
Agent library to communicate with the Aleo Blockchain, following the Public Specification
-
bucket_vec
A vector-like data structure that guarantees to never move its contained elements
-
gsgdt
Generic Stringly Typed Graph Datatype
-
quickphf_codegen
Code generator for creating static maps and sets for use with quickphf
-
listfree
lockfree prepend-only list
-
cbsk_log
log tool
-
multipath
split file path, like
/home/{user,admin}/file.txt -
unnamed_entity
Strongly-typed indexing for vectors and other structures
-
rahashmap
Fork of standard library HashMap with additional functionality
-
arrayy
Stack-allocated fixed-size array with useful methods on top of Rust's [T; L] type
-
folketinget-api-models
Autogenerated Rust structures based on the Danish Parliament's OData metadatafile
-
minimizer-queue
Fast computation of minimizers using a monotone queue
-
riblt
Rateless Invertable Bloom Lookup Table (RIBLT) data structure
-
bktree
BK-tree datastructure
-
handlemap
A collection that produces handles that can be used as keys to retrieve the stored items
-
redox_simple_endian
A create for defining endianness within your data structures, to make handling portable data structures simpler
-
atlv
Algebraic Tag Length Value encoding
-
path-value
Universal type and access property(s) by path
-
vec-option
A space optimized version of
Vec<Option<T>>that stores the discriminant seperately -
patricia_router
Radix Tree implementation for Rust
-
partial
Optional monad with fake variant
-
circular-queue
A circular buffer-like queue
-
cycler
A simultainious write/read data structure
-
large_int
An ease-of-use unbounded signed integer
-
rimu-value
A data structure template system
-
range-map
Maps and sets implemented using ranges
-
simple-rate-limit
Rate limit enforcement as simple data structures, no atomics
-
epoch32
32-bit Epoch with specified starting year
-
rustic_core
fast, encrypted, deduplicated backups that powers rustic-rs
-
render_as_tree
visualizing tree data structures via text
-
tailvec
Split Vec to mutable slice and TailVec, the TailVec can push or pop etc
-
simple-undo
Easy to use undo-redo library
-
hamst
Hash Array Mapped Shareable Trie
-
fst-map
succinct map
-
merkle-cbt-lean
Special implementation of Complete Merkle Binary Tree for minimal memory footprint
-
arena64
A concurrent arena providing mutually exclusive access over indexes
-
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.
-
bit-array-rs
Bit Array
-
distant-protocol
Protocol library for distant, providing data structures used between the client and server
-
liblet
learning about formal languages and grammars
-
rs-tree-sitter-languages
Collection of Tree-Sitter parsers
-
wrapping
slices and arrays
-
zaplib_components
The widget toolkit for Zaplib
-
int-vec-2d
Vectors, points, rectangles, etc. with
i16coordinates. -
qualia
Basic semi-schemaless document store
-
gpt_disk_io
GPT (GUID Partition Table) disk IO no_std library
-
append-only
Append only versions of std data structures
-
rolling_norm
Computes the rolling mean, variance, standard derivation and norm
-
multi_containers
Ergonomically work with multiple values per key
-
RustyDSA
A libary for Rust data structure
-
torro
A correct and easy-to-use BitTorrent library
-
sweeper
A foundation for Minesweeper implementations in Rust
-
leetcode-solutions
A collection of leetcode solution in rust
-
restorable
An iterator adapter for saving and restoring iterator state
-
gapbuf
Generic gap buffer
-
dectree-rs
A decision tree implementation in Rust
-
diskmap
disk based HashMap-like for shared concurrent memory usage
-
reql-types
Some useful types to use along with the reql crate
-
colours
Color types for different color models with conversions between it
-
voml-collection
Collections for VOML
-
bisetmap
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. The structure…
-
quadboard
Typed fixed-length buffers of chess pieces
-
tiny-test
tiny-testis collection of functions simplifying test assertions in rust -
vec-x
structure
VecXto manage fixed-length arrays, supporting numeric operations and assignment operations betweenVecXand scalar values -
sliding_window_alt
A structure that holds the last N items pushed to it
-
mipmap-1d
A small data structure to perform 1d-mipmapping (downsampling)
-
nimble-steps
Nimble Steps Collections
-
data_tree
Hierarchical data tree with pathing and search support
-
ostr
Owned str
-
nvpair-rs
Safe and rustic wrapper around nvpair
-
lazy-seq
constructing lazily evaluated sequences
-
mkargs
Build command arguments
-
poppy-filters
providing serializable Bloom filters implementations
-
indextreemap
A BTreeMap implementation that allows for key and or positional insertion and retreival
-
trie
An ordered map and set based on a trie
-
collect_result
collecting an iterator of results into a result of a collection
-
feature-set
User defined feature set
-
arbtree
A small library for general purpose tree data structures
-
rust_examples
rust 的学习中的一些例子
-
epoch-timestamp
Boilerplate collection for epoch timestamping
-
hdrhistogram
A port of HdrHistogram to Rust
-
rdf-reader
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
eureka-mmanager-core
The core package for the eureka-mmanager crate
-
isomorphism
2 directional hashmaps
-
boxing
cross-platform implementations for NaN and ptr boxes
-
lr_trie
Left-Right trie is trie capable of mapping any string to any string
-
changed
change detection
-
bengbenge
inifity array for round-robin dns, beng, beng
-
mc-oblivious-map
Oblivious Hash Map data structures on top of Oblivious RAM
-
cranelift-entity
Data structures using entity references as mapping keys
-
Xorfilter
No alloc membership approximation
-
subranges
manage non-interssecting integer intervals
-
amalgamator
A set/map like data structure that allows you to combine members together
-
windowed-futures
Helpers for windowed parallel execution of collections of futures
-
casbin-arangors-adapter
ArangoRs adapter for casbin-rs
-
structdb
Persistent data structures using RocksDB
-
processing_chain
set up processing chains of large amounts of data
-
augurs-core
Core data structures and traits for the augurs time series library
-
dynsequence
Sequence-Like data-structure for storing dynamically sized types
-
buffer-trigger
A data collection trigger based on the maximum number and refresh time
-
plurals
singular/plural forms, mostly in English
-
slas
Static Linear Algebra System
-
unsized-vec
Like Vec, but for unsized values
-
ord-collections
offering collections which are pre-sorted automatically
-
transient_map
Hashmap with eviction of unused elements
-
applejack
Radix tree
-
deltastruct
Allows defining deltas for tagged structs for later application
-
mivim
-
simple-sds-sbwt
A fork of simple-sds used in the sbwt crate
-
usage
A convenient alternative to the newtype pattern
-
good_lp
Mixed Integer Linear Programming for Rust, with an user-friendly API. This crate allows modeling LP problems, and lets you solve them with various solvers.
-
starbase-tools
A collection of tools created to help with ship building in the game Starbase by FrozenByte
-
qualomat_schema
Rust bindings for the *Qual-O-Mat* open data format for the german voting advice tool *Wahl-O-Mat*
-
type-freak
Collection of typed data structures, trait operators and aliases
-
optimistic_lock_coupling
A General Lock following paper 'Optimistic Lock Coupling: A Scalable and Efficient General-Purpose Synchronization Method'
-
prototty
Wrapper crate for frontend-independent prototty crates
-
read-copy-update
locking primitive
-
piece_table_rs
piece table data structure
-
syntastic
Generic abstract syntax representation
-
synthax
Synthesize syntax with quasiquoting plugins
-
dyn_vec
A Vec<T: ?Sized>
-
index-from-end
Allow indexing arrays and Vecs from the end using expressions like array[Len-1]
-
bitvec_simd
bitvec with SIMD
-
shortlist
An efficient data structure to track the largest items pushed to it
-
rotbl
Read Only Table
-
loki-logger
A loki logger for the log facade
-
l6t-symbolic
A part of l6t library: symbolic data model for different known devices
-
tree-flat
TreeFlat is the simplest way to build & traverse a pre-order Tree for Rust
-
dinvoke_data
Structures and data types definitions for dinvoke
-
bit-index
A little-endian zero-indexed bitstring representation
-
magiclist
List with O(log n) random access, insertion, splitting, and merging
-
short-lease-map
A map collection optimized for brief internship of values
-
anylist
a list type for any type
-
tree-sitter-sleigh
Tree-sitter parser for the Ghidra SLEIGH language
-
corresponding
Move corresponding fields between structs
-
designal
Procedural macro for use with futures-signals
-
inditech
A set of technical indicators for time series analysis
-
ic-stable-memory
Internet Computer's stable memory collections and tools
-
object-collection
A collection that can store multiple values of types
-
hash-rings
Implementations of various hash rings
-
vec-entries
Entry API for iterating over and removing elements from a
Vec -
funnel
data structure that makes it easy to read from multiple channels from a single source
-
opt_vec
A wrapper around Vec<Option<T> that makes deletion fast
-
hdf5-hl-sys
Bindings to HDF5 High Level API
-
libflow
grouping network flow data
-
collect-me
Additional collections not included in the Rust standard library
-
lim-bit-vec
Limited bit vectors
-
moka-cht
Lock-free resizeable concurrent hash table
-
pure-hfsm
A finite state machine library with a clear separation between the machine definition and its changing state
-
literally
Macro literals for members of std::collections
-
once-list2
A single linked list which is backed by
OnceCell. You can append the value to the non-mutableOnceList. -
puruda
Pure Rust DataFrame
-
eirproject/libeir_ir
Erlang ecosystem common IR
-
bosque
A very fast in-place kdtree library
-
typed_graph
Staticly typed graph library
-
yptoscr
writing yptoscr
-
cbsk_log_tokio
log tool, using tokio as the runtime
-
win-idispatch
that aims to provide a more ergonomic way of working with idispatch in winapi based projects
-
y-sync
Yrs synchronization protocol
-
awint_ext
Externally allocating
awintfunctionality -
mori_parallel
parallel orientation library built around commonly used orientation representations used in crystallography and engineering applications. It contains conversion, rotation, and data…
-
cset
Fine-grained and reversible struct transactions
-
nanoset-py
A memory-optimized wrapper for Python sets likely to be empty
-
union-find-rs
Disjoint-set forest implementation to support the union-find algorithm in Rust
-
pgdb_to_struct
CLI application to generate Rust struct files from PostgreSQL database tables
-
prometheus-tokio
A collection of tokio runtime metrics for prometheus consumption
-
lxc
Linux Containers API
-
datazoo
Bitset and jagged array data structures
-
fervid_core
The core structures and utilities of fervid
-
goya
morphological analyzer for Rust and WebAssembly
-
cliquers
Manage filesequences with a common numeric component
-
penumbra-sdk-asset
Core asset data structures for Penumbra
-
tangu-lints
A collection of lints for the Tangu language
-
rubbl_visdata
Preliminary work on generic data structures for radio interferometric visibility data
-
petal-clustering
A collection of clustering algorithms
-
generational_token_list
A doubly-linked list backed by generational-arena
-
kodiak-sets
manage generic sets supporting unique features
-
collectable
Fallible, no_std-friendly collection traits
-
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.
-
slab_tree
A vec-backed tree structure with tree-specific generational indexes
-
incremental-topo
Data structure to maintain an incremental topological ordering over a collection of values
-
smolvec
A lightweight vector implementation with small-vector optimization for rust
-
ypwt
ypwang's personal toolbox
-
exosphere-core
Core crate for Exosphere
-
helgoboss-midi
Interfaces, data structures and utilities for dealing with MIDI messages according to the MIDI 1.0 specification
-
rt-lists
Link lib
-
treemap
Squarified Treemap algorithm
-
ittybitty
An itty bitty bitset to hold your itty bitty bits
-
hj_ds
A data structure library for Rust
-
aph_disjoint_set
Disjoint set implementation with optimized memory usage and ability to detach elements
-
temporary-annex
Helper for creating temporary annex on a collection
-
empty_type
Tools to define and convert between types and their corresponding "maybe types"
-
construe
Compile-Time Growable Array: Vec & String for const!
-
openpgp-keylist
An OpenPGP Keylist data structure
-
two_three
A two-three (2-3) tree implementation in Rust. Includes a map and set interface
-
aterm
Annotated Terms data structure
-
aspiesolutions_core
core types used by many crates
-
hilbert_curve_generator
A WIP Hilbert Space-Filling Curve Coordinate Generator
-
chronoflake
Generate unique IDs based on the Snowflake algorithm
-
try-push
A trait for attempting potentially expensive actions
-
reunion
A generic implementation of the Union-Find w/ Rank data structure
-
reactive-signals
dx-first scope-based fine-grained reactive system
-
ref_kind
Different reference kinds
-
trying
Basic trie crate
-
sparse_set
sparse set data structure
-
foba
A test crate
-
nested_containment_list
A data structure for efficiently storing and querying nested intervals
-
hedge
An index based half-edge mesh implementation
-
expire
data structure for data maybe expired
-
sdsl
interface for the Succinct Data Structure Library
-
raii-map
Map and set types in Rust in which the presence of the entry in the data structure is tied to the lifetime of a RAII handle returned by the insertion
-
rtlp-lib
This create provide structures to parse PCI TLPs
-
rbtset
A set based on a RB-Tree for efficient operations
-
l6t-file
A part of l6t library: reading, writing and deconding for L6T IFF data
-
gumbel-top-bucket
A bucket data structure that is sampled using the Gambel-Top trick, which allows for O(1) sampling from a softmax-like distribution
-
semver-store
An HashMap structure that uses semver strings as keys
-
motivations
a collection of motivating messages
-
rand_map
A map that creates a random handle on insertion to use when retrieving
-
run-loop
Run loop for thread, provide message post, deadline timer and future executor
-
fenny
working with Fenwick trees
-
bubbletree
Bubble-tree
-
ljprs_async_pool
async-friendly pool data structure using tokio
-
bitarr
A fast and efficient Rust implementation of a BitSet, supporting multiple backing stores
-
small-ord-set
A set data-structure represented by a sorted
SmallVec -
jec
My collection of general-purpose crates
-
morton-index
Types and functions for efficiently and easily work with Morton indices
-
treez
A collection of useful data structures
-
char_index
efficient charwise indexing into a string
-
table
A specialized map for storing values of varying types
-
hashable-map
Wrappers for HashMap and HashSet that implement Hash
-
crdt-sample
containing samples of crdts
-
retworkx
A python graph library implemented in Rust
-
modular-bitfield-ordering
Provide u8be..u128be, u8le..u128le for modular-bitfield
-
ds-bst
Binary search tree implementation
-
rc-dlist-deque
Doubly-linked list based on std::Rc
-
xml2arrow
Efficiently convert XML data to Apache Arrow format for high-performance data processing
-
lanyard
UTF-8 C string types
-
tree_collections
A collection for tree data structures. It provides APIs that allows users to create memory efficient binary search trees, red-black trees and avl trees.
-
evento-query
A collection of libraries and tools that help you build DDD, CQRS, and event sourcing
-
pinus
A prickly BTreeMap. You can insert through shared references and values are pin-projected.
-
fallback
A helper library to implement fallback mechaism
-
bloomfilter-rust
A bloomfilter implementation in Rust
-
goodreads
deserializing a Goodreads library export
-
pages
A dynamically-sized heap-backed data page. Comprises a user-chosen header and data array packed into a single allocation.
-
foxy_types
Types for
foxy -
viral32111-xml
XML parser crate for my Rust projects
-
terrain-graph
Graph Library for Rust
-
errling
A collection of intrinsically useful errors
-
bit-vec-omnitool
A vector of bits
-
zotero
Communicate with Zotero API
-
codemap2
maintained fork of the codemap crate that contains 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…
-
leak
Safely leak data from owned data structures
-
milvus-sdk-rust
The official Milvus Rust SDK
-
sti
STd Improved
-
terees
a collection of tree-like data structures
-
orx-imp-vec
ImpVecstands for immutable push vector 👿, it is a data structure which allows appending elements with a shared reference -
counted_map
a hashmap that automatically assigns keys to pushed values
-
lru-slab
Pre-allocated storage with constant-time LRU tracking
-
hashable_weak
A hashable weak pointer
-
the_one
bst crate, created as a project for class
-
structo
Data structures made in Rust
-
diskdata
A catalog of on-disk data structures
-
vivalaakam_seattle_collection
Collection provider
-
isx
Traits for checking certain conditions of values
-
motivation
A collection of motivating messages
-
rs-arboretum
A study in trees
-
bookfile
A container file format with chapters and an index
-
nary_tree
A vec-backed tree structure with tree-specific generational indexes
-
fwdlist
A simply linked (forward) list
-
gfa-reader
Reading gfa format v1
-
latticequeries
Allows for fast hierarchical queries on Vecs
-
granite
Generic backing storage framework for building data structures
-
tinymap
A map structure that stores its data on the stack
-
lazyfunctions
A collections of functions for lazy people, or highly efficient programmers
-
variant-set
A set-like data structure for enum variants, allowing you to store at most one value for each variant of an enum
-
handy
providing handles and handlemaps
-
nsrb
Nifty Simple Ring Buffer (aka circular buffer) is a no_std library that provides 2 macros to easily create fixed circular buffer on the stack
-
omnitool
A curated respository of algorithms and data structures. The libraries are included as forks of Rust codebases
-
thin-string
A String with a smaller stack footprint
-
visit_diff
Efficiently finding differences between data structures
-
ware
middleware chains
-
whistlinoak
Annotated even-arity trees backed by mmaps
-
grove
A segment tree library enabling generic user-defined queries and actions on segments of your data
-
alloc-checked
Collections that don't panic on alloc failures
-
datastruct
A pure-data structure builder
-
protect
A protected data structure
-
array2ds
Package for handling sized 2d arrays in rust, without the usage of the keyword unsafe cuz why not
-
flatarray
Fast implementation of SeqEval, a sequence evaluation framework
-
rs-bush
Bush data structure
-
cds
Collection of Optimized Data Structures
-
pi_dirty
Record hierarchy dirty
-
rolling-set
A first in first out set that never grows above a certain size
-
crdt
Conflict-free Replicated Data Types for Rust
-
cosmic_undo_2
Undo and redo done the right-way
-
tree-sitter-traversal
Traversal of tree-sitter Trees and any arbitrary tree with a TreeCursor-like interface
-
another-option
option data type; useful when allocations are expensive
-
version-lp
a version struct library for use with version comparing, and wildcard resolving
-
scopegraphs-lib
A port of scopegraphs to Rust
-
dd_statechart
A Data-Driven implementation of Harel Statecharts designed for high-reliability systems
-
bitworks
meant to provide easy to use bitsets with emphasis on safety
-
phf_macros
Macros to generate types in the phf crate
-
simid
Universally Unique IDentifier (UUID)
-
doublets-decorators
Decorators for doublets
-
smallobjectpool
A small object pool for Rust
-
uwheel
Embeddable Aggregate Management System for Streams and Queries
-
tcgeneric
Generic data types used internally by TinyChain
-
wolf-derivation-graph
Adds support for memoizing data flow graphs to wolf-graph
-
tinyvecdeq
VecDeque-like data structures -
willowtree
Lazily evaluated trees
-
strawberry_fields
Consume, read, and mutate struct fields with an iterator-like api
-
binary_sort_tree
二叉树的new,insert,del,search等方法
-
contextual
deal with data in context
-
debruijn
Tools for DNA sequences: efficient k-mer manipulation, De Bruijn graph construction and compaction and handling of DNA strings
-
struct_mapping
Token StructMapping for testing StructMapping implementations
-
charcoal
Implements tree data structures and interfaces to work with them
-
app_properties
reading application properties from a file
-
undo_2
Undo and redo done the right-way
-
symbol-map
Memory-efficient mapping from values to integer identifiers (AKA a lexicon or symbol table), with options for fast bidirectional lookup
-
fxd
Fixed-point decimal implementation
-
ditto
CRDTs for common data structures like maps, sets, vecs, strings, and JSON
-
const-oid
Const-friendly implementation of the ISO/IEC Object Identifier (OID) standard as defined in ITU X.660, with support for BER/DER encoding/decoding as well as heapless no_std (i.e. embedded) support
-
anyid
ambiguous identifier
-
ro
stuff read-only
-
weak-self
WeakSelf is simple way to have a Weak pointer to yourself
-
chemrust-scanner
The core modules defining the flow and structs of data in computational chemistry routines
-
arrsingh-lists
A test crate to test publishing
-
serde_single_or_vec2
Type which can be deserialized from either a sequence or a single value
-
watermark
watermarking set for in-order insertions
-
rustupolis
tuple space data structure in Rust
-
soa-vec
Vec-like API over a struct of arrays layout
-
Project2
Implementations of red black tree and AVL tree
-
kubizone-common
Typed Rust structures for representing partially and fully qualified domain names
-
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)
-
atomic_swapping
An arbitrary type atomic storage with swap operations
-
non-empty-collections
Non-empty hash-map and hash-set implementations
-
wolf-graph-mermaid
Adds support for generating Mermaid diagrams from wolf-graph graphs
-
sbf
Spatial Bloom Filter, a probabilistic data structure that maps elements of a space to indexed disjoint subsets of that space
-
supply-chain-trust-example-crate-000044
The enum
Eitherwith variantsLeftandRightis a general purpose sum type with two cases -
list_tools
一个自己研发的Vec<T>
-
rpos
Cursor Manager on Table
-
bitval
For packing booleans in variables using bitwise operations
-
system-config
storing application properties on disk
-
async-func
providing macros to simplify the creation of asynchronous closures with external state captured by move. Useful for structuring asynchronous code with ease and clarity.
-
fuzzy_trie
Key-value collection to make fuzzy searches
-
cursed-collections
Collections that (seem to) break Rust safety
-
ucd-trie
A trie for storing Unicode codepoint sets and maps
-
astack
offers a Stack data structure with fixed capacity capable of fast LIFO operations
-
cueue
High performance SPSC circular byte buffer with batch operations
-
libpaprika
read and generate Paprika recipe files and recipe collections
-
string-wrapper
A possibly-stack-allocated string with generic bytes storage
-
bmap
A bitmap with an internal counter
-
kodiak-taxonomy
manage generic taxonomies supporting unique features
-
recursive_array
arrays using recrusive data structures to avoid limitations of the rust compiler
-
aabel-identifier-rs
defines identifier behavior, such comparing them, or generating sequences of identifiers
-
transit_model_relations
Modeling the relations between objects
-
tf2-types
a collection of types for tf2
-
bloomfx
Bloom filter implementation backed by fxhash
-
disjoint-collections
Disjoint-set data structures
-
packedvec
Store vectors of integers efficiently
-
kd_interval_tree
Implements a K-dimensional interval tree, for fast interval-overlap lookup. Binary-tree based implementation, i.e. O(log(n)) lookups.
-
nullvec
Rust nullable vector, which can contain null(missing) values as element
-
libkv
building data structures atop key-value stores
-
entry_put_ext
Map entry extension for put operations
-
rcbytes
Rc version bytes crate
-
icu-data
International Components for Unicode (ICU) data in Rust structures
-
mazer-data-structures
A minimal, simple math markup language that compiles to HTML, written in Rust
-
twitter/rustcommon-streamstats
Statistics calculated for a stream of samples
-
dmfr-dataset-reader
Reads transitland folder and outputs graph of valid feeds and operators
-
enum_vec
Efficiently store a vector of enum variants as a packed n-bit vec
-
chtholly
Tree, a data structure originated from CF896C
-
data_nostd
Structures and data types definitions for dinvoke_nostd
-
arraylist
wrapper built on top of rust vector implementation. Taste like Java Arraylist, and intuitive to use like Python list and JavaScript array.
-
sequence_trie
Trie-like data-structure for storing sequences of values
-
rblist
A block-based, non-circular double-linked list implementation for Rust
-
ensure
target state of an object
-
rimu-parse
A data structure template system
-
cnctd_smart_home
A collection of Smart Home APIs
-
f1d2d2f924e986ac86fdf7b36c94bcdf32beec15
Test for XSS on docs.rs
-
nereon
Riboseinc configuration library for Rust
-
geomprim2d
2D geometric primitive types
-
naq_domain
Domain library for nordic air quality (naq) that defines shared domain data structures
-
cad_import
importing CAD data from different formats into a uniform in-memory structure
-
deepmesa-collections
A collection of data structures and algorithms designed for performance
-
content-tree
An efficient data structure for compacted RLE data
-
gridd-euclid
euclid-compatible grid data structure (forked from Frosh_VII's gridd)
-
ads-rs
(Algorithms and Data Structures) is a set of useful generic production-ready algorithms and data structures
-
simple-ref-fn
function wrappers that do not require virtual tables
-
merkletree
Light merkle tree implementation with SPV support and dependency agnostic
-
blocklist
The project is based on blocklistproject. It provides perfect hash map/set structures for fast lookup of blocklisted items.
-
brownstone
building fixed-size arrays
-
restor
A dynamic resource storage system in rust
-
graph_process_manager_core
explore parts of a tree-like or graph-like structure that is not known in advance
-
tongrams
Tons of N-grams
-
blazemap
Implements a vector-based slab-like map with an interface similar to that of HashMap, and also provides tools for generating lightweight identifiers that can be type-safely used as keys for this map
-
into_enum
Rust macro to generate trivial From impls
-
simple_tables
An easy to use rust crate for creating table structures. Including macros for easily creating these table structures.
-
dynprops
Creating and extending objects with typed dynamic properties
-
honeycomb-render
Visualization tool for combinatorial maps
-
nolan
Commitlog/WAL Implmentation and Powerful Abstractions
-
scratchbuffer
A Vec<u8> like data-structure, that can be used as slices of different types
-
bit-vec_serde
A vector of bits
-
subset-map
A map where the keys are subsets of an initial set of elements
-
type-erased-table
A column-oriented based raw data storage
-
anat-rs
represent natural numbers as well-founded sets
-
graus-db
A high-performance, thread-safe key-value embedded data store
-
skootrs-model
module contains the various data structures used by the other Skootrs modules. This is also setup to make it easy to generate schemas from this code for the purposes of easily implementing…
-
pati
Image data structure and format for the Patica editor
-
non-empty-vec
NonEmptyvector implementation, ensure non-emptiness by construction -
pathlink
A URL type whose path can also be used as a filesystem path, for Rust
-
rocstr
An immutable fixed capacity stack based generic copy string
-
supply-chain-trust-example-crate-000085
tinyvecprovides 100% safe vec-like data structures -
supply-chain-trust-example-crate-000029
'Small vector' optimization: store up to a small number of items on the stack
-
okasaki
A collection of peristent datastructures
-
map-to-const
Easily convert HashMap<K, V> to constant [(K, V); N] values
-
genindex
Generational index library
-
abbrev-tree
highly inefficient data structure for text completion
-
generic-cursors
A generic way to mutably traverse acyclic recursive data structures
-
fusebox
Mostly safe and sound append-only collection of trait objects
-
moc
made to create and manipulate HEALPix Multi-Order Coverages maps (MOCs), see https://ivoa.net/documents/MOC/
-
simple_bitfield
Create bitfields with the same memory structure as integers using a simple macro
-
chunky-vec
A pin safe, append only vector never moves the backing store for an element
-
simple-observable
observable pointer for mutable and immutable data
-
awint_dag
DAG
awintfunctionality -
stdng
An enhancement for Rust standard library
-
stable_node_set
An ordered set with handles to values
-
byte_set
Efficient sets of bytes
-
hgg
Approximate nearest neighbor search collection
-
once-list
an append-only per-item list
-
leetcode_prelude
Some useful macros and definition for exercising in leetcode
-
static_merkel_tree
Static Merkel Tree is dedicated for generating Merkle Root and Merkle Proof for a static list of items
-
discrete_range_map
DiscreteRangeMap and DiscreteRangeSet, Data Structures for storing non-overlapping discrete intervals based off BTreeMap
-
field-ref
Field reference (like a member pointer to non-static data field in C++) for Rust
-
swap-queue
A lock-free thread-owned queue whereby tasks are taken by stealers in entirety via buffer swapping
-
identifier
Generate 128 bits id structs easily
-
k2_tree
A space-efficient representation of sparsely populated bit-matrices
-
ts_lib
A collection of functions I find useful for my projects
-
rust-fp-pfds
A Functional Programming Library in Rust, Purely Functional Data Structure
-
implhm
Simplified library of collision-handling HashMaps
-
typed_index_collection
Manage collection of objects
-
const_array_map
A const-capable Map type backed by a static array
-
embedded-async-helpers
staticfriendly helpers for async on embedded -
filetrack
persistent logrotated reading and other useful io things
-
nested
A memory efficient container for nested collections (like
Vec<String>orVec<Vec<T>>) -
partial_const
way to handle constant and non-constant values in a unified way
-
penumbra-sdk-keys
Key data structures and core utilities for Penumbra
-
dyn-slice
&dyn [Trait] implementation, inspired by a Reddit thread
-
advancedresearch-max_tree
maximizer library based on a maximum tree structure
-
contiguous_collections
collections backed by flat contiguous arrays
-
data_structure_traits
data structure collection traits
-
frozen-collections-core
logic for frozen collections
-
aoc-framework-utils
such as data types, algorithms and functions for aoc-framework-rs
-
ctxmap
A collection that can store references of different types and lifetimes
-
evillatoro-data-structures
Personal crate of me trying to implement data structures and algorithms in Rust
-
bitstruct
Better Bitfields
-
arrow-select
Selection kernels for arrow arrays
-
laizy
stable and thread-safe implementation of a lazy value
-
bst-rs
Recursive & Iterative Binary Search Tree Implementations within Rust
-
staticsort
Implements a macro providing a compile-time quicksort function for arrays of any length, containing any primitive Copy type with a PartialOrd implementation
-
char-list
A persistent string type with the same API as a linked-list of characters
-
sesstype
Multiparty Session Types
-
mashmap
A flat HashMap that supports multiple entries per key
-
styc
Typesystem definition SDK
-
ternary-tree-wasm
A simplified Wasm binding to ternary-tree crate
-
bigraph
Different representations with implemented operations on bigraphs
-
sparse-bin-mat
A sparse implementation of a binary matrix optimized for row operations
-
pl-hlist
support for heterogeneous lists (known as
HLists), which are functional, tuple-like, strongly-typed data structures that can contain elements of differing types -
arc-atomic
atomic pointer to an
Arc -
tree-index
Index a flat-tree
-
handler_map
Map from types to functions that receive them
-
anti-r
A spatial data structure outperforming r-trees for low numbers of elements
-
combinations
give you all the combinations of values in a vec
-
fenwick-tree
binary indexed tree (Fenwick tree) data structure in Rust
-
merkle-root
calculating the Merkle root of either a file, or walked directory
-
dendron
Generic tree data structure
-
standards
A collection of standards for international trade facilitation
-
elaru
Memory safe implementation of LRU cache
-
index_many
A proof of concept for indexing an slice at multiple locations at once
-
ord-by-set
providing a weakly ordered multi-set with compile-time configurable ordering scheme
-
dsalgo
A package for Datastructures and Algorithms
-
tbytes
A tiny library for reading and writing typed data into buffers
-
rangelist
A representation of sets as lists of inclusive ranges
-
petitset
An ordered set data structure, optimized for stack-allocated storage of a tiny number of elements with a fixed cap
-
json_tables
A structure that eases operations with a local json storage of undetermined items
-
big_enum_set
creating sets of enums with a large number of variants
-
num-bigint
Big integer implementation for Rust
-
vecset
A vector-based sorted map, set and keyed-set implementation
-
dlist
List data structure based on AVL tree. It can store elements which have dimension and quickly search for elements by distance from 0.
-
zot
Option-like enums for working with ordered collections of zero, one, or two items (
Zot), or ordered collections of one or two items (Ot) -
ahtable
Array Hash Table implementation
-
collidea
Collision-prone memory-efficient collections
-
fairqueue
Spatially distancing fair queue. A kind of queue for sequential round-robin processing.
-
byte-sequence
A little marco that creates structs to be used as byte sequences (for ApiKeys, SessionIds and so on)
-
grouper
generating links between items in a list
-
bstree
A Binary Search Tree written in Rust
-
eztd
Quick start Rust
-
index-map
A map with automatically generated usizes as keys
-
board
creating a single vector with coordinate based access, and a few nice functions for easy use
-
fixed_heap
A fixed-size heap structure with manually provided stateful comparison function
-
thincollections
Alternative implementations for vector, map and set that are faster/smaller for some use cases
-
bitf
procedural macro to easily create a bitfield out of a struct
-
yrs-kvstore
Generic persistence layer over Yrs documents
-
jagged_array
Owned
[[T]]-like 2D array where each row can differ in length -
const_std_vec
const std vec
-
list-any
Type erased slices and Vecs
-
b100m-filter
The fastest bloom filter in Rust. No accuracy compromises. Use any hasher.
-
courgette
Colour manipulation/conversion library
-
cess-sp-core
CESS Storage Proofs - Core parts for proofs of storage
-
parse_tree
A non-abstract syntax tree type
-
hkalbasi-rustc-ap-rustc_serialize
Automatically published version of the package
rustc_serializein the hkalbasi/rust repository from commit e77366b57b799dfa3ce1fcb850c068723a3213ee The publishing script for this crate lives at: https://github… -
graphstack
Graph-structured stack
-
map_split
providing simultaneous mutable access to disjoint portions values stored in a hash map
-
ransel
rank/select succinct data structures
-
cbsk_log_rayon
log tool, using tokio as the runtime
-
oxidd-test-utils
Test utilities for OxiDD
-
rust_fixed_width
that allows for easier manipulation of fixed width files allowing for the ability to name fields and such using specs
-
vec-strings
Store any string efficiently in an immutable way
-
arenas
Arena data structure for efficiently adding & removing items with stable IDs
-
bit-set-omnitool
A set of bits
-
priq
Array implementation of the min/max heap
-
artful
Low-memory overhead and high-performance adaptive radix tree
-
espalier
Very simple flattened tree structure
-
las
Reads and writes point clouds stored in the ASPRS las file format
-
advanced_collections
advanced data structures (collections). Includes counter (hash-bag, multiset), disjoint set (union-find, merge-find), circular buffer (cyclic buffer) and interval (range)
-
ranno
Annotations over recursive data structures
-
ndtensor
n-dimensional tensor library for Rust
-
prefix_dictionary
Data structure similar to a dictionary, but enabling search for prefixes
-
spectacle
Opt-in runtime introspection
-
predicates
boolean-valued predicate functions
-
eytzinger
implements the "eytzinger" (aka BFS) array layout
-
hyperbitbit
data structure
-
tracker-macros
Macros for the tracker crate
-
monitor-common
Basic data structure and algorithm of linux-monitor tool
-
flats
flattens nested structures into a flat single dimension map
-
vector-map
VecMap<K, V>: a Linear Search with Map API
-
sum-queue
Queue struct that keeps a fixed number of items by time, not capacity, and allows to get summarized stats of its content
-
multipeek
An adapter to peek at future elements in an iterator without advancing the iterator cursor
-
rustifact_extra
Extra features for Rustifact
-
rudac
common data structures and algorithms
-
treeflection
that provides reflection for tree structures
-
model
model-based testing for data structures, with linearizability checking
-
benchmark-counters
Light-weight data structures to help with monitoring and benchmarking
-
hash_ring
Consistent Hashing library for Rust
-
dpc-simplemap
map with default value and compacting
-
smart-string
A collection of string types and traits designed for enhanced string manipulation
-
raphy
A graph data structure library
-
map_err
map error values
-
rustupolis_server
using space tuples in fog computing
-
assoc
Treat vectors like associative arrays
-
bndpresbufq
Bounds-preserving, optionally limited, buffer queue
-
mismatch
abstract mismatching. Useful for error propagation.
-
varset
an any type set of items
-
mtgjson
Unofficially provided lightweight models of the data provided by MTGJSON
-
jui_file
file tool
-
advancedresearch-higher_order_point
An experimental higher order data structure for 3D points
-
context-mapper
Single rust macro for generating different maps
-
object-chain
Ad-hoc structure builder
-
linked-syntax-tree
A doubly-linked syntax tree
-
linked-vector
A hybrid linked list and vector data structure
-
break_array
For breaking array indexing
-
hv-alchemy
Heavy Alchemy - the black arts of transmutation, wrapped for your safe usage and enjoyment
-
fill_canvas
FillCanvas is a wrapper around a matrix with special methods to fill the cells
-
foliage
Abstract syntax tree for first-order logic with integer arithmetics
-
equivalence
Trait and derive macro for comparing and hashing types modulo an equivalence relation
-
binary-tree-view
A binary tree visualization application built in Rust
-
art
adaptive radix trie
-
mutable
keep track of changes in structures
-
fastrie
Sequentialised memory-packed associative tries, buildable at compile time, useful for longest prefix matching
-
ABtree
AVL and Btree for rust
-
tc-state
TinyChain's general state enum
-
paged
Read and create read-only paged database files
-
segment-map
A self-balancing binary search tree for mapping discrete, disjoint segments to values
-
anycollections
Rust Vec and HashMap which can contain arbitrary types
-
hashcons
Hash cons'ing for compact representations of shared, immutable data structures
-
lending-library
A key-value store that loans full ownership of items
-
ordered-vecmap
Ordered map and set based on vectors and binary search
-
fe_data
Data structures for FE
-
btreemultimap
A multimap implementation with range support
-
ultrametric_matrix_tools
Toolbox that provides functions and data structures to generate and handle ultrametric matrices
-
luka
working with graphs
-
batbox-approx
Approximate comparison
-
vec-dimension-shift
N-Dimension shift features for Vec<T>
-
adts
Common abstract data type traits and implementations
-
dyn_trie
Dynamic trie is trie capable of mapping any T to any string
-
bfield
B-field datastructure implementation in Rust
-
pinned_vec
Vec-like data structure whose elements never move
-
lockfree-cuckoohash
lockfree cuckoo hashmap
-
segmentmap
A collection that maintains insertion order
-
forged-in-lost-lands
Forged in Lost Lands is a simple game engine built in Rust that focuses on data control and ease of use
-
trie-alg
Trie implementation
-
type-pools
A data structure to store values of multiple types
-
rdf-writer
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
baggie
Container for storing mixed / heterogeneous values in a common structure
-
setting
The styles of all graphics elements
-
tree_by_path
A tree data structure featuring nodes addressable using a &Vec<usize> path and avoiding recursion and run-time borrow checking
-
vbox
type erased Box of trait object
-
swimmer
Thread-safe object pool type
-
exegraph
no_std execution graph library
-
treers
Sedgewick's tree maps
-
disjoint_set_forest
A disjoint set data structure implemented using a disjoint set forest
-
skippable_map
deserialize wrapper around HashMap which skips non-conforming data
-
binary-search
General binary search implementation
-
bucket_queue
A Bucket Queue data structure that can be used as a Priority Queue
-
ringbahn
an experimental safe API for io-uring
-
ccl_owning_ref
creating references that carry their owner with them
-
hexgridspiral
Hexagonal Cube-Coordinate System with Spiralling Integer Tile Identifiers
-
bstree-file-readonly
Query read-only binary-search tree file, supporting billions of entries in files of tens of GB
-
keylist
Elixir keyword list in Rust
-
microcrates-bytes
Types and traits for working with bytes (with no_std support by default)
-
ritelinked
HashMap-like containers that hold their key-value pairs in a user controllable order
-
ndcopy
Fast N-dimensional array memcpy
-
uset
set and a map designed for speed, with unsigned integers as keys
-
apint
Arbitrary precision integers library
-
causal-length
CRDT's based on causal length sets
-
rstructure
A thread-safe data structure library
-
data-query
Query library that allows for Querying Serializable data using string queries
-
portdiff
Data structure for fast local graph rewriting
-
tinystr-raw
Raw string-to-integer conversions for tinystr
-
sequencetree
a new type of collection to store keys and their corresponding values
-
simple_event_bus
A basic, simple event bus in Rust
-
mexset
Implementing a set with MEX support
-
graphlib_rust
Dagre's Graphlib implementation in Rust
-
old_norse_alphabet
Old Norse alphabet constants & sort for Rust
-
packed_array
Packed Array aka sparse set structure with compile-time known size
-
hash_table_datastruct
Adds a HashTable type, allowing to store values in a table with integer-indexed rows and hashable keys for columns
-
bin-tree
Building Binary Tree
-
blend-bindgen-rs
generated Blender's data structures
-
collectivity
Generic collection traits
-
qt-json
JSON library for QT
-
wolf-graph-dot
Adds support for generating Graphviz DOT files from wolf-graph graphs
-
array_stump
A data structure mixing dynamic array and sorted set semantics
-
jirachi
A collision resistant runtime agnostic key-generator
-
interval-map
A vector-based, non-duplicate range-keyed, sorted array
-
version-rs
A struct for Versions, with the methods you expect
-
cycle_cursor
Cyclic cursor implementation over generic iterators
-
varstack
A call-stack based singly-linked list
-
asdl
Parser for ASDL format. Describes the abstract syntax of compiler intermediate representations and other tree-like data structures
-
growable-bitmap
A growable (and shrinkable) compact boolean array
-
baz-tree-sitter-traversal
Traversal of tree-sitter Trees and any arbitrary tree with a TreeCursor-like interface
-
std_collection_traits
Abstraction of operations in std collection types
-
bittree
O(1) find functions in a special data structure called a bit tree
-
mycelium-bitfield
Structured bitfields, courtesy of Mycelium
-
nibble_vec
Vector data-structure for half-byte values
-
m6coll
Small Smart Collections using prefix m6
-
twodarray
A 2D array library
-
sbbf-rs-safe
Split block bloom filter implementation
-
kserd
Kurt's Self-Explanatory Rust Data
-
lockerroom
Readers-writer access to individual cells of your collection!
-
judy-wrap
Judy arrays FFI mid-level binding
-
fixedbitset-stack
A forked version of FixedBitSet that supports const generics
-
competitive-programming-lib
Competitive Programming Library
-
extensions
typemap container with FxHashMap
-
flag_set
FlagSet can process operations of the infinite complementary sets and the origin sets
-
hlist2
Compile-time heterogeneous list implementation
-
dag-cbor-references
Extract blake3 ipld links from dag-cbor blocks
-
mycelial-crdt
mycelial crdt
-
threshold-dict
A data structure to find smallest key that is larger than the query
-
sharedvec
A fast but limited collection for storing values of a single type
-
scopegraphs-prust-lib
fork of prust for scopegraphs
-
artsy
ART Tree data structure library
-
eclectic
Experimental collection traits
-
component_table
Data structure for associating data with entities in an Entity Component System
-
grid_trait
2D and 3D grids with combinators
-
intersection
Find the intersection over a collection of sets; when you need more than the intersection between two sets
-
dequemap
A no_std compatible implementation of the dequemap crate
-
pds
Probabilistic Data Structures efficiently implemented in Rust
-
roaring_bitmap
Roaring bitmap data structure implemented in Rust
-
schemes
cache-aware recursion schemes in rust
-
codas-macros
Macros for Codas
-
smallbigint
Big integer types that have a small on-stack representation for small values. Uses num-bigint internally.
-
rotbuf
Queue implementation wrapped around the
Bytescrates’ BytesMut data structure -
holium-rs-sdk
Holium Rust SDK
-
chtholly_tree
Rust bindings for Chtholly Tree
-
passive
A trio of marker traits to classify passive data structures
-
moretypes
Named tuples, records, and more!
-
id_sys
data structures which can be marked such that they only work with similarly marked integer data types
-
ramp_table
RampTable, a data structure useful for certain specialized situations
-
free-ranges
An efficient data structure for keeping track of indices which are either free or not
-
hirpdag
procedural macros for Hash Consed, Immutable, Reference Counted, Persistent, Directed Acyclic Graph data structures
-
gauze
Probabilistic set membership filters with a simple interface
-
unsized_enum
Unsized enum implementation
-
jsonnlp
JSON-NLP data structure
-
front-vec
Efficiently-prependable Vec and String types
-
id-pool
Create and recycle integer ids using a ranged pool
-
cpclib-tokens
cpclib libraries related to assembly tokens. Only structures are provided there. Intelligence is within cpclib-asm
-
datastreams-rs
DataStreams container
-
composite_types
Compose type definitions in the style of typescript
-
batbox-collection
Collection of identifiable objects
-
pinned-bucket
Mutable container for pinned and immutable items
-
hashbrown_tstd
port of Google's SwissTable hash map
-
priority-expiry-cache
A cache that evicts items based on their priority and expiry time (LRU + TTL) Add (O(1)), Get (O(1)), Evict (O(1)) in both time and space
-
range-traits
Ranges related traits
-
cartesian-tree
Construct a Cartesian Tree from a Slice in Linear Time
-
extract_map
A HashMap for memory efficent storage of value types which contain their own keys
-
tinysearch-cuckoofilter
Cuckoo Filter: Practically Better Than Bloom
-
bitsvec
A bit vector with the Rust standard library's portable SIMD API
-
map1
@ErichDonGubler's fancy template for new Rust projects
-
cola
A text CRDT for real-time collaborative editing
-
decoded-char
wrapper to keep track of the original byte length of a decoded character in the encoded source file
-
flat-veb
Fast implementation of vEB trees without internal allocation
-
better_peekable
Create a Peekable structure like Rust's Peekable except allowing for peeking n items ahead
-
disk-mpmc
on-disk mpmc
-
one_way_slot_map
SlotMap with minimal restrictions on Keys and Values
-
no_vec
modifying sized arrays
-
tournament-kway
k-way merge using a tournament tree
-
backtracking_iterator
generic iterator with an item history, capable of backtracking and forgetting
-
lineartree
tree data structure for rust
-
rstmt-core
focuses on building a music theory library that can be used to generate music theory data structures and algorithms
-
hexarr
working with hexagonal grids
-
go-heap-rs
Golang's heap written in Rust
-
btree-vec
A growable array (vector) implemented using a B-tree
-
slots
Fixed size data structure with constant-time operations
-
bsp-pathfinding
Runtime path finding using Binary Spatial Partitioning
-
arenavec
An arena backed implementation of vectors and related types
-
simple-matrix
generic matrix library
-
rt_vec
Runtime managed mutable borrowing from a vec
-
fix_float
Fixed floating types that allows useful trait implementations and datastructures on float numbers
-
cognitive-frames
Managing windows for
cognitive -
truncate-integer
Truncate integers
-
reusable-vec
A Vec wrapper that allows reusing contained values
-
hecs
A fast, minimal, and ergonomic entity-component-system library
-
simple-canvas
generic 2 dimensional canvas struct
-
valet
Stores your objects and gives you a tag to retrieve them later
-
typed_id
Make your IDs strongly typed!!
-
cumulfreqtable
A Cumulative Frequency Table implemented with a Binary Indexed Tree
-
treena
Tree stored in an arena
-
precedence-net
Create and analyse precedence networks
-
insert_multiple
insert multiple items into a stream in reasonable runtime
-
rimu-eval
A data structure template system
-
polystore
Polymorphic data store
-
bitint
Integer types that have a logical size measured in bits
-
hashmap-entry-ownable
Variation of HashMap::entry() that accepts borrowed forms of keys
-
hkalbasi-rustc-ap-rustc_data_structures
Automatically published version of the package
rustc_data_structuresin the hkalbasi/rust repository from commit e77366b57b799dfa3ce1fcb850c068723a3213ee The publishing script for this crate lives at: https://github… -
sexpr_parser
Generic S-Expression parser
-
offset
Glorified offsets for arbitrary structures
-
intsplit
splitting numeric types into their binary component arrays
-
kdt
k-dimensional tree implemented with const generics
-
building_blocks_mesh
Fast meshing algorithms for voxel data structures
-
flow_arena
A HashMap managed Graph Model with the concept of ownership
-
banyan
Persistent indexable tree data structure
-
strchunk
Data types for working with UTF-8 text in I/O
-
hopscotch
A FIFO queue for efficiently hopping and skipping between tagged items
-
mintaka-types
Mintaka Types
-
weight-cache
A cache that holds a limited number of key-value-pairs according to a user defined criterion
-
catalan
binary tree of n variables where the parent node represents a function and the child node represents a value
-
bpht
A bit-packed hash table implementation using hopscotch hashing for 32-bit keys and values
-
dynamic-matrix
work with matrices
-
unthbuf
Unsigned N-bit Buffer: A structure that holds a fixed buffer of
bits-sized unsigned integer elements -
bitmac
Structure for accessing to single bits
-
forgetful
Track and forget values within a specific scope, enabling detection of repeated values
-
push-while-ref
push while having a reference
-
debounce
Data structures and helpers for debouncing a stream of events: removing duplicate events occurring closely in time
-
hashtree
A Merkle Tree implementation in Rust
-
multi_key_map
a hash table that shares one value across multiple keys
-
automatic-relations
Tree automatic relations
-
soak
Transform a struct into arrays of its fields
-
nonoverlapping_interval_tree
Map data structure keyed on (non-overlapping) ranges that allows lookup of a point within a range. Can be no_std (with use of alloc crate).
-
arrsingh
A top level crate in the workspace
-
cloneless_cow
A greatly-reduced implementation of Cow that does not require T to be Clone but allows for storing either a reference or an owned instance for future needs of references to T
-
bytes-expand
Types and traits for working with bytes
-
dotreds-binary-heap-plus
Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps. Makes some previously internal function public
-
mind-tree
Organize your thoughts in a tree-like structure
-
iron_rose
Invertable Bloom Filters & Strata Estimators as found in https://www.ics.uci.edu/~eppstein/pubs/EppGooUye-SIGCOMM-11.pdf
-
enum-ref
Proc. macro for generating enum discriminant types.
-
url-hash
types that provide secure and stable hash values for Urls
-
colony
A fast associative data-structure that chooses its own keys
-
algae-rs
A collection of abstract algebraic structures implemented in Rust
-
fast-list
A doubly linked list using SlotMap for improved cache locality, and to solve the ABA problem
-
automap
pattern to implement key-value maps where the value type contains the key type
-
batbox-cli
cli interface
-
dot_tree
Create, query and store binary trees
-
typed_index
A strongly typed Index that know what it is indexing
-
secured_linked_list
A cryptographically secured and provable linked list
-
rust_list
Singly linked list in Rust, with macros for easy instantiation
-
solana_libra_canonical_serialization
Libra canonical serialization
-
more_ranges
Range types not provided in the standard library
-
siraph
A node-based digital signal processing crate
-
slotmap-map
Slotmap data structure
-
ckb_multi_index_map
MultiIndexMap: A generic multi index map inspired by boost multi index containers
-
common-tree
common tree lib
-
id-map
Data structure of values indexed by IDs
-
largeint
that supports large integer arithmetic
-
kaola
A Persistent Delayed Queue in Rust
-
p8n-types
Basic types for representing binary programs
-
arbitrary-int
Modern and lightweight implementation of u2, u3, u4, ..., u127
-
memcell
providing a MemoryCell struct, which stores a current and previous value
-
rarena
Lock-free allocator and data structures based on ARENA
-
key_set
KeySet representing concepts of All, None, Some(list), and AllExceptSome(list), with basic set calculations (intersection, difference, inverse)
-
circular_vec
A fixed length vector that provides a next function that loops infinitely
-
db_meta_derive
db-meta-derive is a wrapper around PostgresSOL using tokio-postgres
-
utf8char
that supplies a utf8 encoded char
-
projected-hash-map
projected HashMap over HashSet
-
negatable-set
Wrapper for sets that allows full boolean operations including negation
-
traitgraph
Abstracting over different graph representations
-
cbsk_unique
unique value generator
-
hyper-tree-router
Routing middleware for Hyper http library using Prefix tree (trie) for path finding
-
triskell
A tri-partite ring buffer
-
taskforge
Task management shared functions and structures for the taskforge family of tools
-
range-split
splitting sequences with range parameters
-
binartree
Binary Tree realisation
-
fsort
sort files in a fast, OS-independent and 'rusty' way
-
fplist
An immutable, persistent, singly-linked list
-
kukoo
lockfree cuckoo hashmap
-
densevec
Map like collection with usize indices that stores values contiguosly
-
dst-container
Containers for DST objects
-
bloom_filter_plus
rust_bloom_filter
-
array-init-cursor
help keep track of arrays of MaybeUninit
-
leetcode_for_rust
leetcode for rust
-
typemap_core
A no_std typemap with trait-based value-presence guarantees (on nightly)
-
aggregate-map
Collect key-values pairs into a mapping from keys to collections of values
-
simple-collection-macros
configurable macros for maps and sets
-
indexed_vec
IndexVecfromlibrustc_data_structures -
librualg
Collection of basic algorithms for everyday development
-
segmap
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. Originated as a fork of Jeff Parsons' "rangemap"
-
prefix_tree_map
generic prefix tree (trie) map with wildcard capture support
-
cmp_wrap
Let you compare structes by context
-
bugu
Cuckoo Filter: Practically Better Than Bloom
-
checked
Implements a wrapper over the primitive Rust types that better indicates overflow during arithmetic
-
stack-array
A data structure for storing and manipulating fixed number of elements of a specific type
-
ov
a collection of traits that allow you to chain off of anything
-
pasture-derive
Macro implementations for #[derive(PointType)]
-
spigal
fixed-length ring buffer implementation, intended to be no-frills and easy to use, especially for embedded applications
-
chunked-bytes
A rope-like non-contiguous buffer for efficient data structure serialization and vectored output
-
stringvec
macro for creating Vec<String> from various types
-
tree-graphviz
Generate GraphViz DOT directed trees, based on an arbitrary tree structure
-
collect-once-hashmap
A hashmap that can be collected only when there are unique keys in the iterator
-
zeen_filter
A fast and optimized Bloom Filter implementation in Rust
-
cbor-tag-index
Tag index
-
lazy-array
An array where entries are lazily initialized in any order
-
heapless_topo
no-std topological sort using
heapless -
crdt_rs
work with Conflict-free replicated data types (CRDT) in Rust
-
rdf-vocab
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
key-node-list
Doubly-linked list that stores key-node pairs
-
mapro
A tiny macro library for creating std::collections
-
cons-rs
containing a Cons data structure
-
higher-cat
Functors, Applicatives, Monads and other bad ideas
-
seg-tree
segment tree library
-
fixed-slice-deque
A fixed size deque implementation
-
wasmflow-interface
Types used by the Wasmflow tool chain
-
truetree
Trees in Rust
-
trait-map
Rust map for dynamic trait storage and references
-
vlsm-tree
Versioned Log Stream Merkle Tree
-
offset-views
Create and index offset views of arrays, slices, strings, etc
-
ensured_bufreader
A Bufreader ensures N bytes in buffer
-
frbf
robust, and efficient implementation of the Bloom Filter data structure in Rust
-
data-buffer
low-level data buffer type useful for IO and in homogeneous collections
-
flat_bit_set
有序、稀疏、节省空间的 bitset，适用于小数据量
-
to-offset
developer-friendly methods to manipulate strings with character indices
-
binary-data-schema
Meta language for raw binary serialization
-
vec_key_value_pair
A drop-in replacement for std::HashMap and std::HashSet that use Vec on the backend
-
blobary
place for blobs
-
twie
fast and compact prefix tries
-
bidirectional-map
A two-way map data structure for small keys and values
-
ppar
Persistent immutable array
-
u64_array_bigints
biginteger library based on u64 arrays
-
cdl-list-rs
A circular doubly linked list implementation using Rc<T> and RefCell<T>
-
fixedvec
A heapless version of the Rust vector type
-
id-set
A bitset implementation that stores data on the stack for small sizes
-
graff
manipulating graphs
-
xio_base_datatypes
XIO base data structures
-
fera
An aggregation of algorithms, data structures and supporting crates
-
hash-trie
Hash Array Mapped Trie (HAMT) Immutable Set Implementation
-
sized-vec
Type level sized vectors
-
owned_chunks
a collection of traits and iterators to get owned chunks from collections
-
lazy-cogs
Lazy Cogs is a implementation of lazy clonable data structures
-
fp-collections
An alternate collections library for rust
-
bitrush-index
A serializable bitmap index library able to index millions values/sec on a single thread
-
supply-chain-trust-example-crate-000097
generate and parse UUIDs
-
set-trie
A trie for fast subset and superset queries
-
calcit_fingertrees
(Calcit fork of )Immutable persisten
fingertrees -
tinyvec_string
tinyvec based string types
-
lookups
Improve the data retrieval operations for collections
-
indexmap-amortized
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…
-
onigiri
handling chars
-
inline-str
Efficent and immutable string type, backed by inline-array
-
dsu-tree
A non-invasive disjoint-set-like data structure implementation
-
linked_lists
Different types of linked lists
-
apid
Collection of type definitions from several APIs
-
fieldfilter
trait that lets you filter stuff!
-
outils
Graph and tree data structure library. Providing utilities which aren't easily available in Rust.
-
disjoint-hash-set
A disjoint set / union-find data structure suitable for incremental tracking of connected component identified by their hash
-
collect-mac
collect!macro, which can be used to easily construct arbitrary collections, includingVec,String, andHashMap. It also endeavours to construct the collection with a single allocation, where possible. -
wrapped_slab
WrappedSlab: Auto-generate newtype idiom based on a Slab
-
loro-preload
Loro internal lib for loading data
-
aligned-utils
Common utilities to work with aligned values and allocation
-
hedel-rs
A Hierarchical Doubly Linked List
-
aabb-quadtree
A quadtree that maps bounding-boxes to elements
-
dynamic-list
A powerful and efficient implementation of dynamic lists with versatile data structures, capable of storing any type!
-
streamhist
streaming histogram
-
solomondb
An embedded and distributed Gremlin-compatible graph database
-
dastral
Reduce boilerplate code, learn data structures & algorithms with Dastral
-
xtree
general purpose tree data structure
-
fusefilter
No alloc membership approximation
-
pretree
package for storing and querying routing rules with prefix tree. Pretree 是一个用于存储和查询路由规则的包。它用前缀树存储路由规则，支持包含变量的路由。
-
kermit-algos
Algorithms used in Kermit
-
sqlite-collections
Rust collection types backed by sqlite database files
-
copy-range
core::ops::Range et al, but Copy and IntoIterator
-
tree-cursor
non-intrusive tree cursor that supports node mutation without Cell/RefCell
-
biheap
A heap group that supports efficient removal of extreme elements
-
head
Common types with inline headers, such as HeaderVec for Vec
-
fricgan
performing basic input and output on bytes
-
read-write-pipe
A trait for objects implementing Write, to write all content from a Read object
-
lz_diet
An AVL balanced Discrete Interval Encoding Tree
-
dotwalk
Traits to traverse structures and generate DOT graphs
-
rust-bloomfilter
bloom filter implementation in Rust programming language
-
ttm-rs
CLI to turn tuples into adjacency matrices
-
arrav
Sentinel-based heapless vector
-
hat_trie
A hat-trie implementation that support prefix match iteration
-
prototty_storage
Interface to persistent storage
-
treelike
A trait to abstract over trees, and simplify implementing them, all in one handy crate
-
stable_bst
An ordered map and set based on a binary search tree. Works with stable Rust 1.9.0.
-
same_elements
Function to test if two collections contain the same values
-
prust_core
encoding/decoding PUS-C packet data structures with ease
-
nave
Thinking about the construction of distributed systems starting from the *consistent hash* algorithm
-
flat-multimap
A multimap and multiset implementation using a flattened hash table
-
fast_collections
noheap zero copy collections
-
header-slice
Definitions for slices with headers, and a vec-like type with a header allocated inline
-
lobby-queue
Const-size queue-like data structure
-
collection
Deterministic, copy-on-write balanced search trees
-
dfb
Dynamic-Fifo-Buffer, like AnyMap but uses a VecDeque to store values and treats access as a Fifo
-
packbytes
Convert structures to and from packed representavises - byte arrays of fixed size that live on stack
-
collect
An experimental extension of std::collections
-
ident
wrapping types with an immutable identifier and storing/accessing such types in collections
-
bonzai
An abstraction for optimizing the memory layout and pointer aliasing of trees
-
fast_trie_tree
A fast
TrieTreefor multiple data types -
grafite
Range Filter
-
ascii_num
digit to ascii numbers
-
tapestry
Generic 2D grid data structure and utilities
-
ttl-queue
A queue that drops its content after a given amount of time
-
hayami
general use symbol table
-
variant-map
defines maps to store variants of enums
-
triemap
Triemaps for Rust
-
len-trait
Len trait for collectons
-
pui-arena
Generalized Arenas that can be used on
no_std -
map_ext
Extensions to std::collections::HashMap and std::collections::BTreeMap
-
plain-map
map that uses small_vec as backing storage, which is useful for having many tiny maps. For storing non-Copy types please use v1.x which is also supported.
-
shifted_vec
A growable datastructure with positive and negative indexing built on top of
std::vec::Veccalculating the offset automatically -
lhlist
Labeled heterogeneous lists
-
bytes-quilt
data structure for tracking random-access writes to a buffer
-
vector2
2D vector library
-
gridd
A generic, dirt-simple, two-dimensional grid
-
suffix_trie
Suffix trie for searching
-
miniconf
Serialize/deserialize/access reflection for trees
-
sorbus
A tree manipulation library
-
pathtrie
A specialised trie for paths in the style of a Patricia or radix trie
-
graphlib
powerful rust library for the graph data-structure
-
simple_ringbuf
Ringbuf is a speedy lightweight fixed-size infinite-use collection optimized for straightforward single threaded use
-
trailer
Store a type with an associated buffer in contiguous memory
-
dense_bitset
A variably sized, heap allocated, dense bitset implemented using no
unsafecode -
flat-zip
An iterator adaptor to help traverse two-level collections
-
bloomy
Bloom filter using only two hash functions
-
htmldom_read
HTML reader that parses the code into easy-use tree
-
qt-json-rs
JSON library for QT
-
include-lua
that allows the embedding of a lua source tree into a Rust application binary
-
slotgraph
Graph implementation built with slotmap and petgraph
-
bounded-vec-deque
A double-ended queue|ringbuffer with an upper bound on its length
-
serde-ordered-collections
Ordered serialization/deserialization serde functionality
-
vortex-alp
Vortex ALP array
-
atlas-rb-tree
A textbook implementation of a Red-Black Tree
-
compressed_map
'Static functions': compressed maps with the keys removed
-
dot_json
Tools for dot map representations of serde_json Maps
-
upto
Fixed-capacity and variable length stack allocated arrays
-
discord-indexmap
A fork of the popular
indexmaplibrary that adds a few extra APIs that are yet to be upstreamed -
woodland
Easy to use implementations of popular tree data structures such as Binary, Binary Search, AVL, Red-Black, and more
-
rimu
A data structure template system
-
sets_multisets
API for working with sets and multisets of elements of type usize
-
mvbitfield
Generates types to work with bit-aligned fields
-
suggestion_trie
A Radix trie for suggestion search, it allows to search for data indexed by a set of keywords fast
-
bitsetium
One stop shop for all bitset needs
-
vector-trees
Vector backed B and AVL trees
-
bet
parsing and evaluating binary expression trees
-
prioq
Priority Queue implemented using std::collections::BinaryHeap
-
tranche
Tranches are an alternative to slices
-
rc-slice2
Reference-counted slices with easy subdivision
-
fixed-index-vec
A vector-like data structure whose indices do not change when elements are removed
-
gsrs
Generic Self Referencing Struct
-
pi_phf_map
phf_map
-
workit
single-threaded work queueing utility
-
unrolled-linked-list
unrolled linked list in rust
-
fremkit
broadcast log
-
hodgepodge
enums
-
dst
Data structures for DSTs
-
cyclic_data_types
Cyclic data types are series of structs, enums, types and functions to create a series of fast data types
-
delete_if_not
unsafely in-place delete function
-
deqmap
A double-ended queue with optional keys
-
skew-forest
Skew-binary random access lists
-
pointer_vec
The PointerVec works same as the std Vec structure except the Vec has a size of 3 usize (pointer, length, capacity). This crate provides a replacement that has a size of 1 pointer.
-
rope_rd
A Read/Seek rope implementation
-
shelves
Storing values referenced by a unique typed index
-
easy_strings
Ergonomic, garbage collected strings for Rust
-
batbox-android
Helper crate for android
-
domain-lookup-tree
A tree structure in Rust optimized for looking up domain names, with wildcard support
-
partial-array
potentially partially-filled arrays
-
static_map
A static hashmap implementation, based on the Round-Robin hashing algorithm found in rustc
-
contigious-tree
Write and read tree graphs to and from contigious blocks of memory
-
asyncapi
aims to provide data structures that represent the AsyncAPI specification easily deserializable with serde
-
cursieve
that makes it easy to deserialize byte arrays into annotated Rust structures
-
stride
A strided slice type
-
lazy_concat
Lazy concatenation for Strings and Vecs
-
autocomplete
Auto-complete feature using Trie data structure
-
enum-set
A structure for holding a set of enum variants
-
graphia
graph data structure
-
bloom_filter_plush
rust_bloom_filter
-
box-collections
A no_std compatible implementation of the collection crate
-
erased-type-arena
A type-erased allocation arena with proper dropping
-
prefix_sum
prefix sum data structure
-
dgrambuf
A fixed capacity ring buffer for datagrams (byte slices)
-
fast_forward
Quering collections blazing fast
-
collection_macros
Collection of macros for collections
-
rbtree-arena
A cache friendly red black tree where nodes live on sequential memory
-
nexum
collection of commonly used data structures
-
simple-octree
octree implementation written in Rust
-
runtime-sized-array
A variable-length array, also called runtime-sized
-
bfilters
bloom filter implementation in Rust
-
bytes_to_type
facilitate byte conversion to specified types using macro generation
-
higher_order_point
An experimental higher order data structure for 3D points
-
batbox-range
Helpers for working with ranges
-
unsized-stack
Fast heterogeneous / unsized stack
-
empty-collections
Correct-by-construction empty collections
-
my-stack
stack implementation in Rust
-
b_trees
Implementations for various binary trees including AVL tree
-
tagged-tree
A tree-like data structure where the values are tagged
-
hamt-rs
A Hash Array Mapped Trie implementation based on the *Ideal Hash Trees* paper by Phil Bagwell
-
rdf-query
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
btreelist
A list data structure that has efficient insertion and removal in the middle
-
jmt-blake3
Jellyfish Merkle Tree based on BLAKE3 hash function
-
weakheap
Weak Heap data structure implementation in Rust
-
btree_monstousity
a code port of BTreeMap but with comparator functions
-
sortedcontainers
An experimental sorted data structure
-
vhr_serde
A serde (de)serializer crate for the simplist possible binary format
-
ropey
A fast and robust text rope for Rust
-
repc
APIs to calculate the layout of C types
-
priority-set
A no_std Priority Set
-
mmap_json_file
parse, count, filter JSON files using memory mapped io library
-
mqf
MQF, Mixed Quotient Filter, is a variant of CQF (Counting Quotient Filter)
-
bytes
Types and traits for working with bytes
-
rs-bucket-filter
Skips slow scans using cache, bloom filter,
-
seq
The module 'seq' provides the lightweight, generic sequence container 'Seq' for unmovable data and is embedded into the program during compile time
-
arraylike
trait for using arrays without needing const expressions
-
neighborgrid
A 2-D grid datastructure with easy to use iterators and adjacent cell methods
-
shared-string
Split a string without another allocation
-
generic-arrayvec
Interop between the arrayvec and generic_array crates
-
btree_network
A generic network (undirected graph) data structure
-
reservoir-buf
Dead simple interning
-
any_handle
A thread-safe, type-safe smart pointer that can share, store and downcast a
dyn Any -
fibheap
but actually useful Fibonacci Heaps
-
transit_model_collection
Manage collection of objects
-
store-interval-tree
A balanced unbounded interval-tree in Rust with associated values in the nodes
-
stacking
using a stack datastructure in rust
-
compact-map
'Small map' optimization: store up to a small number of key-value pairs on the stack
-
routee-compass-core
The core routing algorithms and data structures of the RouteE-Compass energy-aware routing engine
-
sbf-blake3
Spatial Bloom Filter, a probabilistic data structure that maps elements of a space to indexed disjoint subsets of that space
-
multi-stash
Vector-based arena data structure that reuses vacant slots
-
dynamization
Fast insertion for static containers
-
lilbits
Super fast u8 set (ie bitmap) relying on the assumption that elements are <= 63
-
dark-std
asynchronous containers build on tokio. It uses a read-write separation design borrowed from Golang
-
udgraph
Universal dependency graphs
-
linked_list_c
Safely work with c compatible linked lists
-
avl-cont
A contiguous AVL Tree
-
densemap
A collection data structure that is permanently accessible by unique keys and fast iterable
-
dyobj
improved version of the ECS pattern
-
freezie
small library that disables mutation for the contained type
-
pokeapi-model
Data structures for PokéAPI v2
-
flowerbloom
fast bloom filter implementation with thorough documentation and tests
-
bloom
Fast Bloom Filter and Counting Bloom Filter implementation
-
erasable
Type-erased thin pointers
-
nimrodshn-btree
A persistent copy-on-write B+Tree implementation, designed as an index for a key-value store, inspired by SQLite
-
vec-2-10-10-10
A 32-bit vector, where 2 bits are dedicated for alpha, and 30 bits are dedicated for color. Compatible with GL_UNSIGNED_INT_2_10_10_10_REV vertex attribute format.
-
aabel-bloom-rs
implements the Bloom filter
-
tadm
A collection of algorithms and data structures wrote out while reading The Algorithm Design Manual book
-
tsil_cev
LinkedList on Vec
-
indexmap-rmw
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…
-
dashmap-shard
port of Google's SwissTable hash map
-
deferred_vector
A deferred vector implementation
-
tree-automata
Term Rewriting Systems
-
street_index
small utility crate for working with road name / street indexing for cartographic purposes
-
simple-bitrange
manipulating bit ranges which is common when working with IC registers
-
hitree
Indexable containers for Rust: HiSet and HiMap
-
extended-collections
An extension to the collections in the standard library with various data structures
-
closures
Abstraction for seperating code and state in closures
-
comprehend
Python like list, set and hashmap comprehensions via macros
-
bytesstr
An immutable reference-counted UTF8 String
-
an-rope
an rope for large text documents
-
pegitan
A bunch of random algorithms library
-
last-git-commit
wrapper arround git2-rs to get info about the last commit. Useful for when you want to show the git hash in a program.
-
clampf
Clamped floating-point types
-
enum_from_variant
macro to generate From<T> trait implementations for enum variants, simplifying error conversions and enum mapping
-
pq-bincode
A wrapper crate of queue-file for bincode serializable structs
-
rose_tree
An indexable tree data structure with a variable and unbounded number of branches per node. It is Implemented on top of petgraph's Graph data structure and attempts to follow similar conventions where suitable.
-
wheelbuf
wheelbuffer crate offers a ringbuffer-like structure without a read pointer, making multiple reads of a buffer possible. The store behind the buffer is flexible and can be a static array…
-
ra-ap-rustc_graphviz
Automatically published version of the package
rustc_graphvizin the rust-lang/rust repository from commit 5113ed28ea1451a13eae3a05dca0dbabfd56f587 The publishing script for this crate lives at:… -
json-node
A way to work with JSON as a node tree
-
yagraphc
working with Graph data structures and common algorithms on top of it
-
kermit-ds
Data structures used in Kermit
-
ego-binary-tree
Binary tree API built by wrapping ego-tree
-
sorting-vec
Sorts a vector using a btreemap
-
stack-stack
stack-allocated stack
-
slotmapd
orlp/slotmap fork where serialization cycle doesn't change observable behavior
-
atom_table
Assign easy-to-handle typed IDs to large, hard to handle things like strings
-
map-trait
Generic Map trait
-
const-vec
Vec-like data structure with immutable push method
-
murmurhash64
MurmurHash2 (64bit version)
-
local_vec
fixed-capacity vector allocated on the stack
-
rustgym
solutions
-
prust-lib
Persistent & Immutable Data Structures in Rust
-
bit-long-vec
Vector with fixed bit sized values stored in long
-
fallacy-hash
fallible hash collections
-
inspector
General purpose inspection for popular data structures
-
final
Wrap a value in a type that does not give out mutable references
-
mucell
A cell with the ability to mutate the value through an immutable reference when safe
-
flat_enum
Expand nested enum into flattened enum
-
dimension_shiftable_buffer
A dimension shiftable buffer
-
queueue
Queue-like data structures used in rCore
-
hashed
type you can convert any hashable type into and still do equality checks on
-
lightning-containers
A set of lock-free data structures
-
retrace
Safe, generic rollback log with predictable latency
-
tierkreis-core
Core implementation for the tierkreis quantum-classical hybrid workflow orchestration tool
-
hashable_rc
Hashable wrappers for reference countings
-
data_structures_SD
collection of data structures. In other words a collection of ways to handle your data in your code and/or program.
-
btree_dag
A generic DAG (undirected graph) data structure
-
hashmap_union
Allows the union and intersection of hashmaps
-
eitherq
Queue which support two different types
-
sixarm_collections
Collections for HashMapToSet and BTreeMapToSet as trait extensions. By SixArm.com.
-
unrecurse
Helper crate for rewriting your recursive code in iterative way
-
bucket
Offers a very simple container for any value without mutation
-
prefix-tree
A map and set interfaces using trie data structure
-
rimu-ast
A data structure template system
-
leonardo-heap
Heap structure supporting fast in-place partial sorting
-
nom-midi
Parse a simple midi file into data structures using nom
-
sliced
A segmented vector for iterating over slices
-
queue-rs
queue
-
oxc_index
Newtype-style helpers for
Vecandusize -
another_radix_trie
Rust built radix tree library
-
simple_trie
array backed trie
-
tapa-trait-serde
A collection of Tapalogi's reusable crates
-
terms
Tree terms and patterns data structures
-
quickphf
Runtime code for static data structures based on the PTHash perfect hash function
-
tdb-succinct
succinct data structures used by terminusdb
-
containerof
Macros and traits facilitating the use of intrusive structures in Rust
-
trashmap
A HashMap and HashSet that operate directly on hashes instead of keys, avoiding rehashing
-
banyan-utils
work with banyan trees
-
get-many-mut
Stable polyfill for slice::get_many_mut
-
fcsd
Front-coding string dictionary
-
explicit-discriminant
Macro for enforcing enum discriminants
-
gentrix
that adds the Matrix typed using generics that is basically a wrapper around a 2D Vector
-
ommui_data
OMMUI data structures
-
alo
ALO means At Least One. It could contain any number of item like
Vecbut it does not heap allocation if it contains only one item -
im_interval_tree
An immutable data structure for storing and querying a collection of intervals
-
gavl
A fast implementation for a map and a set using an AVL tree
-
bufferring
Ring buffers for Rust
-
bitstr
contiguous sequence of bits in memory
-
pair_macro
Create types consisting of the same type values such that Pair, Triplet, and so on
-
gtrie
Generic trie implementation with a support of different key and value types
-
ngds
Rust bindings for AVFounation
-
altdeque
An alternative deque implementation
-
querable
Quer(y)able data structure implementation
-
flex-algo
Rust commonly used data structure and algorithms
-
arith
containers with arithmetics
-
persistent_rope
An immutable persistent rope data structure
-
st_ring_buffer
A fixed-size String implementation using a ring buffer
-
pi_slotmap_tree
A tree structure implemented by dense memory linked list
-
single_byte_hashmap
HashMap for storing singular bytes as keys
-
froggy
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
-
indexed_bitvec
An indexed bitvector with (hopefully) fast rank and select operations
-
sortedlist-rs
A fast sorted list data structure in rust
-
stl-rs
STL like features in idiomatic rust
-
noindexmap
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…
-
fastgraph
Graph abstraction providing a generic interface and powerful parallelized traversals
-
hkalbasi-rustc-ap-rustc_graphviz
Automatically published version of the package
rustc_graphvizin the hkalbasi/rust repository from commit e77366b57b799dfa3ce1fcb850c068723a3213ee The publishing script for this crate lives at: https://github… -
hubs
The horribly unsafe buffer structure
-
anymap3
A safe and convenient store for one value of each type
-
trips
generic triple store written in Rust
-
bitaccess
Macro for efficient and type-checked access to individual bits of a variable
-
string-err
String error type
-
tyght-map
A static type map implementation
-
tampon
Contains SAFE Rust functions, macro and trait to serialize / deserialize data structure and/or object and generate buffer
-
cli_tree
A CLI tool to generate a tree of user defined nodes
-
to_any
Auto derive ToAny trait for any structure
-
moonlight_collections
Collections for Rust
-
sac
A macro for constructing collections
-
smallbytes
= SmallVec + impl BufMut (from the bytes crate)
-
dirty
Holds a value with a dirty flag which is set on writes and cleared on clear()
-
pathtree
An immutable tree data structure for fast path operations
-
uniqueid
Generates a unique hash/identifier for a system given a set of parameters
-
dynamic_graph
graph processing
-
svec
Dart-style list in Rust
-
tag-vec
A vector used for storing tags
-
compactmap
Compact Vec-based map that choses assigns IDs for your values on it's own. Very similar to Slab.
-
boxed_array_ringbuffer
A ring buffer of fixed size, that uses a boxed array as storage, therefore avoiding re-allocations when converting from Vec or to VecDeque
-
digger
A trait for extracting data from recursive data structures
-
staticbitset
A container like std::collections::BitSet but static storage + Copy trait
-
fixed-queue
no_std, no_alloc, use [T; N]. support
Vec/VecDeque/History -
rdf_rs
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
bipbuffer
Simon Cooke's Bip-Buffer
-
batching-queue
An Israeli Queue implementation
-
grafana-dashboard
grafana import/export data serializable structures
-
doubly-linked-list
double link list
-
treesome
tree creation, manipulation, traversal and visualization
-
mut-binary-heap
Enhanced version of std::collections::BinaryHeap that supports increase and decrease key, max, min, and custom-order heaps
-
simple-stack
linked list-based implementation of the Stack data type
-
splay
native implementation of a Splay Tree for Rust. Splay Trees are self-balancing binary search trees which adapt dynamically to lookups over time to allow common access patterns to frequently have better than log(n)…
-
golomb-set
A Golomb Coded Set implementation
-
provenance
Container structures that generate key upon insertion that only works with the map that generated it
-
miniqueue
A minimalistic single-thread job queue based on fold/reduce
-
many-to-many
creating many-to-many data structures with the ability to query either side, useful for applications such as pubsub. Like a fusion between
bimapandmultimap. -
default-vec
A specialized vector that has a default value
-
dependency-graph
building and resolving dependency graphs
-
recasting
traits for one-to-one recasting of values in data structures
-
know_yaml
The Know Framework for Rust
-
algotrees
VERY early stage project to implement a library of algorithms and data structures in Rust. It has very little features and only supports one data structure (binary trees) at the moment…
-
id-vec
Simplify Graphs in Rust. Introduces IdVec, which automatically creates Ids for each new object, reusing deleted Ids.
-
algo
Algorithms & Data Structure implementations
-
static-bytes
Bytes for embedded devices
-
compressed-sparse-fiber
Compressed sparse fiber implementation for Rust
-
crdt-list
Abstract CRDTs for lists
-
pinned-queue
Queue-like data structure whose elements can never move
-
locale-decoder
Parser and data structure for dealing with locale strings
-
stackvector
StackVec: vector-like facade for stack-allocated arrays
-
init_trait
A small helper trait to simplify the initialisation of 'indexable' data structures
-
bigsi_rs
A in-memory implementation of a BIGSI-like data structure
-
ax_banyan
Persistent indexable tree data structure
-
winvec
Windowed Vector (TTL) Collection for Rust
-
external_set
A set with externally-owned items, designed for managing subscribers, clients, listeners, or observers across threads. Inserting an item returns an ItemOwner that removes the item when dropped.
-
gvec
Very simple implementation of generational indexing for vectors written in Rust
-
iostream
the project is rust io stream.you can easily use it to manipulate files stream and memory stream
-
dogged
Persistent vector, similar to Clojure
-
mitsein
Strongly typed APIs for non-empty collections, slices, and iterators
-
option_vec
Vec<Option<T>>-like container
-
vortex-datetime-dtype
Vortex datetime extension dtype
-
qlrumap
A HashMap with an LRU feature
-
map-of-indexes
A compact key-value map for unique but not dense indexes
-
const-arrayvec
A vec-like type backed by an array on the stack
-
pulz-bitset
bitset implementation
-
compacts
compact data structures
-
cacaos
Core library for CACAO traits and data structures
-
mini-linked-list
A package containing a minimal i32 LinkedList implementation
-
c_linked_list
handling NULL-terminated C linked lists
-
trie-generic
A trie with generic content
-
serde_fs
[De]serializing data structures as files
-
event-queue
crates.io için bir paket nasıl hazırlanırın ele alındığı öğrenme amaçlı modüldür
-
unempty
Non-empty data structures for Rust
-
bitmaptrie
Bitmapped vector trie (mutable, not persistent). Word-size path-cached indexing into essentially a sparse vector. Requires rust-nightly.
-
flexible-string
A stack heap flexible string designed to improve performance
-
one-stack-vec
OneStackVec could contain any number of item like
Vec, and it does heap allocation only when it contains more than one item -
traitgraph-algo
Graph algorithms based on the traitgraph crate
-
tree-experiments
Experiments with tree-like data structures
-
linked_lista
LinkedList data structure
-
stacked_type_map
Compile time map of any type
-
batbox-cmp
Traits & functions related to Ord
-
lineup_rust
queue implementation in Rust. This is a learning and a hobby project and is not intended for production use.
-
guzzle
A derivable trait for consuming key value pairs into structs
-
smol_str
small-string optimized string type with O(1) clone
-
hamt
Purely functional hash array mapped tries
-
small_vec2
Vector on the stack or heap need nightly rustc
-
sortbuf
Data structure for sorting large numbers of items
-
indexvec
Simplified copy of rustc's index crate
-
calf-vec
Small copy-on-write arrays, essentially combining
SmallVecandCow -
pointer-value-pair
A pair of a pointer and a small integer packed into a pointer-sized object
-
kermit-iters
Iterators used in Kermit
-
transiter
An Iterator suitable for navigating recursive structures and DAGs
-
rimu-meta
A data structure template system
-
trie_map
A trie with good iterator support backed by a hashmap
-
maybe-cell
An UnsafeCell optionally containing a value, with the state externally managed
-
vortex-dict
Vortex dictionary array
-
plum
Probabilistic data structures for rust
-
gap_query_interval_tree
that provides a gap-query optimized interval-tree data-structure
-
indexed-bitfield
An indexed bitfield, to track presence or absence of up to 128 elements
-
power_map
A map with finite key and fixed size
-
nopetgraph
Graph data structure library. Provides graph types and graph algorithms.
-
toboggan-kv
abstraction layer over multiple KV stores
-
sorted-list
SortedList data structure which allows mapping an Ord key to multiple distinct PartialEq values
-
nanobox
NanoBoxoptimization: store small item on stack and fallback to heap for large item -
graphrepresentations
providing efficient abstract implementations of different graph representations
-
tindex
Vec, slice and bitset with custom index types -
binary_tree_zy
binary tree
-
traitgraph-tsplib-io
Functions to read and write graphs in TSPLIB format
-
rankmap
rust hash table supporting key ranking
-
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
trait-based-collection
A trait-based collection library that implement different data structures using the same trait
-
raw-vec
A Raw utility for managing contiguous heap allocations
-
phf_mac
Compiler plugin for perfect hash function data structures
-
containers-rs
'Collections' interfaces for describing objects that contain other objects
-
sequence_buffer
Sequence buffer data structure implementation
-
blfilter
Bloom filter implementation using farmhash
-
shared_bytes
Owned string and byte slices
-
inexor-rgf-model-binary
Inexor - Reactive Graph Flow - Model - Binary
-
functional_vec
Owning versions of mutable Vec methods
-
branchless
Algorithms and data structures designed to maximize performance on superscalar processors
-
tree-rizzen-yazston
Tree Library using the Any trait for data
-
byte_trie
A compressed trie based on bytes with some weird child node bucket sizes
-
twilio-data
Twilio API data structures
-
priority-matrix
A matrix that supports per-row, per-column and whole-matrix maximum key queries
-
any_key
Dynamically typed keys for associative arrays
-
pq-tree
consecutive ones property (C1P) and graph planarity testing
-
immutable-map
An immutable ordered map and set based on weight-balanced tree
-
static-box
A stack-allocated box that stores trait objects
-
const-buffer
A fixed-capacity memory buffer allocated on the stack using const generics
-
generic-json
Generic JSON traits
-
littlechestnutgames-trie
A generalized trie implementation for quick prefix searching
-
flashtext
algorithm to search and replace keywords in given text
-
lupine
A bloom filter using FX Hash with Kirsch and Mitzenmacher optimization
-
tree_multiset
A tree-based multiset for Rust
-
enumap
A HashMap and HashSet like interface for enums backed by an array
-
yuuang_petgraph
Graph data structure library. Provides graph types and graph algorithms.
-
bitsets
BitSet implementations: Dense, Compressed, Memory-Mapped, and Roaring
-
mrslac
sparse matrix data structures
-
dimsum
multi-dimensional array library
-
faex
A fast and efficient Compact Data Structures Library
-
dynvec
DynVectype that acts like a vector to store any datatype -
tuco-core
Contains the Tuco trait, used by the Tuco crate
-
valued
Describe your data in terms of basic data structures. Get serialization and other facilities for free
-
capillary
HashMap-like storage of key-value pairs, but allowing for step-by-step (partial) search of value
-
indexed-vector
that implements vector container that can be indexed with specified function
-
intrusive-containers
intrusive data structures
-
sif-rtree
immutable, flat R-tree
-
stringz
A way to use strings in generic paramters
-
safer-bytes
safe, non-panicking wrappers around the 'bytes' crate
-
butils
shared by software included in BSuccinct
-
rdf-borsh
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
vortex-zigzag
Vortex zig zag array
-
pi_async_graph
async graph
-
packed_str
Store immutable strings in a single packed allocation
-
ring_queue
A double-ended queue implemented using a vector that reuses space after elements are removed
-
clouseau
A query language for inspecting Rust data structures at runtime
-
array-ops
Automatic method implementations for array data types
-
tibitset
bitset replacement for HashSet
-
aximate
core data structures and utilities
-
slice-deque
A double-ended queue that Deref's into a slice
-
history-buffer
A fixed capacity, write-only, ring buffer
-
array-linked-list
A data structure, which combines the advantages of dynamic arrays and linked lists
-
vector_mapp
A Vec based map
-
sparse-slot
minimal sparse slot (sparse vector)
-
blocked-vec
A vector of byte blocks behaving like files
-
kvstructs
General basic key-value structs for Key-Value based storages
-
justly
justified containers
-
dsll
Fast Thread Safe Doubly Sorted Linked List
-
uvector
access two slices as a single continuous vector
-
dogma
Dogma.rs
-
immutable-seq
Immutable sequence data structure
-
wl-tools
Wordlist tools – algorithms and data structures for working with lists of words
-
simple-binary-tree
binary tree view representation
-
tobz1000-petgraph
Pseudo-namespaced fork of
petgraph: Graph data structure library. Provides graph types and graph algorithms. -
sqa-bounded-spsc-queue
A bounded SPSC queue (temporary version so I can publish sqa-engine)
-
freezable
immutable data
-
recursion-schemes
cache-aware stack safe recursion (this is the really haskell brained one)
-
collections-more
Common data structure and algorithms for rust-lang to complete the already excellent std::collections
-
dynstr
A string implementation optimized for manipulations
-
hff-core
Hierarchical File Format: core structure
-
fera-graph
Graph data structures and algorithms
-
string32
A string that is indexed by u32 instead of usize
-
lfbs
Lock-free stack with batched pop
-
lighter
Macro for rewriting string matches as tries
-
xdag
DAG(Directed Acyclic Graph) lib
-
id_cache
A cache data structure which generates sequentially-assigned ids for unique values
-
flattree
A series of functions to map a binary tree to a list
-
xsl-rs
A simple library
-
maybe-string
newtype wrapper that represents a byte vector that may be a valid UTF-8 string
-
hashindexed
A cache. A set which compares elements in a customisable way without overriding the eq() and hash() functions on the type itself.
-
graphster
High-performance DataGraph Library
-
flit
Bloom filter backed by xxHash
-
low-map
A convenient wrapper around a vector of options
-
loaf
Why have a slice when you can have a loaf?
-
lattice-graph
Set of Lattice(Grid) based Graph Structures
-
holodeque
Array- and slice-backed double-ended queues in 100% safe Rust
-
ati
Introduces the
Attrait, which allows collections to be indexed byu|i{8,16,32,64,128}andisize. Supports Python-like negative index, where -1 is last element. -
hoop
Fixed ring buffer that allows non-consuming iteration both ways
-
datastructures
A variety of data structures for learning purpose
-
hashmap_vec
A HashMap with lists a values
-
stack-buf
Vector-like facade for arrays allocated entirely on the stack
-
pyrpds
Python Wrapper for Rust Persistent Data Structures
-
keyed
Implement comparison traits by specifying a key
-
xio_instructionset
XIO instructionset data structures
-
gardiz
integer geometry on 2D planes, focused on games
-
graphed
implement graph-based functionality
-
index-set
An ordered set that stores indices in a sparse bit field
-
prio-queue
priority queue implemented as a heap stored in a Vec
-
elastic-array-plus
Elastic vector backed by fixed size array
-
unstorable
An interface for requiring that a type is only used on the current stack frame
-
csgo-gsi-payload
Data structures for CSGO Game State Integration
-
sexpr_matcher
Structural pattern matching macro for S-Expressions and other list-like data structures
-
intset
Various integer set data structures, each efficient for different operations
-
elu
Traits and implementations for EVAL-LINK-UPDATE data structures
-
neurarbor
manipulating tree graphs, for the analysis of neuronal arbors
-
internode
Smart references to your graph nodes
-
html-types
HTML Data structures
-
structurray
Easy psuedo-array generation for database optimization
-
quarkrs
A collection of small life improvements for rust
-
velect
A Vec with item / index selection
-
quetta
Immutable, reference-counted strings for rust
-
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.
-
slicedvec
A segmented vector for iterating over slices
-
priority-queue-rs
Priority Queue is more specialized data structure than Queue. Like ordinary queue, priority queue has same method but with a major difference. In Priority queue items are ordered by…
-
binary_search_tree
Binary search tree implementation
-
stacked
Stack-allocated data structures. This was a good learning experience, and these container types work well, but in the end, I was not able to beat the performance of Vec
-
slice-cell
A
Cell<[T]>-like mutable slice, that allows slice-like APIs -
flow-graph
A representation of a graph data structure for flow-based programming
-
immutable-avl
An Immutable map and set implement for rust based on an AVL tree
-
randsort
A sorting library with an optimal complexity of O(n) (!!) by randomly sorting Vectors until they are sorted
-
embedrs-bytes
Types and traits for working with bytes
-
ethercat-types
Common EtherCAT data structures
-
tdf_utils
such as tree
-
enum-map-derive
Macros 1.1 implementation of #[derive(Enum)]
-
atlist-rs
LinkedList which is allowed to insert/remove element by immutable iterator.Adding, removing and moving the elements within the list or across several lists does not invalidate the iterators or references…
-
rbloom
efficient and minimalistic bloom filter
-
arae
Cursed data structures
-
immutable_string
Immutable Single Instance Strings for Rust
-
ringvec
ring buffer implementation based on a vector
-
u64_array_bigints_core
Core library for
u64_array_bigints -
algods
A collection of data structures and algorithms
-
graphrs
package for the creation, manipulation and analysis of graphs
-
kudzu
concurrent, grow-only data structures
-
nd-slice
Wrapping
std::slices to represent n-dimensional arrays -
ninja-files-data
Core data structures for ninja files
-
regex-map
Associative container where the keys are regular expressions
-
gtfs-translations
Reads GTFS translations.txt into structures
-
castle_api
Castle API, graph api
-
associative_positional_list
AssociativePositionalList is a list-like container in which each value is associated with an index, but unlike other list containers, the index for a value can be determined efficiently
-
poison
writing poisoned types
-
cursorvec
Cursored vector container
-
lifetimed-bytes
Bytes, but with attached lifetime
-
tournament_tree
A tournament tree library
-
sliding_window
A fixed size, heapless sliding window
-
bloomy-rs
Fast bloom filter implementation
-
history_stack
A collection of containers that support generic history tracking mechanisms
-
rs-collections
generic collections (no dependency on std)
-
bitset-fixed
Bitset for DP
-
doubly
linked lists in rust
-
labelgraph
graph implementation, allowing random access to nodes via labels
-
const_queue
A stack-only, no_std queue using const generics
-
easy_graph
Data structure that represent generic vertices and undirected connections
-
tileline
generate SVG block graph
-
symbolmap-trait
A trait for generic implementation of symbol tables
-
fral
Functional random-access lists
-
texcraft-stdext
Rust data structures and algorithms used in the Texcraft project
-
heapq
Priority Queue with scoring function
-
collectables
collections helpers for BTreeMap, BTreeSet, HashMapSet, etc. By SixArm.com.
-
cons-list
An immutable singly-linked list, as seen in basically every functional language
-
dag_compute
construction of arbitrary computation DAGs and the expression of dataflow graphs
-
opt_arrayvec
Vector-like container with fixed capacity, using options instead of stored length
-
im-rope
Unicode strings backed by RRB vectors
-
simple-graph
Graph library with ability to serialize/deserialize Trivial Graph Format
-
ketsugou
merges two arrays
-
lenses
An optics library loosely inspired by Julien Truffaut's Monocle
-
gml_parser
A fast and simple Graph Modeling Language (GML) parser
-
btree_graph
A generic graph data structure