-
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
-
bit-vec
A vector of bits
-
bimap
Bijective maps
-
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 -
smallbitvec
A bit vector optimized for size and inline storage
-
ringbuffer
A fixed-size circular buffer
-
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
-
spade
Delaunay triangulations for the rust ecosystem
-
hashbag
An unordered multiset implementation using a hash bag
-
multimap
A multimap implementation
-
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
-
gix-pack
Implements git packs and related data structures
-
modql
Model Query Language support
-
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
-
fixed-map
A fixed map where storage layout is calculated by a procedural macro
-
louds-rs
High performance LOUDS (Level-Order Unary Degree Sequence) library
-
slice-ring-buffer
A double-ended queue that Deref's into a slice
-
array-macro
Array multiple elements constructor syntax
-
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
-
binary-heap-plus
Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps
-
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
-
fastbloom
The fastest Bloom filter in Rust. No accuracy compromises. Compatible with any hasher.
-
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
-
csaf-walker
work with CSAF data
-
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.
-
blart
adaptive radix tree packaged as a BTreeMap replacement
-
hibitset
Hierarchical bit set structure
-
algorithm
about algorithm data structure, now has ttl with lru/lru-k/lfu/arc and slab/rbtree/roaring_bitmap/timer_wheelss, 关于算法常用的数据结构
-
indexset
A two-level BTree with fast iteration and indexing operations
-
fastbloom-rs
Some fast bloom filter implemented by Rust for Python and Rust!
-
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
-
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
-
range-collections
Sets and maps of ranges, backed by smallvec
-
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
-
any_vec
Type erased vector. Most operations can be done without type knowledge. Mostly zero overhead.
-
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
-
fm-index
FM index and its variant implementations for Rust
-
xsd-types
XSD data types
-
gix-traverse
gitoxide project
-
vecmap-rs
A vector-based map and set implementation
-
bitfield-struct
Struct-like procedural macro for bitfields
-
zerofrom
trait for constructing
-
lattices
Lattice data types for simplifying distributed state by providing associativity, commutativity, and idempotence
-
vortex-dtype
Vortex's core type system
-
array2d
A fixed sized two-dimensional array
-
rust_dynamic
Support for dynamically-typed values in run-time
-
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.
-
btree-range-map
B-tree range map implementation
-
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
-
cow_hashbrown
port of Google's SwissTable hash map with copy-on-write support
-
hash_hasher
A hasher which is designed to work with already-hashed or hash-like data
-
tree-ds
manipulate tree data structures
-
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
-
differential-dogs3
Advanced join patterns in differential dataflow
-
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
-
baby_shark
Geometry processing library
-
tracker
A macro to track changes on structs
-
iso7816
Types for ISO 7816
-
ordered-multimap
Insertion ordered multimap
-
tagged-pointer
Platform-independent space-efficient tagged pointers
-
oxidd
A safe, concurrent, modular, and performant decision diagram framework
-
starlark_map
Map implementation with starlark-rust specific optimizations
-
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
-
arrow-ord
Ordering kernels for arrow arrays
-
uguid
GUID (Globally Unique Identifier) no_std library
-
cactus
Immutable parent pointer tree
-
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
-
imbl-sized-chunks
Efficient sized chunk datatypes
-
bitm
bit and bitmap (bit vector) manipulation
-
polars-ops
More operations on Polars data structures
-
scapegoat
Safe, fallible, embedded-friendly ordered set/map via a scapegoat tree. Validated against BTreeSet/BTreeMap.
-
pyinrs
type library that is as easy to use as Python built-in types
-
validated
The cumulative sibling of
ResultandEither -
ordered
A wrapper for adding arbitrary partial/total order to a type
-
orx-fixed-vec
An efficient fixed capacity vector with pinned element guarantees
-
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… -
cc-traits
Common collection traits
-
orx-iterable
Defines and implements Iterable, Collection and CollectionMut traits to represent types that can be iterated over multiple times
-
mhgl
Matts HyperGraph Library (MHGL). A straightforward library for hypergraph datastructures.
-
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.
-
json-number
JSON number parsing and storage
-
orange-trees
Tree data structure with several methods to query and manipulate nodes
-
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
-
tc-value
TinyChain's representation of a value which can be collated and stored
-
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
-
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
-
elusion
DataFrame library, built on top of DataFusion SQL engine, for easy usage, with familiar DataFrame syntax like: PySpark, Pandas, Polars
-
extindex
Persisted immutable index
-
more_collections
Additional collections not found in std::collections
-
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
-
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…
-
optional
supplies a number of Option-like primitive types
-
atelier
a Computational Workshop for Market Microstructure Modeling, Synthetic Simulation and Historical Replay
-
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
-
bittle
Zero-cost bitsets over native Rust types
-
flatk
Flat layout abstraction toolkit
-
vart
An immutable versioned adaptive radix trie
-
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
-
oxidd-rules-zbdd
Zero-suppressed decision diagrams (ZBDDs) for OxiDD
-
avl
A map and a set implemented with an AVL tree
-
walker-common
Common functionality for SBOM and CSAF walker
-
pasture-core
A framework for working with point cloud data
-
ux-primitives
Graphics Primitives for Angular Rust
-
edtui-jagged
A jagged array data structure for the edtui editor
-
sized-chunks
Efficient sized chunk datatypes
-
ordsearch
A data structure for efficient lower-bound lookups
-
cbsk_socket
socket callback tool
-
flatcontainer
A flat container representation for Rust
-
mut_set
A safe implementation for HashSet with iter_mut and get_mut
-
number-general
A generic number type for Rust which supports basic math and (de)serialization
-
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
-
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
-
odht
hash tables that can be mapped from disk into memory without the need for up-front decoding
-
xorf
implementing xor filters - faster and smaller than bloom and cuckoo filters
-
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
-
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
-
mikufans-proto
gRPC APIs for Mikufans
-
spacetimedb-data-structures
Assorted data structures used in spacetimedb
-
delay_map
HashMap collections whose entries expire after a given time
-
rbitset
A bit set, being able to hold a fixed amount of booleans in an array of integers
-
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
-
ordinal-map
Ordinal trait to map values to integers and efficient maps and sets for such types
-
fingertrees
Immutable persisten finger trees
-
jaggedarray
Multidimensional jagged array
-
alot
A forbid-unsafe, generational slot map with usize-sized IDs
-
hotel
Collection Data-structure to associate values with keys
-
polytype
A Hindley-Milner polymorphic typing system
-
datas
data structures and algorithms and data analisys
-
lean_string
Compact, clone-on-write string
-
bitboard64
A 64-bit bitboard useful for chess programming
-
rust_multistack
Support for two-dimentional stacks for the Rust programming language
-
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
-
typeid_prefix
that implements a type-safe version of the TypePrefix section of the
TypeIDSpecification -
smallvec-wrapper
Macro and common structs to play with
smallvec -
unordered-pair
A tuple struct representing an unordered pair
-
c_vec
Structures to wrap C arrays
-
gix-diff
Calculate differences between various git objects
-
tuplez
Tuples represented in recursive form
-
json_dotpath
Dotted path access to nested JSON objects (serde_json::Value)
-
sync42
synchronization tools
-
cmsketch
A count min sketch implementation in Rust
-
numeric-array
Wrapper around generic-array that adds efficient numeric trait implementations
-
normalize_interval
Normalizing interval library
-
nam-sparse-merkle-tree
(Namada fork) Sparse merkle tree implement in rust
-
matreex
matrix implementation
-
wipe-on-fork
A replacement to OnceCell, LazyCell, Once, OnceLock, LazyLock that wipes itself when being forked in Unix
-
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.
-
min-max-heap
An efficient, double-ended priority queue
-
pdatastructs
probabilistic data structures
-
rdf-types
Data-structures and traits definitions for RDF
-
edgefirst-schemas
Maivin EdgeFirst Services Schemas
-
sigma-types
Types checked for an invariant
-
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.
-
field_access
Dynamically access struct fields
-
lctree
Link-Cut-Tree: self-balancing data structure to maintain a forest of rooted trees
-
cantrip
Practical extension methods for standard Rust collections
-
smart_led_effects
A collection of effects for LED strips
-
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
-
std-ext
Extend the standard library functionality
-
endpoints
A collection of data structures for the OpenAI-compatible endpoints
-
signalk
parse signalk maritime data
-
mago-ast
Supplies the data structures and types for representing PHP code as an Abstract Syntax Tree (AST)
-
entity_data
A container for entity component data
-
sucds
Succinct data structures in Rust
-
v_queue
file based queue
-
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
-
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
-
rdf-model
RDF.rs
-
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
-
atomic_ptr_cell
Safe no_std repr(transparent) wrapper for AtomicPtr and &AtomicPtr with an api similar to a cell
-
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
-
pipebuf
Efficient byte-stream pipe buffer
-
prost-unwrap
A procedural macro for prost-generated structs validation and type-casting
-
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…
-
trane
An automated system for learning complex skills
-
jumprope
fast rope (fancy string) library built on top of Skiplists
-
cuckoofilter
Cuckoo Filter: Practically Better Than Bloom
-
plain_trie
Classic trie implementation capable of mapping any T to char iterator
-
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
-
doubloon
Money datatype that supports both statically and dynamically typed currencies
-
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
-
supply-chain-trust-example-crate-000006
port of Google's SwissTable hash map
-
ndata
Thread-safe, self-owned JSON-like data with manual garbage collection
-
trie-hard
Fast implementation of trie data structure
-
kollect
Collections made ergonomic for gamedev usecases
-
beach_map
slotmap
-
enum2egui
derive macro that creates a set of egui ui databindings from arbitrary data structures. Supports egui v0.29.1
-
bao-tree
BLAKE3 verfiied streaming with custom chunk groups and range set queries
-
hvec
A Vec-like structure that can store different types of different sizes contiguous with each other in memory
-
libreda-db
Layout and netlist datastructures for chip design
-
ffi-convert
A collection of utilities to ease conversion between Rust and C-compatible data structures
-
value-ext
Serde Json Value Extension Trait (more Value type later)
-
ttgraph
Typed/Transactional Graph container
-
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
-
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 -
named_colors
that provides named colors in RGB and Hexadecimal formats
-
phf_generator
PHF generation logic
-
mmdb
A std-collection-like database
-
btree-slab
A memory compact Slab-based B-tree implementation
-
packed-uints
Array of uints that scales from u4 to u32 to minimize wasted space while still being fast
-
heavykeeper
finding the top-k elements of a stream of data
-
relend
A generalized reborrowing mechanism that extends beyond simple references. It also allows for implementing traits that work with reborrowing for custom types.
-
libpna
PNA(Portable-Network-Archive) decoding and encoding library
-
cell-grid
2d grid container
-
type-map
typemap container with FxHashMap
-
hibit_tree
Hierarchical bitmap tree. Prefix tree without memory overhead that act as herarchical bitmap.
-
parametrized
Supply useful iterating methods for user-defined types which are parametrized by type parameters
-
decomp
Components of a decompilation pipeline
-
prefix-sum-vec
Compressed storage for highly repeating elements, with
O(log n)lookups -
populated
Collection types that are guaranteed to be populated (i.e. non-empty). Based on std::collections types.
-
statiki
Static friendly data structures
-
chemrust-core
The core modules defining the flow and structs of data in computational chemistry routines
-
bv
Bit-vectors and bit-slices
-
settrie
Fast subset and superset queries
-
basic_trie
Trie implementation in Rust
-
hextree
Location to value mapping
-
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
-
among
The enum
Amongwith variantsLeft,MiddleandRightis a general purpose sum type with three cases -
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
-
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
-
canopydb
Transactional key-value storage engine
-
token-parser
parsing texts into data structures
-
grovedb-path
Path extension crate for GroveDB
-
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…
-
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
-
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
-
slice-of-array
Extension traits for casting between slices and slices of arrays. (&[T] <-> &[[T; n]])
-
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 -
jupyter-serde
Serialization and Deserialization for Jupyter related data structures
-
threshold
data structures
-
re_string_interner
string interning library
-
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
-
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
-
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)
-
standard_card
A Lightweight Library for Efficient Card Representation
-
mem_btree
A Data Structure of BTree Implemented with Rust, support snapshot. not use any unsafe lib.
-
roussillon-type-system
A type system for a programming language
-
get-full-year
An unofficial Rust client for getfullyear.com that helps you get the full year
-
rstmt-neo
focuses on building a music theory library that can be used to generate music theory data structures and algorithms
-
fast-graph
A fast, lightweight and extensible implementation of a graph data structure
-
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
-
rtree_rs
R-tree for Rust
-
flammkuchen
Some data structures for fun and flammkuchen (e.g. a 2d grid which permits negative indices)
-
shardtree
A space-efficient Merkle tree with witnessing of marked leaves, checkpointing & state restoration
-
radicle-cob
Radicle Collaborative Objects library
-
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
-
arrayset
An array-backed ordered set type
-
trie-root
In-memory patricia trie operations
-
sigmars
sigmahq rule collections
-
bit_mask_ring_buf
A ring buffer implementation with cheap indexing
-
flatbuffers-owned
that enables a more flexible usage of FlatBuffers
-
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
-
pfx
A prefix tree (map and set), implemented without any unsafe
-
microkelvin
tree traversal over annotated data structures
-
queues
Efficient FIFO Queue data structures
-
datafrost
Data format and acceleration structure management
-
erased_set
A set of erased types
-
ztimer
A block-based, non-circular double-linked list implementation for Rust
-
beat_saber_map
Read and write Beat Saber maps with Rust
-
btree_monstrousity
a code port of BTreeMap but with comparator functions
-
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
-
codas
Compact and streamable data format that works anywhere--from web apps to robots
-
task-group
manage groups of tokio tasks
-
delta-collections
Data structures with revertable operations called deltas
-
host-port-pair
Host-port pair type
-
hylo-fix
Fixed-point number types with Solana Anchor support
-
mown
Maybe owned values. Wrappers for values that can be either owned or borrowed.
-
vortex-bytebool
Vortex byte-boolean array
-
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
-
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.
-
search_trail
manager of variables that can save and restore their values
-
crdt-lite
CRDT library for Rust
-
orx-selfref-col
SelfRefCol is a core data structure to conveniently build safe and efficient self referential collections, such as linked lists and trees
-
expiringdict
A dict / HashMap whose items expire over time
-
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
-
akita
Mini orm for rust
-
oca-presentation
Lib providing struct for OCA presentation
-
mule-map
A hybrid between a HashMap and a lookup table
-
fixed-vec-deque
A fixed-size, zero-allocation circular buffer for Rust
-
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
-
starling
This tree structure is a binary merkle tree with branch compression via split indexes
-
artie_common
Common Library for Artie Rust Projects
-
know
Framework for Rust
-
linearize
Types that are enumerable and an array-backed map
-
orx-pseudo-default
PseudoDefault trait allows to create a cheap default instance of a type, which does not claim to be useful
-
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
-
indexical
indexed collections
-
fixed-capacity-vec
Variable-length buffer backed by a fixed-size heap array
-
regroup
regrouping arrays
-
iterable
collection like types
-
ndstruct
Structures for N-dimensions
-
stavec
Stack-allocated vector with static capacity
-
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.
-
compact_strings
A more compact but limited representation of a list of strings or bytestrings
-
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
-
miny
Box<T> with small value optimization
-
vsmtp-config
Next-gen MTA. Secured, Faster and Greener
-
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
-
bitstring
traits and implementations
-
unionfind
A union find library made for building type inference engines. Can be used as general purpose datastructure.
-
const_sized_bit_set
A bitset with a const generic size parameter indicating the number of 64 bit words to use
-
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 -
logisheets_controller
the core of LogiSheets
-
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
-
oxidd-manager-index
Index-based manager implementation for OxiDD
-
etwin_dinoparc_store
Dinoparc store implementation
-
trybox
stable,
no_std-compatible, fallible heap allocation -
no_std_collections
Auxiliary structures and traits for using dynamically resizable arrays (Vectors) in flexible environments, supporting both std and no_std contexts
-
pasture-algorithms
Point cloud algorithms for pasture
-
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)
-
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
-
pi_spatial
sparial octtree quadtree
-
quadtree_simple
quadtree implementation
-
aatree
in Rust
-
lp-pack-scanner
scanner library
-
non_empty_continuous
Non-empty continuous collections
-
competitive-programming-rs
Competitive Programming Library in Rust
-
yyid
Yyid generator (random tokens like UUIDv4, but using all the bits)
-
set_genome
A genetic data structure for neuroevolution algorithms
-
mirl
Miners Rust Lib - A collection of ever growing functions and structs
-
floating_bar
Representing rational numbers using the floating-bar number type
-
quickselect
基于rust的选择算法
-
iterlist
Linked list with a cursor based api
-
palettevec
A palette compressed vector library for potentially insane runtime compression ratios
-
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
-
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
-
ux-dx
3D Graphics Primitives for Angular Rust
-
index-ext
Index slices with arbitrary ints and as arrays
-
ibuilder
Interactive builder for Rust types
-
scribe
Text editor toolkit
-
sbbf-rs
Split block bloom filter implementation
-
ds-ext
Extensions to standard Rust data structures which provide additional capabilities
-
trk-io
TrackVis (*.trk) reader and writer
-
bytering
A ring buffer specialized for vectored reading and writing in blocking and async I/O
-
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
-
foyer-intrusive-collections
Intrusive collections for Rust (linked list and red-black tree)
-
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
-
atomicow
A
Cow-like data structure where owned data is stored inside anArc -
tord
Data structure to store transitive relations
-
forest-ds
secure tree structure
-
penumbra-sdk-transaction
Core transaction data structures for Penumbra
-
confiner
A config language for things that look like trees
-
hdf5-dst
DST extensions for HDF5
-
fibis
fixed range bitset
-
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
-
hit-data
Hierarchical Indexed Typed data structure
-
loaned
Safely move values with live inner borrows
-
ux-dataflow
Data Processing Library
-
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
-
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.
-
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
-
israeli_queue_etc
various queues
-
school_library
structures to manage school-related data, including students, classes, and schools
-
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
-
stable-map
A hash map with temporarily stable indices
-
pi_slot
lock free Slotmap data structure
-
cfpyo3_rs_core
a collection of performant utilities
-
arr-rs
arrays library
-
lapce-xi-rope
A generic rope data structure built on top of B-Trees
-
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
-
sparse_set_container
A container based on sparse set. Stable keys, O(1) lookup, cache-friendly iterations, and no hashing.
-
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
-
iter-tree
Convert between iterators and tree structures in both directions
-
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
-
ascent-byods-rels
data structures for Ascent relations, made possible by Ascent's BYODS feature
-
incrstruct
Build self-referencing structs using two-phase initialization
-
anchors
async incremental computations
-
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
-
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
-
enum_meta
Add metadata to Enum Variants
-
incrementalmerkletree-testing
Common types, interfaces, and utilities for testing Merkle tree data structures
-
leetcode-trees-rs
Tree Node LeetCode problems
-
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…
-
sequential_gen
sequential generator
-
data_model
[highly unstable] data model for virtualization
-
im-lists
Persistent unrolled linked lists and vlists
-
cmdtree
(Rust) commands tree
-
medianheap
A median heap for keeping track of a running median
-
non-random-state
Deterministic HashMap and HashSets
-
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
-
timeless
storing in-memory timeseries data
-
token-lists
token list representation
-
nlist
inline-allocated list with statically tracked length
-
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
-
shiftnanigans
contains different iteration data structures for either iterating or for shifting iteratively forward and backward
-
multi_index_map
MultiIndexMap: A generic multi index map inspired by boost multi index containers
-
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
-
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)
-
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.
-
cow_vec_item
Copy-on-write Vec, available on stable rust
-
safer_owning_ref
creating references that carry their owner with them
-
tuple_list
macro-free variadic tuple metaprogramming
-
probabilistic-collections
Various implementations of collections that use approximations to improve on running time or memory, but introduce a certain amount of error
-
higher
Functors, Applicatives, Monads and other bad ideas
-
phylo
An extensible Phylogenetics library written in rust
-
seq-map
Sequential Map
-
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
-
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
-
big_unsigned_ints
Big Unsigned Integers ranging from U256 to U2048 using u64 arrays all under a fixed-size of 32
-
fenwick
tree: data structure that efficiently calculates prefix sums in a changing array of numbers
-
codes-iso-639
This package contains an implementation of the ISO 639 (Parts 1, 3, and 5) Language Code specifications
-
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…
-
uuidv7
UUIDv7 implementation
-
laurier
ratatui helper library
-
any-range
AnyRange<T> enum can hold any Range*<T> type
-
mago-token
Defines the data structures and enumerations representing PHP tokens
-
rexsgdata
Scatter-Gather Data Descriptors
-
cbsk_mut_data
ref mut tool
-
modular-bitfield-msb
Allows to easily define bitfield types with modular building blocks. MSB-first version.
-
tensorism
Multidimensional arrays with bounds included in the type system
-
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
-
hicollections
C-liked Collections
-
emap
A map with a fixed capacity and integers as keys
-
chesspos
Basic structs for representing chess squares
-
frunk-enum-core
Implemenation of genericized enums for use with frunk
-
try-lazy-init
Fallible lazy initialization
-
rust_twostack
Support for two-dimentional stacks for the Rust programming language
-
disjoint-sets
Three union-find implementations
-
ssd-data
A service and data description format + a code generator based on rhai scripts and templates
-
gix-hashtable
that provides hashtable based data structures optimized to utilize ObjectId keys
-
riddance
retiring, recyclable, reservable IDs
-
gecs
A generated entity component system
-
depends
Ergonomic, performant, incremental computation between arbitrary types
-
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
-
ftree
A very fast fenwick tree implementation
-
sweep-bptree
In memory locality aware b+ tree, faster for ordered access
-
default-vec2
Vec-like data structure with default elements and a bitset built using it -
smallbitset
series of allocation free sets capable of holding small integer values
-
i_tree
Red-black tree implementation for rust. Only for uniq elements
-
alignment-exporter
Proc macro providing alignment info for a user-defined struct
-
chronofold
A conflict-free replicated data structure (a.k.a CRDT) for versioned text
-
itc
Interval Tree Clocks as described in the itc2008 paper
-
histogram-sampler
Sampling from a distribution given by a histogram
-
circbuf
A growable circular buffer for working with bytes
-
range_bounds_map
[
RangeBoundsMap] and [RangeBoundsSet], Data Structures for storing non-overlapping intervals based of [BTreeMap] -
generic-btree
Generic BTree for versatile purposes
-
orchestrator
Orchestration sequences
-
wasmrs-frames
WasmRS RSocket frame decoding, encoding, and data structures
-
rdf-format
RDF.rs
-
dayendar
advanced days calendar operations
-
expanding_slice_rb
A self-expanding ring buffer similar to VecDeque optimized for working with slices of data
-
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.
-
codas-flow
Low-latency, high-throughput bounded queues ("data flows") for (a)synchronous and event-driven systems
-
arraysetcell
A fixed-capacity, vector-like array with interior mutability and no ordering guarantees
-
flat_collections
Lightweight and memory-efficient associative data structures
-
vec-string
To print Vec<Display>
-
deepmesa
fast Data Structures and Algorithms in Rust. Every data structure is hand crafted for performance, well tested and has an extensive API.
-
easy_collections
Wrappers around standard collections for ease of use and quick prototyping
-
twice-cell
Like
once-cell, except you set the value twice -
canadensis_dsdl_frontend
Compiler front-end for the Cyphal Data Structure Description Language
-
msgpack_simple
Simplified, easy to use, pure Rust MessagePack implementation focused on handling dynamic data structures
-
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
-
lru-st
A package providing a Vec based doubly linked list implementation and related data structures
-
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
-
text-document
Text document structure and management
-
croaring-sys
Raw bindings to CRoaring
-
zk-kit-smt
Sparse Merkle Tree
-
xot
Full-featured XML tree library for Rust
-
zond
standard rust collections but with collecting statistics
-
alt-std
Alternative Lightweight Std library for making small executables and shared objects
-
committable
Keccak256-based structured commitments
-
ioc
An Inversion-of-Control library in Rust
-
ndarray-histogram
Histogram support for n-dimensional arrays
-
rj
reactive json
-
anymap2
A safe and convenient store for one value of each type
-
type-rules
easily constrain a struct
-
uniquevec
A
Vec-like datastructure which only contains unique entries. It is no_std and has optional serde support. -
output_iter
An iterator that performs calculation during iteration
-
arbutus
Trees
-
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
-
mikufans-proto-intl
gRPC APIs for Mikufans (Intl)
-
wplot
Plot interface
-
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
-
entity
that provides entity-like constructs
-
sortedvec
a sorted vector that enables quick lookups
-
packed_ptr
A configurable & generic tagged pointer implementation in Rust
-
jsonmap
store values of multiple types value in one Map
-
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…
-
hdf5-hl
High level bindings to HDF5 High Level API
-
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
-
string_manipulation_utf8
String manipulation functions using character indexing (UTF-8) instead of bytes
-
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
-
rle_vec
A vector like struct that stores data as runs of identical values. Useful for storing sparse data.
-
mago-reflection
Offers data structures and APIs to represent and inspect PHP code elements—like classes, functions, and interfaces—enabling introspection and analysis
-
seq-set
A Set collection that maintains insertion order
-
gen_value
indexes and values with generations for vectors
-
tinybox
Like
Box, but with an optimization that avoids allocations for small data-structures -
cow_hashmap
Hashmap with copy-on-write semantics that requires no locks
-
compare
Experimental comparators for collections to be generic over
-
arc-bytes
A reference-counted byte buffer
-
tree-sitter-traversal2
Traversal of tree-sitter Trees and any arbitrary tree with a TreeCursor-like interface
-
byteview
Thin, immutable zero-copy slice type
-
median-heap
A median heap implementation in Rust, used to keep track of a running median of a sequence of numbers
-
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…
-
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.
-
pax-properties-coproduct
Static container for program-variable data structures and polymorphic components
-
galemu
workaround for generic associated types (GAT) limited to lifetimes (GAL)
-
open-coroutine-timer
The time utils
-
structures
collection data structures
-
syzlang-parser
Parse Syzlang language
-
minsize
Collections with a statically known minimum size (using const generics)
-
bdaddr
Bluetooth Device Address
-
rust-3d
2D/3D library written in rust
-
contack
easy contact library
-
rc-writer
A tiny implement for writing data to a reference counted instance
-
union-fn
Proc. macro for creating efficient "inline closures".
-
intervaltree
generic implementation of an immutable interval tree
-
zngur-def
Data types that define the structure of a zng file
-
pin_array
Tiny crate providing an array with structurally projected pinning
-
timer_list
A list of timed events that will be triggered sequentially when the timer expires
-
latestmap
latest map
-
xbinser
binary structure transporation
-
mih-rs
Multi-index hashing (MIH) for neighbor searches on binary codes in the Hamming space
-
sweetrpg-kv-objects
Objects for Key-value store
-
kv6
Collection of structs to allow reading of Ken Silverman's voxel formats
-
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.
-
grdf
Generalized RDF graphs and datasets
-
weak-lists
Lists with weak references and concurrent iteration and modification
-
fixed_deque
A fixed size VecDeque to match Python Deque
-
range_map_vec
range map data structure backed by a Vec
-
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
-
valser
Structure schema library for Rust
-
rs_filter
filter library for matching on complex data structures
-
streaming_algorithms
SIMD-accelerated implementations of various streaming algorithms, including Count–min sketch, Top k, HyperLogLog, Reservoir sampling
-
timer-queue
Pure, minimal, and scalable timers
-
mco-gen
Stackfull Generator Library in Rust
-
expiringmap
a HashMap-backed TTL map
-
flex-alloc
Data structures with extra flexible storage
-
comparer
track changes in a HashMap over several iterations
-
varlen
Ergonomic variable-length types
-
bit-int
An arbitrary fixed bit-width integer library
-
mut-rc
Temporarily mutable
Rc<T>that decays intoRc<T> -
kdtree-simd
K-dimensional tree in Rust for fast geospatial indexing and nearest neighbors lookup
-
atomic_lifo
Lock free thread-safe lifo for rust
-
wolf-graph
Data structures and algorithms for working with graphs with reference or value semantics
-
sbom-walker
work with SBOM data
-
pi_ordmap
Ord Map
-
compt
A complete binary tree visitor library
-
indexmap-nostd
A no_std compatible implementation of the indexmap crate
-
collect-rs
Special and custom Collections and Containers (for Rust)
-
implies
A parser for logical formulas
-
honeycomb-kernels
Meshing kernel implementations using combinatorial maps
-
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
-
ordmask
To check if a value is included efficiently
-
voxtree
A sparse voxel octree for rust & rust-gpu
-
alist
Association list offering fast lookups while preserving insertion order
-
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
-
smart_access
A minimalistic "lazy bidirectional pointer" framework
-
spaceindex
-
rs-car
CAR v1 and v2 specifications
-
bittyset
A BitSet type for manipulating bit sets
-
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
-
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
-
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 -
ldtk_map
reading ldtk maps for usage in games
-
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
-
ordered_hash_map
HashMap which preserves insertion order
-
crdt_tree
Tree Conflict-free Replicated Data Type (CRDT)
-
meminterval
interval-tree in Rust made to store memory mappings
-
spaghetto
making double-ended data structures, like an always-contigouous double-ended queue (deque) and double-ended string
-
xsd
XSD.rs
-
grid2d
Two dimensional grid of runtime-defined, but unchangable size
-
phf_mut
Perfectly hashed mutable containers
-
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
-
triangle_matrix
Triangle matrix indexing operations
-
omango-util
Utililites
-
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
-
penumbra-sdk-num
Numerical data structures and implementations used by Penumbra
-
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
-
radix-heap
Fast monotone priority queues
-
froop
A functional reactive stream library for rust
-
incremental-map
combinators for incremental immutable maps (see crate
incremental) -
twitter/rustcommon-time
getting current and recent timestamps
-
fixed_bitmaps
A small crate implementing bitmap functionality around primitive Rust unsigned integers
-
quickscope
Multi-layer HashMap and HashSet implementations for performant representation of variable scopes
-
raw-btree
Generic B-Tree implementation
-
tpntree
A N-dimensional generalization of region quad/oc-trees
-
signvec
Vector implementation for fast, sign-based manipulation of dynamic collections
-
netlist
generic netlist data structure for VLSI design
-
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
-
sif-itree
immutable, flat interval tree
-
inplace-vec-builder
Build a vec from a vec, in place
-
merkle
tree implementation with support for generation of inclusion proofs
-
tangu-lints
A collection of lints for the Tangu language
-
mqfilters
Highly optimized approximate membership query filters (bloom, cuckoo, xor, quotient) with SIMD support
-
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
-
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
-
grids
2D grid data structure for games
-
light-curve-interpol
Interpolations tools for time series
-
osmgraph
Convert OSM queries into graphs
-
hash-chain
A tiered hashmap and hashset implementation that allows for easily representing lexically scoped variables
-
debug_match
debugging and matching patterns in data structures
-
disk-ringbuffer
lock free on disk ringbuffer to be used in the implementation of Franz
-
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
-
header-vec
Vector with user-specified header, length, capacity, and array elements all stored on the heap together
-
manhattan-tree
A spatial tree which can effiently find closest key to a point, by manhattan distance
-
wccg-models
WCCG Data
-
rstmt
focuses on building a music theory library that can be used to generate music theory data structures and algorithms
-
array-const-fn-init
Initializes an array with constant values calculated by a
const fn -
egui_suspense
Automatically show loading and error uis for egui
-
limq
Queue with optional maximum number of elements constraint
-
eastl-rs
EASTL binary-compatible Rust implementations
-
supply-chain-trust-example-crate-000048
Types and traits for working with bytes
-
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
-
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]> -
sorted_vector_map
maps and sets backed by sorted vectors
-
panoradix
A generic map and a set, both backed by a Radix tree
-
id_collections
Index-oriented programming in Rust
-
orbweaver
designed for effortless construction and analysis of graph data structures
-
fixstr
fixing strings
-
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 -
tinybitset
Generic implementation of small, fixed size, copyable bitsets
-
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
-
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:… -
pvec
RRB-Tree based persistent vector implementation
-
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!
-
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
-
purse
Bag data structure implementation in Rust
-
veho
a iterable toolset
-
cseq
compact sequences
-
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
-
groupex
Syncronization primitive that allows acquire lock by index
-
nakadi-types
A connector for the Nakadi Event Broker
-
piece_table_rs
piece table data structure
-
predicates-tree
Render boolean-valued predicate functions results as a tree
-
kushi
A queue built for the Dango Music Player and Oden Music Bot
-
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
-
supply-chain-trust-example-crate-000019
A hash table with consistent order and fast iteration
-
b-tree
A persistent B+ tree using freqfs
-
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
-
recursive_reference
way to walk on recursive structures easily and safely
-
total-maps
Maps where every possible key has an associated value
-
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.
-
chainmap
mutability of intermediate maps
-
zetacore
in-memory vector store library with Python bindings
-
diamond-types
The world's fastest text CRDT
-
kd-tree-rs
k-d tree
-
pointcloud
An accessor layer for goko
-
enum-tag
Proc. macro for generating enum discriminant types.
-
rustz
functional programming in Rust
-
myopic
A possibly bad lens library for Rust
-
chainbuf
Fast chained buffers
-
extensions-rs
File extension types in Rust
-
generational-indextree
Arena based tree structure by using indices instead of reference counted pointers
-
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
-
slice-find
SliceFind trait add .find() method (for search sub-slice in slice) to Vec, slice, fixed-length-slice in standard library
-
beehive
collections for 3D hexagonal maps
-
wavelet-matrix
A wavelet matrix implementation. Supports various near-O(1) queries on large number of symbols or integers.
-
neighborhood-diversity
computing the neighborhood diversity of simple, undirected graphs
-
chain-map
A chain of maps with a single view into the aggregated values
-
python-objects
that implements the architecture of the CPython objects. with this crate you can crate a list with any data type from rust
-
dakv_skiplist
skiplist for dakv
-
stealth-lib
functions for ZKP
-
typerat
Type-level rational numbers based on
typenum -
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
-
listfree
lockfree prepend-only list
-
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)
-
numas
multidimensional array for efficient computing
-
supply-chain-trust-example-crate-000058
Generic types implementing functionality of arrays
-
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.
-
clap_flags
Collection of reusable flags for Clap
-
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
-
colibri
Rust data structures for Jitsi Meet Colibri messages
-
unnamed_entity
Strongly-typed indexing for vectors and other structures
-
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… -
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
-
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
-
billios
A soil library
-
tst
Ternary search trie collection in rust with similar API to std::collections as it possible
-
nimbusqueue
fifo collection
-
acme-types
Types for implementing ACME (RFC 8555) providers and clients
-
esl01-indexedlog
Append-only on-disk storage with integrity checks and indexing support
-
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
-
equivalent-flipped
Similar to
equivalentcrate, but flipsKandQ -
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
-
rahashmap
Fork of standard library HashMap with additional functionality
-
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
-
statemachine-rs
A statemachine crate which have zero dependencies
-
unicase_collections
Collection of UniCase datastructures
-
st2-logformat
Adapter-agnostic definitions for data types used by ST2
-
skog
Adobe's stlab::forest data structure
-
landfill
Various types for dealing with on-disk data
-
arrayy
Stack-allocated fixed-size array with useful methods on top of Rust's [T; L] type
-
staticvec
Implements a fixed-capacity stack-allocated Vec alternative backed by an array, using const generics
-
caffeine
Collection of data structures I'm writing for fun. Originally written for use with my crafting interpeters tutorial implementation.
-
periodic-rs
Bounded datastructures
-
riblt
Rateless Invertable Bloom Lookup Table (RIBLT) data structure
-
stonks
Sets that allow borrowing while inserting entries
-
subranges
manage non-interssecting integer intervals
-
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 -
persist-o-vec
A Vec type that aims to have stable indices and memory location
-
constructivism
Simplify the construction of structured data
-
libreda-splay
Splay map and splay set data structures
-
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!
-
circular-queue
A circular buffer-like queue
-
splay_tree
Splay Tree based Data Structures (map, set, heap)
-
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
-
insrcdata
Embed static data as source code
-
queued_rust
queue type for better privacy managment and data orginization
-
crfsuite-sys
Rust binding to crfsuite
-
rimu-value
A data structure template system
-
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
-
arc-string-interner
An efficient cuncurrent string interning data structure with minimal memory-footprint and fast access to the underlying contents
-
quickphf_codegen
Code generator for creating static maps and sets for use with quickphf
-
multipath
split file path, like
/home/{user,admin}/file.txt -
folketinget-api-models
Autogenerated Rust structures based on the Danish Parliament's OData metadatafile
-
crio
An easy to use persistent data storage library
-
minimizer-queue
Fast computation of minimizers using a monotone queue
-
google-contacts-csv
Struct defined to hold the contact information from the Google contact file
-
handlemap
A collection that produces handles that can be used as keys to retrieve the stored items
-
bktree
BK-tree datastructure
-
redox_simple_endian
A create for defining endianness within your data structures, to make handling portable data structures simpler
-
cbsk_log
log tool
-
atlv
Algebraic Tag Length Value encoding
-
path-value
Universal type and access property(s) by path
-
partial
Optional monad with fake variant
-
cycler
A simultainious write/read data structure
-
eureka-mmanager-core
The core package for the eureka-mmanager crate
-
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
-
poppy-filters
providing serializable Bloom filters implementations
-
simple-undo
Easy to use undo-redo library
-
hamst
Hash Array Mapped Shareable Trie
-
im-pathtree
Immutable, path-addressable tree data structure
-
fst-map
succinct map
-
b100m-filter
The fastest bloom filter in Rust. No accuracy compromises. Use any hasher.
-
merkle-cbt-lean
Special implementation of Complete Merkle Binary Tree for minimal memory footprint
-
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
-
pinus
A prickly BTreeMap. You can insert through shared references and values are pin-projected.
-
qualia
Basic semi-schemaless document store
-
gpt_disk_io
GPT (GUID Partition Table) disk IO no_std library
-
indextreemap
A BTreeMap implementation that allows for key and or positional insertion and retreival
-
rolling_norm
Computes the rolling mean, variance, standard derivation and norm
-
rust_examples
rust 的学习中的一些例子
-
qualomat_schema
Rust bindings for the *Qual-O-Mat* open data format for the german voting advice tool *Wahl-O-Mat*
-
multi_containers
Ergonomically work with multiple values per key
-
vec-option
A space optimized version of
Vec<Option<T>>that stores the discriminant seperately -
RustyDSA
A libary for Rust data structure
-
torro
A correct and easy-to-use BitTorrent library
-
sweeper
A foundation for Minesweeper implementations in Rust
-
patricia_router
Radix Tree implementation for 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
-
lr_trie
Left-Right trie is trie capable of mapping any string to any string
-
diskmap
disk based HashMap-like for shared concurrent memory usage
-
Xorfilter
No alloc membership approximation
-
reql-types
Some useful types to use along with the reql crate
-
cervine
A slightly more flexible Cow; roughly to T: Borrow<R> as alloc::borrow::Cow is to B: ToOwned
-
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…
-
arena64
A concurrent arena providing mutually exclusive access over indexes
-
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
-
nvpair-rs
Safe and rustic wrapper around nvpair
-
lazy-seq
constructing lazily evaluated sequences
-
mkargs
Build command arguments
-
buffer-trigger
A data collection trigger based on the maximum number and refresh time
-
int-vec-2d
Vectors, points, rectangles, etc. with
i16coordinates. -
deltastruct
Allows defining deltas for tagged structs for later application
-
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
-
epoch-timestamp
Boilerplate collection for epoch timestamping
-
append-only
Append only versions of std data structures
-
simple-sds-sbwt
A fork of simple-sds used in the sbwt crate
-
hdrhistogram
A port of HdrHistogram to Rust
-
rdf-reader
RDF.rs
-
large_int
An ease-of-use unbounded signed integer
-
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
-
type-freak
Collection of typed data structures, trait operators and aliases
-
isomorphism
2 directional hashmaps
-
boxing
cross-platform implementations for NaN and ptr boxes
-
index-from-end
Allow indexing arrays and Vecs from the end using expressions like array[Len-1]
-
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
-
vec-entries
Entry API for iterating over and removing elements from a
Vec -
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
-
ostr
Owned str
-
corresponding
Move corresponding fields between structs
-
processing_chain
set up processing chains of large amounts of data
-
collect-me
Additional collections not included in the Rust standard library
-
dynsequence
Sequence-Like data-structure for storing dynamically sized types
-
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
-
moka-cht
Lock-free resizeable concurrent hash table
-
mivim
-
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
-
dinvoke_data
Structures and data types definitions for dinvoke
-
literally
Macro literals for members of std::collections
-
optimistic_lock_coupling
A General Lock following paper 'Optimistic Lock Coupling: A Scalable and Efficient General-Purpose Synchronization Method'
-
read-copy-update
locking primitive
-
syntastic
Generic abstract syntax representation
-
synthax
Synthesize syntax with quasiquoting plugins
-
cranelift-entity
Data structures using entity references as mapping keys
-
dyn_vec
A Vec<T: ?Sized>
-
loki-logger
A loki logger for the log facade
-
bitvec_simd
bitvec with SIMD
-
shortlist
An efficient data structure to track the largest items pushed to it
-
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
-
pgdb_to_struct
CLI application to generate Rust struct files from PostgreSQL database tables
-
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
-
variant-set
A set-like data structure for enum variants, allowing you to store at most one value for each variant of an enum
-
designal
Procedural macro for use with futures-signals
-
inditech
A set of technical indicators for time series analysis
-
lxc
Linux Containers API
-
ic-stable-memory
Internet Computer's stable memory collections and tools
-
augurs-core
Core data structures and traits for the augurs time series library
-
hash-rings
Implementations of various hash rings
-
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.
-
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
-
penumbra-sdk-asset
Core asset data structures for Penumbra
-
hdf5-hl-sys
Bindings to HDF5 High Level API
-
libflow
grouping network flow data
-
lim-bit-vec
Limited bit vectors
-
tan-lints
A collection of lints for the Tan Language
-
pure-hfsm
A finite state machine library with a clear separation between the machine definition and its changing state
-
helgoboss-midi
Interfaces, data structures and utilities for dealing with MIDI messages according to the MIDI 1.0 specification
-
puruda
Pure Rust DataFrame
-
ittybitty
An itty bitty bitset to hold your itty bitty bits
-
eirproject/libeir_ir
Erlang ecosystem common IR
-
bosque
A very fast in-place kdtree library
-
construe
Compile-Time Growable Array: Vec & String for const!
-
typed_graph
Staticly typed graph library
-
try-push
A trait for attempting potentially expensive actions
-
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…
-
rotbl
Read Only Table
-
cset
Fine-grained and reversible struct transactions
-
union-find-rs
Disjoint-set forest implementation to support the union-find algorithm in Rust
-
extract_map
A HashMap for memory efficent storage of value types which contain their own keys
-
prometheus-tokio
A collection of tokio runtime metrics for prometheus consumption
-
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
-
object-collection
A collection that can store multiple values of types
-
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
-
incremental-topo
Data structure to maintain an incremental topological ordering over a collection of values
-
ypwt
ypwang's personal toolbox
-
exosphere-core
Core crate for Exosphere
-
rt-lists
Link lib
-
treemap
Squarified Treemap algorithm
-
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"
-
openpgp-keylist
An OpenPGP Keylist data structure
-
char_index
efficient charwise indexing into a string
-
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
-
morton-index
Types and functions for efficiently and easily work with Morton indices
-
hilbert_curve_generator
A WIP Hilbert Space-Filling Curve Coordinate Generator
-
chronoflake
Generate unique IDs based on the Snowflake algorithm
-
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
-
bloomfilter-rust
A bloomfilter implementation in Rust
-
fallback
A helper library to implement fallback mechaism
-
sparse_set
sparse set data structure
-
zotero
Communicate with Zotero API
-
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
-
batbox-approx
Approximate comparison
-
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
-
structo
Data structures made in Rust
-
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
-
sti
STd Improved
-
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
-
smolvec
A lightweight vector implementation with small-vector optimization for rust
-
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
-
treez
A collection of useful data structures
-
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
-
granite
Generic backing storage framework for building data structures
-
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
-
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.
-
nanoset-py
A memory-optimized wrapper for Python sets likely to be empty
-
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
-
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
-
handy
providing handles and handlemaps
-
llist
Lisp-style singly-linked list
-
milvus-sdk-rust
The official Milvus Rust SDK
-
grove
A segment tree library enabling generic user-defined queries and actions on segments of your data
-
ware
middleware chains
-
terees
a collection of tree-like data structures
-
fenny
working with Fenwick trees
-
contextual
deal with data in context
-
crdt
Conflict-free Replicated Data Types for Rust
-
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
-
alloc-checked
Collections that don't panic on alloc failures
-
another-option
option data type; useful when allocations are expensive
-
doublets-decorators
Decorators for doublets
-
diskdata
A catalog of on-disk data structures
-
vivalaakam_seattle_collection
Collection provider
-
isx
Traits for checking certain conditions of values
-
slab_tree
A vec-backed tree structure with tree-specific generational indexes
-
motivation
A collection of motivating messages
-
rs-arboretum
A study in trees
-
ads-rs
(Algorithms and Data Structures) is a set of useful generic production-ready algorithms and data structures
-
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
-
bitworks
meant to provide easy to use bitsets with emphasis on safety
-
gfa-reader
Reading gfa format v1
-
tinyvecdeq
VecDeque-like data structures -
latticequeries
Allows for fast hierarchical queries on Vecs
-
lazyfunctions
A collections of functions for lazy people, or highly efficient programmers
-
kubizone-common
Typed Rust structures for representing partially and fully qualified domain names
-
struct_mapping
Token StructMapping for testing StructMapping implementations
-
rcbytes
Rc version bytes crate
-
once-list2
A single linked list which is backed by
OnceCell. You can append the value to the non-mutableOnceList. -
prototty
Wrapper crate for frontend-independent prototty crates
-
visit_diff
Efficiently finding differences between data structures
-
bloomfx
Bloom filter implementation backed by fxhash
-
symbol-map
Memory-efficient mapping from values to integer identifiers (AKA a lexicon or symbol table), with options for fast bidirectional lookup
-
whistlinoak
Annotated even-arity trees backed by mmaps
-
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
-
hashable_weak
A hashable weak pointer
-
rs-bush
Bush data structure
-
dd_statechart
A Data-Driven implementation of Harel Statecharts designed for high-reliability systems
-
cds
Collection of Optimized Data Structures
-
simple_tables
An easy to use rust crate for creating table structures. Including macros for easily creating these table structures.
-
pi_dirty
Record hierarchy dirty
-
rolling-set
A first in first out set that never grows above a certain size
-
astack
offers a Stack data structure with fixed capacity capable of fast LIFO operations
-
tree-sitter-traversal
Traversal of tree-sitter Trees and any arbitrary tree with a TreeCursor-like interface
-
version-lp
a version struct library for use with version comparing, and wildcard resolving
-
cosmic_undo_2
Undo and redo done the right-way
-
scopegraphs-lib
A port of scopegraphs to Rust
-
phf_macros
Macros to generate types in the phf crate
-
simid
Universally Unique IDentifier (UUID)
-
tinymap
A map structure that stores its data on the stack
-
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
-
the_one
bst crate, created as a project for class
-
willowtree
Lazily evaluated trees
-
sbf
Spatial Bloom Filter, a probabilistic data structure that maps elements of a space to indexed disjoint subsets of that space
-
strawberry_fields
Consume, read, and mutate struct fields with an iterator-like api
-
thin-string
A String with a smaller stack footprint
-
binary_sort_tree
二叉树的new,insert,del,search等方法
-
app_properties
reading application properties from a file
-
undo_2
Undo and redo done the right-way
-
fuzzy_trie
Key-value collection to make fuzzy searches
-
entry_put_ext
Map entry extension for put operations
-
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
-
disjoint-collections
Disjoint-set data structures
-
soa-vec
Vec-like API over a struct of arrays layout
-
Project2
Implementations of red black tree and AVL tree
-
libkv
building data structures atop key-value stores
-
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)
-
debruijn
Tools for DNA sequences: efficient k-mer manipulation, De Bruijn graph construction and compaction and handling of DNA strings
-
non-empty-collections
Non-empty hash-map and hash-set implementations
-
wolf-graph-mermaid
Adds support for generating Mermaid diagrams from wolf-graph graphs
-
list_tools
一个自己研发的Vec<T>
-
rpos
Cursor Manager on Table
-
bitval
For packing booleans in variables using bitwise operations
-
charcoal
Implements tree data structures and interfaces to work with them
-
system-config
storing application properties on disk
-
cursed-collections
Collections that (seem to) break Rust safety
-
rocstr
An immutable fixed capacity stack based generic copy string
-
pathlink
A URL type whose path can also be used as a filesystem path, for Rust
-
ucd-trie
A trie for storing Unicode codepoint sets and maps
-
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
-
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
-
restor
A dynamic resource storage system in rust
-
rustupolis
tuple space data structure in Rust
-
typed_index_collection
Manage collection of objects
-
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
-
into_enum
Rust macro to generate trivial From impls
-
supply-chain-trust-example-crate-000044
The enum
Eitherwith variantsLeftandRightis a general purpose sum type with two cases -
atomic_swapping
An arbitrary type atomic storage with swap operations
-
enum_vec
Efficiently store a vector of enum variants as a packed n-bit vec
-
chtholly
Tree, a data structure originated from CF896C
-
genindex
Generational index library
-
sequence_trie
Trie-like data-structure for storing sequences of values
-
omnitool
A curated respository of algorithms and data structures. The libraries are included as forks of Rust codebases
-
dynprops
Creating and extending objects with typed dynamic properties
-
rblist
A block-based, non-circular double-linked list implementation for Rust
-
leetcode_prelude
Some useful macros and definition for exercising in leetcode
-
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
-
stdng
An enhancement for Rust standard library
-
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)
-
simple-ref-fn
function wrappers that do not require virtual tables
-
watermark
watermarking set for in-order insertions
-
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
-
supply-chain-trust-example-crate-000085
tinyvecprovides 100% safe vec-like data structures -
dmfr-dataset-reader
Reads transitland folder and outputs graph of valid feeds and operators
-
graph_process_manager_core
explore parts of a tree-like or graph-like structure that is not known in advance
-
serde_single_or_vec2
Type which can be deserialized from either a sequence or a single value
-
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
-
arraylist
wrapper built on top of rust vector implementation. Taste like Java Arraylist, and intuitive to use like Python list and JavaScript array.
-
cueue
High performance SPSC circular byte buffer with batch operations
-
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
-
graus-db
A high-performance, thread-safe key-value embedded data store
-
ensure
target state of an object
-
bit-vec_serde
A vector of bits
-
type-erased-table
A column-oriented based raw data storage
-
anat-rs
represent natural numbers as well-founded sets
-
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…
-
non-empty-vec
NonEmptyvector implementation, ensure non-emptiness by construction -
moc
made to create and manipulate HEALPix Multi-Order Coverages maps (MOCs), see https://ivoa.net/documents/MOC/
-
dsalgo
A package for Datastructures and Algorithms
-
swap-queue
A lock-free thread-owned queue whereby tasks are taken by stealers in entirety via buffer swapping
-
tongrams
Tons of N-grams
-
sparse-bin-mat
A sparse implementation of a binary matrix optimized for row operations
-
filetrack
persistent logrotated reading and other useful io things
-
map-to-const
Easily convert HashMap<K, V> to constant [(K, V); N] values
-
abbrev-tree
highly inefficient data structure for text completion
-
generic-cursors
A generic way to mutably traverse acyclic recursive data structures
-
data_nostd
Structures and data types definitions for dinvoke_nostd
-
ctxmap
A collection that can store references of different types and lifetimes
-
advancedresearch-max_tree
maximizer library based on a maximum tree structure
-
fusebox
Mostly safe and sound append-only collection of trait objects
-
simple_bitfield
Create bitfields with the same memory structure as integers using a simple macro
-
staticsort
Implements a macro providing a compile-time quicksort function for arrays of any length, containing any primitive Copy type with a PartialOrd implementation
-
awint_dag
DAG
awintfunctionality -
subset-map
A map where the keys are subsets of an initial set of elements
-
stable_node_set
An ordered set with handles to values
-
arrow-select
Selection kernels for arrow arrays
-
byte_set
Efficient sets of bytes
-
once-list
an append-only per-item list
-
static_merkel_tree
Static Merkel Tree is dedicated for generating Merkle Root and Merkle Proof for a static list of items
-
combinations
give you all the combinations of values in a vec
-
discrete_range_map
DiscreteRangeMap and DiscreteRangeSet, Data Structures for storing non-overlapping discrete intervals based off BTreeMap
-
styc
Typesystem definition SDK
-
identifier
Generate 128 bits id structs easily
-
k2_tree
A space-efficient representation of sparsely populated bit-matrices
-
prefix_dictionary
Data structure similar to a dictionary, but enabling search for prefixes
-
ts_lib
A collection of functions I find useful for my projects
-
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 -
rust-fp-pfds
A Functional Programming Library in Rust, Purely Functional Data Structure
-
standards
A collection of standards for international trade facilitation
-
implhm
Simplified library of collision-handling HashMaps
-
embedded-async-helpers
staticfriendly helpers for async on embedded -
nested
A memory efficient container for nested collections (like
Vec<String>orVec<Vec<T>>) -
json_tables
A structure that eases operations with a local json storage of undetermined items
-
partial_const
way to handle constant and non-constant values in a unified way
-
index_many
A proof of concept for indexing an slice at multiple locations at once
-
penumbra-sdk-keys
Key data structures and core utilities for Penumbra
-
contiguous_collections
collections backed by flat contiguous arrays
-
data_structure_traits
data structure collection traits
-
tbytes
A tiny library for reading and writing typed data into buffers
-
frozen-collections-core
logic for frozen collections
-
vecset
A vector-based sorted map, set and keyed-set implementation
-
aoc-framework-utils
such as data types, algorithms and functions for aoc-framework-rs
-
chunky-vec
A pin safe, append only vector never moves the backing store for an element
-
evillatoro-data-structures
Personal crate of me trying to implement data structures and algorithms in Rust
-
bitstruct
Better Bitfields
-
laizy
stable and thread-safe implementation of a lazy value
-
bst-rs
Recursive & Iterative Binary Search Tree Implementations within Rust
-
okasaki
A collection of peristent datastructures
-
simple-observable
observable pointer for mutable and immutable data
-
vector-map
VecMap<K, V>: a Linear Search with Map API
-
hgg
Approximate nearest neighbor search collection
-
char-list
A persistent string type with the same API as a linked-list of characters
-
sesstype
Multiparty Session Types
-
fairqueue
Spatially distancing fair queue. A kind of queue for sequential round-robin processing.
-
mashmap
A flat HashMap that supports multiple entries per key
-
field-ref
Field reference (like a member pointer to non-static data field in C++) for Rust
-
supply-chain-trust-example-crate-000029
'Small vector' optimization: store up to a small number of items on the stack
-
index-map
A map with automatically generated usizes as keys
-
arc-atomic
atomic pointer to an
Arc -
tree-index
Index a flat-tree
-
handler_map
Map from types to functions that receive them
-
jagged_array
Owned
[[T]]-like 2D array where each row can differ in length -
anti-r
A spatial data structure outperforming r-trees for low numbers of elements
-
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
-
rimu-eval
A data structure template system
-
elaru
Memory safe implementation of LRU cache
-
linked-vector
A hybrid linked list and vector data structure
-
ord-by-set
providing a weakly ordered multi-set with compile-time configurable ordering scheme
-
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
-
num-bigint
Big integer implementation for Rust
-
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
-
bigraph
Different representations with implemented operations on bigraphs
-
byte-sequence
A little marco that creates structs to be used as byte sequences (for ApiKeys, SessionIds and so on)
-
ternary-tree-wasm
A simplified Wasm binding to ternary-tree crate
-
bstree
A Binary Search Tree written in Rust
-
eztd
Quick start Rust
-
board
creating a single vector with coordinate based access, and a few nice functions for easy use
-
espalier
Very simple flattened tree structure
-
artful
Low-memory overhead and high-performance adaptive radix tree
-
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
-
const_std_vec
const std vec
-
list-any
Type erased slices and Vecs
-
courgette
Colour manipulation/conversion library
-
big_enum_set
creating sets of enums with a large number of variants
-
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
-
dyn-slice
&dyn [Trait] implementation, inspired by a Reddit thread
-
ransel
rank/select succinct data structures
-
cbsk_log_rayon
log tool, using tokio as the runtime
-
oxidd-test-utils
Test utilities for OxiDD
-
bndpresbufq
Bounds-preserving, optionally limited, buffer queue
-
rustifact_extra
Extra features for Rustifact
-
rust_fixed_width
that allows for easier manipulation of fixed width files allowing for the ability to name fields and such using specs
-
grouper
generating links between items in a list
-
fixed_heap
A fixed-size heap structure with manually provided stateful comparison function
-
vec-strings
Store any string efficiently in an immutable way
-
arenas
Arena data structure for efficiently adding & removing items with stable IDs
-
priq
Array implementation of the min/max heap
-
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
-
spectacle
Opt-in runtime introspection
-
varset
an any type set of items
-
predicates
boolean-valued predicate functions
-
hyperbitbit
data structure
-
tracker-macros
Macros for the tracker crate
-
cess-sp-core
CESS Storage Proofs - Core parts for proofs of storage
-
monitor-common
Basic data structure and algorithm of linux-monitor tool
-
flats
flattens nested structures into a flat single dimension map
-
foliage
Abstract syntax tree for first-order logic with integer arithmetics
-
multipeek
An adapter to peek at future elements in an iterator without advancing the iterator cursor
-
bit-set-omnitool
A set of bits
-
treeflection
that provides reflection for tree structures
-
anycollections
Rust Vec and HashMap which can contain arbitrary types
-
model
model-based testing for data structures, with linearizability checking
-
benchmark-counters
Light-weight data structures to help with monitoring and benchmarking
-
luka
working with graphs
-
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
-
las
Reads and writes point clouds stored in the ASPRS las file format
-
mutable
keep track of changes in structures
-
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
-
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
-
sum-queue
Queue struct that keeps a fixed number of items by time, not capacity, and allows to get summarized stats of its content
-
linked-syntax-tree
A doubly-linked syntax tree
-
rudac
common data structures and algorithms
-
adts
Common abstract data type traits and implementations
-
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
-
binary-tree-view
A binary tree visualization application built in Rust
-
bfield
B-field datastructure implementation in Rust
-
art
adaptive radix trie
-
fastrie
Sequentialised memory-packed associative tries, buildable at compile time, useful for longest prefix matching
-
ABtree
AVL and Btree for rust
-
pati
Image data structure and format for the Patica editor
-
paged
Read and create read-only paged database files
-
segment-map
A self-balancing binary search tree for mapping discrete, disjoint segments to values
-
hashcons
Hash cons'ing for compact representations of shared, immutable data structures
-
ordered-vecmap
Ordered map and set based on vectors and binary search
-
btreemultimap
A multimap implementation with range support
-
mismatch
abstract mismatching. Useful for error propagation.
-
microcrates-bytes
Types and traits for working with bytes (with no_std support by default)
-
eytzinger
implements the "eytzinger" (aka BFS) array layout
-
ultrametric_matrix_tools
Toolbox that provides functions and data structures to generate and handle ultrametric matrices
-
rdf-writer
RDF.rs
-
equivalence
Trait and derive macro for comparing and hashing types modulo an equivalence relation
-
vec-dimension-shift
N-Dimension shift features for Vec<T>
-
break_array
For breaking array indexing
-
pinned_vec
Vec-like data structure whose elements never move
-
lockfree-cuckoohash
lockfree cuckoo hashmap
-
segmentmap
A collection that maintains insertion order
-
tc-state
TinyChain's general state enum
-
tinystr-raw
Raw string-to-integer conversions for tinystr
-
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
-
bucket_queue
A Bucket Queue data structure that can be used as a Priority Queue
-
trie-alg
Trie implementation
-
type-pools
A data structure to store values of multiple types
-
graphlib_rust
Dagre's Graphlib implementation in Rust
-
ritelinked
HashMap-like containers that hold their key-value pairs in a user controllable order
-
lending-library
A key-value store that loans full ownership of items
-
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
-
dyn_trie
Dynamic trie is trie capable of mapping any T to any string
-
swimmer
Thread-safe object pool type
-
exegraph
no_std execution graph library
-
disjoint_set_forest
A disjoint set data structure implemented using a disjoint set forest
-
treers
Sedgewick's tree maps
-
sequencetree
a new type of collection to store keys and their corresponding values
-
skippable_map
deserialize wrapper around HashMap which skips non-conforming data
-
ringbahn
an experimental safe API for io-uring
-
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
-
ndcopy
Fast N-dimensional array memcpy
-
setting
The styles of all graphics elements
-
uset
set and a map designed for speed, with unsigned integers as keys
-
causal-length
CRDT's based on causal length sets
-
rstructure
A thread-safe data structure library
-
portdiff
Data structure for fast local graph rewriting
-
qt-json
JSON library for QT
-
holium-rs-sdk
Holium Rust SDK
-
mexset
Implementing a set with MEX support
-
fe_data
Data structures for FE
-
binary-search
General binary search implementation
-
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
-
ccl_owning_ref
creating references that carry their owner with them
-
bin-tree
Building Binary Tree
-
blend-bindgen-rs
generated Blender's data structures
-
apint
Arbitrary precision integers library
-
collectivity
Generic collection traits
-
baggie
Container for storing mixed / heterogeneous values in a common structure
-
data-query
Query library that allows for Querying Serializable data using string queries
-
codas-macros
Macros for Codas
-
wolf-graph-dot
Adds support for generating Graphviz DOT files from wolf-graph graphs
-
jirachi
A collision resistant runtime agnostic key-generator
-
extensions
typemap container with FxHashMap
-
array_stump
A data structure mixing dynamic array and sorted set semantics
-
sbbf-rs-safe
Split block bloom filter implementation
-
kserd
Kurt's Self-Explanatory Rust Data
-
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
-
simple_event_bus
A basic, simple event bus in Rust
-
pds
Probabilistic Data Structures efficiently implemented in Rust
-
asdl
Parser for ASDL format. Describes the abstract syntax of compiler intermediate representations and other tree-like data structures
-
eclectic
Experimental collection traits
-
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
-
dequemap
A no_std compatible implementation of the dequemap crate
-
std_collection_traits
Abstraction of operations in std collection types
-
mycelium-bitfield
Structured bitfields, courtesy of Mycelium
-
nibble_vec
Vector data-structure for half-byte values
-
m6coll
Small Smart Collections using prefix m6
-
hashbrown_tstd
port of Google's SwissTable hash map
-
cmp_wrap
Let you compare structes by context
-
chtholly_tree
Rust bindings for Chtholly Tree
-
smallbigint
Big integer types that have a small on-stack representation for small values. Uses num-bigint internally.
-
judy-wrap
Judy arrays FFI mid-level binding
-
fixedbitset-stack
A forked version of FixedBitSet that supports const generics
-
hexarr
working with hexagonal grids
-
competitive-programming-lib
Competitive Programming Library
-
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
-
component_table
Data structure for associating data with entities in an Entity Component System
-
intersection
Find the intersection over a collection of sets; when you need more than the intersection between two sets
-
roaring_bitmap
Roaring bitmap data structure implemented in Rust
-
gauze
Probabilistic set membership filters with a simple interface
-
jsonnlp
JSON-NLP data structure
-
schemes
cache-aware recursion schemes in rust
-
unsized_enum
Unsized enum implementation
-
twodarray
A 2D array library
-
datastreams-rs
DataStreams container
-
cpclib-tokens
cpclib libraries related to assembly tokens. Only structures are provided there. Intelligence is within cpclib-asm
-
rimu-parse
A data structure template system
-
bittree
O(1) find functions in a special data structure called a bit 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
-
free-ranges
An efficient data structure for keeping track of indices which are either free or not
-
pinned-bucket
Mutable container for pinned and immutable items
-
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
-
lockerroom
Readers-writer access to individual cells of your collection!
-
rotbuf
Queue implementation wrapped around the
Bytescrates’ BytesMut data structure -
tinysearch-cuckoofilter
Cuckoo Filter: Practically Better Than Bloom
-
front-vec
Efficiently-prependable Vec and String types
-
composite_types
Compose type definitions in the style of typescript
-
batbox-collection
Collection of identifiable objects
-
cartesian-tree
Construct a Cartesian Tree from a Slice in Linear Time
-
ramp_table
RampTable, a data structure useful for certain specialized situations
-
hirpdag
procedural macros for Hash Consed, Immutable, Reference Counted, Persistent, Directed Acyclic Graph data structures
-
grid_trait
2D and 3D grids with combinators
-
offset
Glorified offsets for arbitrary structures
-
bytes-expand
Types and traits for working with bytes
-
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
-
btree-vec
A growable array (vector) implemented using a B-tree
-
decoded-char
wrapper to keep track of the original byte length of a decoded character in the encoded source file
-
id-pool
Create and recycle integer ids using a ranged pool
-
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
-
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… -
one_way_slot_map
SlotMap with minimal restrictions on Keys and Values
-
hecs
A fast, minimal, and ergonomic entity-component-system library
-
no_vec
modifying sized arrays
-
tournament-kway
k-way merge using a tournament tree
-
simple-canvas
generic 2 dimensional canvas struct
-
backtracking_iterator
generic iterator with an item history, capable of backtracking and forgetting
-
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).
-
mintaka-types
Mintaka Types
-
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
-
typed_id
Make your IDs strongly typed!!
-
go-heap-rs
Golang's heap written in Rust
-
slots
Fixed size data structure with constant-time operations
-
bsp-pathfinding
Runtime path finding using Binary Spatial Partitioning
-
bitint
Integer types that have a logical size measured in bits
-
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
-
url-hash
types that provide secure and stable hash values for Urls
-
cognitive-frames
Managing windows for
cognitive -
truncate-integer
Truncate integers
-
reusable-vec
A Vec wrapper that allows reusing contained values
-
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
-
hopscotch
A FIFO queue for efficiently hopping and skipping between tagged items
-
valet
Stores your objects and gives you a tag to retrieve them later
-
strchunk
Data types for working with UTF-8 text in I/O
-
banyan
Persistent indexable tree data structure
-
hashtree
A Merkle Tree implementation in Rust
-
precedence-net
Create and analyse precedence networks
-
insert_multiple
insert multiple items into a stream in reasonable runtime
-
debounce
Data structures and helpers for debouncing a stream of events: removing duplicate events occurring closely in time
-
polystore
Polymorphic data store
-
sexpr_parser
Generic S-Expression parser
-
range-split
splitting sequences with range parameters
-
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
-
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
-
cumulfreqtable
A Cumulative Frequency Table implemented with a Binary Indexed Tree
-
bpht
A bit-packed hash table implementation using hopscotch hashing for 32-bit keys and values
-
dynamic-matrix
work with matrices
-
iron_rose
Invertable Bloom Filters & Strata Estimators as found in https://www.ics.uci.edu/~eppstein/pubs/EppGooUye-SIGCOMM-11.pdf
-
bitmac
Structure for accessing to single bits
-
forgetful
Track and forget values within a specific scope, enabling detection of repeated values
-
enum-ref
Proc. macro for generating enum discriminant types.
-
algae-rs
A collection of abstract algebraic structures implemented in Rust
-
prototty_storage
Interface to persistent storage
-
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
-
secured_linked_list
A cryptographically secured and provable linked list
-
arrsingh
A top level crate in the workspace
-
intsplit
splitting numeric types into their binary component arrays
-
slotmap-map
Slotmap data structure
-
kaola
A Persistent Delayed Queue in Rust
-
dotreds-binary-heap-plus
Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps. Makes some previously internal function public
-
treena
Tree stored in an arena
-
mind-tree
Organize your thoughts in a tree-like structure
-
unthbuf
Unsigned N-bit Buffer: A structure that holds a fixed buffer of
bits-sized unsigned integer elements -
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
-
dot_tree
Create, query and store binary trees
-
push-while-ref
push while having a reference
-
rust_list
Singly linked list in Rust, with macros for easy instantiation
-
hashmap-entry-ownable
Variation of HashMap::entry() that accepts borrowed forms of keys
-
solana_libra_canonical_serialization
Libra canonical serialization
-
siraph
A node-based digital signal processing crate
-
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
-
hyper-tree-router
Routing middleware for Hyper http library using Prefix tree (trie) for path finding
-
largeint
that supports large integer arithmetic
-
p8n-types
Basic types for representing binary programs
-
arbitrary-int
Modern and lightweight implementation of u2, u3, u4, ..., u127
-
taskforge
Task management shared functions and structures for the taskforge family of tools
-
colony
A fast associative data-structure that chooses its own keys
-
memcell
providing a MemoryCell struct, which stores a current and previous value
-
chunked-bytes
A rope-like non-contiguous buffer for efficient data structure serialization and vectored output
-
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)
-
bloom_filter_plus
rust_bloom_filter
-
db_meta_derive
db-meta-derive is a wrapper around PostgresSOL using tokio-postgres
-
utf8char
that supplies a utf8 encoded char
-
densevec
Map like collection with usize indices that stores values contiguosly
-
more_ranges
Range types not provided in the standard library
-
projected-hash-map
projected HashMap over HashSet
-
array-init-cursor
help keep track of arrays of MaybeUninit
-
stack-array
A data structure for storing and manipulating fixed number of elements of a specific type
-
negatable-set
Wrapper for sets that allows full boolean operations including negation
-
traitgraph
Abstracting over different graph representations
-
spigal
fixed-length ring buffer implementation, intended to be no-frills and easy to use, especially for embedded applications
-
cbsk_unique
unique value generator
-
triskell
A tri-partite ring buffer
-
binartree
Binary Tree realisation
-
inline-str
Efficent and immutable string type, backed by inline-array
-
fsort
sort files in a fast, OS-independent and 'rusty' way
-
kukoo
lockfree cuckoo hashmap
-
indexed_vec
IndexVecfromlibrustc_data_structures -
simple-collection-macros
configurable macros for maps and sets
-
circular_vec
A fixed length vector that provides a next function that loops infinitely
-
dst-container
Containers for DST objects
-
mapro
A tiny macro library for creating std::collections
-
prefix_tree_map
generic prefix tree (trie) map with wildcard capture support
-
leetcode_for_rust
leetcode for rust
-
seg-tree
segment tree library
-
typemap_core
A no_std typemap with trait-based value-presence guarantees (on nightly)
-
fplist
An immutable, persistent, singly-linked list
-
truetree
Trees in Rust
-
zeen_filter
A fast and optimized Bloom Filter implementation in Rust
-
ensured_bufreader
A Bufreader ensures N bytes in buffer
-
aggregate-map
Collect key-values pairs into a mapping from keys to collections of values
-
cbor-tag-index
Tag index
-
data-buffer
low-level data buffer type useful for IO and in homogeneous collections
-
u64_array_bigints
biginteger library based on u64 arrays
-
librualg
Collection of basic algorithms for everyday development
-
bugu
Cuckoo Filter: Practically Better Than Bloom
-
checked
Implements a wrapper over the primitive Rust types that better indicates overflow during arithmetic
-
pasture-derive
Macro implementations for #[derive(PointType)]
-
cons-rs
containing a Cons data structure
-
stringvec
macro for creating Vec<String> from various types
-
collect-once-hashmap
A hashmap that can be collected only when there are unique keys in the iterator
-
fixed-slice-deque
A fixed size deque implementation
-
rdf-query
RDF.rs
-
lazy-array
An array where entries are lazily initialized in any order
-
to-offset
developer-friendly methods to manipulate strings with character indices
-
frbf
robust, and efficient implementation of the Bloom Filter data structure in Rust
-
crdt_rs
work with Conflict-free replicated data types (CRDT) in Rust
-
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"
-
binary-data-schema
Meta language for raw binary serialization
-
ov
a collection of traits that allow you to chain off of anything
-
key-node-list
Doubly-linked list that stores key-node pairs
-
higher-cat
Functors, Applicatives, Monads and other bad ideas
-
tree-graphviz
Generate GraphViz DOT directed trees, based on an arbitrary tree structure
-
trait-map
Rust map for dynamic trait storage and references
-
vlsm-tree
Versioned Log Stream Merkle Tree
-
vec_key_value_pair
A drop-in replacement for std::HashMap and std::HashSet that use Vec on the backend
-
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. -
offset-views
Create and index offset views of arrays, slices, strings, etc
-
xio_base_datatypes
XIO base data structures
-
heapless_topo
no-std topological sort using
heapless -
flat_bit_set
有序、稀疏、节省空间的 bitset，适用于小数据量
-
fixedvec
A heapless version of the Rust vector type
-
batbox-cli
cli interface
-
blobary
place for blobs
-
bitrush-index
A serializable bitmap index library able to index millions values/sec on a single thread
-
twie
fast and compact prefix tries
-
bidirectional-map
A two-way map data structure for small keys and values
-
ppar
Persistent immutable array
-
dynamic-list
A powerful and efficient implementation of dynamic lists with versatile data structures, capable of storing any type!
-
fricgan
performing basic input and output on bytes
-
graff
manipulating graphs
-
wasmflow-interface
Types used by the Wasmflow tool chain
-
fera
An aggregation of algorithms, data structures and supporting crates
-
fieldfilter
trait that lets you filter stuff!
-
owned_chunks
a collection of traits and iterators to get owned chunks from collections
-
fp-collections
An alternate collections library for rust
-
aligned-utils
Common utilities to work with aligned values and allocation
-
supply-chain-trust-example-crate-000097
generate and parse UUIDs
-
set-trie
A trie for fast subset and superset queries
-
dastral
Reduce boilerplate code, learn data structures & algorithms with Dastral
-
dotwalk
Traits to traverse structures and generate DOT graphs
-
calcit_fingertrees
(Calcit fork of )Immutable persisten
fingertrees -
kermit-algos
Algorithms used in Kermit
-
cdl-list-rs
A circular doubly linked list implementation using Rc<T> and RefCell<T>
-
xtree
general purpose tree data structure
-
hash-trie
Hash Array Mapped Trie (HAMT) Immutable Set Implementation
-
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…
-
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
-
disjoint-hash-set
A disjoint set / union-find data structure suitable for incremental tracking of connected component identified by their hash
-
lazy-cogs
Lazy Cogs is a implementation of lazy clonable data structures
-
loro-preload
Loro internal lib for loading data
-
sqlite-collections
Rust collection types backed by sqlite database files
-
tinyvec_string
tinyvec based string types
-
hedel-rs
A Hierarchical Doubly Linked List
-
aabb-quadtree
A quadtree that maps bounding-boxes to elements
-
bytes-quilt
data structure for tracking random-access writes to a buffer
-
solomondb
An embedded and distributed Gremlin-compatible graph database
-
ux
Implement the following non standard integers: u2, u3, u4, u5, u6, u7, u9, u10, u11, u12, u13, u14, u15, u17, u18, u19, u20, u21, u22, u23, u24, u25, u26, u27, u28, u29, u30, u31, u33…
-
lz_diet
An AVL balanced Discrete Interval Encoding Tree
-
batbox-android
Helper crate for android
-
sized-vec
Type level sized vectors
-
onigiri
handling chars
-
triemap
Triemaps for Rust
-
ttm-rs
CLI to turn tuples into adjacency matrices
-
wrapped_slab
WrappedSlab: Auto-generate newtype idiom based on a Slab
-
pretree
package for storing and querying routing rules with prefix tree. Pretree 是一个用于存储和查询路由规则的包。它用前缀树存储路由规则，支持包含变量的路由。
-
rust-bloomfilter
bloom filter implementation in Rust programming language
-
lookups
Improve the data retrieval operations for collections
-
id-set
A bitset implementation that stores data on the stack for small sizes
-
treelike
A trait to abstract over trees, and simplify implementing them, all in one handy crate
-
copy-range
core::ops::Range et al, but Copy and IntoIterator
-
tree-cursor
non-intrusive tree cursor that supports node mutation without Cell/RefCell
-
collect
An experimental extension of std::collections
-
biheap
A heap group that supports efficient removal of extreme elements
-
head
Common types with inline headers, such as HeaderVec for Vec
-
outils
Graph and tree data structure library. Providing utilities which aren't easily available in Rust.
-
variant-map
defines maps to store variants of enums
-
nave
Thinking about the construction of distributed systems starting from the *consistent hash* algorithm
-
read-write-pipe
A trait for objects implementing Write, to write all content from a Read object
-
streamhist
streaming histogram
-
fast_collections
noheap zero copy collections
-
grafite
Range Filter
-
arrav
Sentinel-based heapless vector
-
fusefilter
No alloc membership approximation
-
hat_trie
A hat-trie implementation that support prefix match iteration
-
packbytes
Convert structures to and from packed representavises - byte arrays of fixed size that live on stack
-
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
-
map_ext
Extensions to std::collections::HashMap and std::collections::BTreeMap
-
prust_core
encoding/decoding PUS-C packet data structures with ease
-
flat-multimap
A multimap and multiset implementation using a flattened hash table
-
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
-
bloomy
Bloom filter using only two hash functions
-
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.
-
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
-
suffix_trie
Suffix trie for searching
-
bonzai
An abstraction for optimizing the memory layout and pointer aliasing of trees
-
fast_trie_tree
A fast
TrieTreefor multiple data types -
ascii_num
digit to ascii numbers
-
trailer
Store a type with an associated buffer in contiguous memory
-
graphlib
powerful rust library for the graph data-structure
-
hayami
general use symbol table
-
tapestry
Generic 2D grid data structure and utilities
-
ttl-queue
A queue that drops its content after a given amount of time
-
len-trait
Len trait for collectons
-
pui-arena
Generalized Arenas that can be used on
no_std -
bitsetium
One stop shop for all bitset needs
-
ethers-impl-rlp
RLP serialization support for uint and fixed hash
-
shifted_vec
A growable datastructure with positive and negative indexing built on top of
std::vec::Veccalculating the offset automatically -
qt-json-rs
JSON library for QT
-
lhlist
Labeled heterogeneous lists
-
vector2
2D vector library
-
gridd
A generic, dirt-simple, two-dimensional grid
-
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
-
simple_ringbuf
Ringbuf is a speedy lightweight fixed-size infinite-use collection optimized for straightforward single threaded use
-
serde-ordered-collections
Ordered serialization/deserialization serde functionality
-
ident
wrapping types with an immutable identifier and storing/accessing such types in collections
-
bounded-vec-deque
A double-ended queue|ringbuffer with an upper bound on its length
-
dot_json
Tools for dot map representations of serde_json Maps
-
fixed-index-vec
A vector-like data structure whose indices do not change when elements are removed
-
dst
Data structures for DSTs
-
dense_bitset
A variably sized, heap allocated, dense bitset implemented using no
unsafecode -
flat-zip
An iterator adaptor to help traverse two-level collections
-
sets_multisets
API for working with sets and multisets of elements of type usize
-
suggestion_trie
A Radix trie for suggestion search, it allows to search for data indexed by a set of keywords fast
-
slotgraph
Graph implementation built with slotmap and petgraph
-
bet
parsing and evaluating binary expression trees
-
atlas-rb-tree
A textbook implementation of a Red-Black Tree
-
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
-
htmldom_read
HTML reader that parses the code into easy-use tree
-
mvbitfield
Generates types to work with bit-aligned fields
-
gsrs
Generic Self Referencing Struct
-
hodgepodge
enums
-
vortex-alp
Vortex ALP array
-
workit
single-threaded work queueing utility
-
vector-trees
Vector backed B and AVL trees
-
compressed_map
'Static functions': compressed maps with the keys removed
-
prioq
Priority Queue implemented using std::collections::BinaryHeap
-
tranche
Tranches are an alternative to slices
-
rc-slice2
Reference-counted slices with easy subdivision
-
shelves
Storing values referenced by a unique typed index
-
pi_phf_map
phf_map
-
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.
-
unrolled-linked-list
unrolled linked list in rust
-
include-lua
that allows the embedding of a lua source tree into a Rust application binary
-
fremkit
broadcast log
-
rope_rd
A Read/Seek rope implementation
-
easy_strings
Ergonomic, garbage collected strings for Rust
-
delete_if_not
unsafely in-place delete function
-
deqmap
A double-ended queue with optional keys
-
collection_macros
Collection of macros for collections
-
skew-forest
Skew-binary random access lists
-
bloom_filter_plush
rust_bloom_filter
-
cyclic_data_types
Cyclic data types are series of structs, enums, types and functions to create a series of fast data types
-
enum-set
A structure for holding a set of enum variants
-
partial-array
potentially partially-filled arrays
-
static_map
A static hashmap implementation, based on the Round-Robin hashing algorithm found in rustc
-
bfilters
bloom filter implementation in Rust
-
dgrambuf
A fixed capacity ring buffer for datagrams (byte slices)
-
asyncapi
aims to provide data structures that represent the AsyncAPI specification easily deserializable with serde
-
nexum
collection of commonly used data structures
-
repc
APIs to calculate the layout of C types
-
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
-
hamt-rs
A Hash Array Mapped Trie implementation based on the *Ideal Hash Trees* paper by Phil Bagwell
-
bytes_to_type
facilitate byte conversion to specified types using macro generation
-
box-collections
A no_std compatible implementation of the collection crate
-
fast_forward
Quering collections blazing fast
-
mmap_json_file
parse, count, filter JSON files using memory mapped io library
-
rs-bucket-filter
Skips slow scans using cache, bloom filter,
-
simple-octree
octree implementation written in Rust
-
domain-lookup-tree
A tree structure in Rust optimized for looking up domain names, with wildcard support
-
runtime-sized-array
A variable-length array, also called runtime-sized
-
mqf
MQF, Mixed Quotient Filter, is a variant of CQF (Counting Quotient Filter)
-
autocomplete
Auto-complete feature using Trie data structure
-
sbf-blake3
Spatial Bloom Filter, a probabilistic data structure that maps elements of a space to indexed disjoint subsets of that space
-
erased-type-arena
A type-erased allocation arena with proper dropping
-
btree_monstousity
a code port of BTreeMap but with comparator functions
-
vhr_serde
A serde (de)serializer crate for the simplist possible binary format
-
prefix_sum
prefix sum data structure
-
higher_order_point
An experimental higher order data structure for 3D points
-
rbtree-arena
A cache friendly red black tree where nodes live on sequential memory
-
rdf-vocab
RDF.rs
-
any_handle
A thread-safe, type-safe smart pointer that can share, store and downcast a
dyn Any -
unsized-stack
Fast heterogeneous / unsized stack
-
empty-collections
Correct-by-construction empty collections
-
my-stack
stack implementation in Rust
-
graphia
graph data structure
-
b_trees
Implementations for various binary trees including AVL tree
-
tagged-tree
A tree-like data structure where the values are tagged
-
contigious-tree
Write and read tree graphs to and from contigious blocks of memory
-
shared-string
Split a string without another allocation
-
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
-
flowerbloom
fast bloom filter implementation with thorough documentation and tests
-
sortedcontainers
An experimental sorted data structure
-
fibheap
but actually useful Fibonacci Heaps
-
priority-set
A no_std Priority Set
-
transit_model_collection
Manage collection of objects
-
comprehend
Python like list, set and hashmap comprehensions via macros
-
stacking
using a stack datastructure in rust
-
arraylike
trait for using arrays without needing const expressions
-
ropey
A fast and robust text rope for Rust
-
generic-arrayvec
Interop between the arrayvec and generic_array crates
-
btree_network
A generic network (undirected graph) data structure
-
street_index
small utility crate for working with road name / street indexing for cartographic purposes
-
dark-std
asynchronous containers build on tokio. It uses a read-write separation design borrowed from Golang
-
reservoir-buf
Dead simple interning
-
bytes
Types and traits for working with bytes
-
nimrodshn-btree
A persistent copy-on-write B+Tree implementation, designed as an index for a key-value store, inspired by SQLite
-
routee-compass-core
The core routing algorithms and data structures of the RouteE-Compass energy-aware routing engine
-
bloom
Fast Bloom Filter and Counting Bloom Filter implementation
-
pokeapi-model
Data structures for PokéAPI v2
-
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…
-
lilbits
Super fast u8 set (ie bitmap) relying on the assumption that elements are <= 63
-
udgraph
Universal dependency graphs
-
linked_list_c
Safely work with c compatible linked lists
-
avl-cont
A contiguous AVL Tree
-
seq
The module 'seq' provides the lightweight, generic sequence container 'Seq' for unmovable data and is embedded into the program during compile time
-
enum_from_variant
macro to generate From<T> trait implementations for enum variants, simplifying error conversions and enum mapping
-
compact-map
'Small map' optimization: store up to a small number of key-value pairs on the stack
-
densemap
A collection data structure that is permanently accessible by unique keys and fast iterable
-
neighborgrid
A 2-D grid datastructure with easy to use iterators and adjacent cell methods
-
dyobj
improved version of the ECS pattern
-
freezie
small library that disables mutation for the contained type
-
kermit-ds
Data structures used in Kermit
-
deferred_vector
A deferred vector implementation
-
dashmap-shard
port of Google's SwissTable hash map
-
hitree
Indexable containers for Rust: HiSet and HiMap
-
map-trait
Generic Map trait
-
dynamization
Fast insertion for static containers
-
batbox-range
Helpers for working with ranges
-
simple-bitrange
manipulating bit ranges which is common when working with IC registers
-
erasable
Type-erased thin pointers
-
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.
-
extended-collections
An extension to the collections in the standard library with various data structures
-
store-interval-tree
A balanced unbounded interval-tree in Rust with associated values in the nodes
-
multi-stash
Vector-based arena data structure that reuses vacant slots
-
bytesstr
An immutable reference-counted UTF8 String
-
tadm
A collection of algorithms and data structures wrote out while reading The Algorithm Design Manual book
-
local_vec
fixed-capacity vector allocated on the stack
-
tree-automata
Term Rewriting Systems
-
tsil_cev
LinkedList on Vec
-
flat_enum
Expand nested enum into flattened enum
-
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.
-
json-node
A way to work with JSON as a node tree
-
clampf
Clamped floating-point types
-
atom_table
Assign easy-to-handle typed IDs to large, hard to handle things like strings
-
pq-bincode
A wrapper crate of queue-file for bincode serializable structs
-
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…
-
lightning-containers
A set of lock-free data structures
-
an-rope
an rope for large text documents
-
yagraphc
working with Graph data structures and common algorithms on top of it
-
prust-lib
Persistent & Immutable Data Structures in Rust
-
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.
-
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
-
queueue
Queue-like data structures used in rCore
-
mucell
A cell with the ability to mutate the value through an immutable reference when safe
-
dimension_shiftable_buffer
A dimension shiftable buffer
-
closures
Abstraction for seperating code and state in closures
-
const-vec
Vec-like data structure with immutable push method
-
murmurhash64
MurmurHash2 (64bit version)
-
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
-
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:… -
explicit-discriminant
Macro for enforcing enum discriminants
-
sliced
A segmented vector for iterating over slices
-
retrace
Safe, generic rollback log with predictable latency
-
tierkreis-core
Core implementation for the tierkreis quantum-classical hybrid workflow orchestration tool
-
bucket
Offers a very simple container for any value without mutation
-
fcsd
Front-coding string dictionary
-
pegitan
A bunch of random algorithms library
-
quickphf
Runtime code for static data structures based on the PTHash perfect hash function
-
nom-midi
Parse a simple midi file into data structures using nom
-
final
Wrap a value in a type that does not give out mutable references
-
hashable_rc
Hashable wrappers for reference countings
-
ommui_data
OMMUI data structures
-
data_structures_SD
collection of data structures. In other words a collection of ways to handle your data in your code and/or program.
-
containerof
Macros and traits facilitating the use of intrusive structures in Rust
-
oxc_index
Newtype-style helpers for
Vecandusize -
btree_dag
A generic DAG (undirected graph) data structure
-
hashmap_union
Allows the union and intersection of hashmaps
-
arith
containers with arithmetics
-
rustgym
solutions
-
eitherq
Queue which support two different types
-
hashed
type you can convert any hashable type into and still do equality checks on
-
sixarm_collections
Collections for HashMapToSet and BTreeMapToSet as trait extensions. By SixArm.com.
-
unrecurse
Helper crate for rewriting your recursive code in iterative way
-
prefix-tree
A map and set interfaces using trie data structure
-
tapa-trait-serde
A collection of Tapalogi's reusable crates
-
rimu-ast
A data structure template system
-
queue-rs
queue
-
querable
Quer(y)able data structure implementation
-
another_radix_trie
Rust built radix tree library
-
bitaccess
Macro for efficient and type-checked access to individual bits of a variable
-
gentrix
that adds the Matrix typed using generics that is basically a wrapper around a 2D Vector
-
terms
Tree terms and patterns data structures
-
gavl
A fast implementation for a map and a set using an AVL tree
-
trashmap
A HashMap and HashSet that operate directly on hashes instead of keys, avoiding rehashing
-
smallbytes
= SmallVec + impl BufMut (from the bytes crate)
-
banyan-utils
work with banyan trees
-
altdeque
An alternative deque implementation
-
get-many-mut
Stable polyfill for slice::get_many_mut
-
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
-
fastgraph
Graph abstraction providing a generic interface and powerful parallelized traversals
-
tdb-succinct
succinct data structures used by terminusdb
-
bufferring
Ring buffers for Rust
-
sac
A macro for constructing collections
-
bitstr
contiguous sequence of bits in memory
-
pair_macro
Create types consisting of the same type values such that Pair, Triplet, and so on
-
ngds
Rust bindings for AVFounation
-
leonardo-heap
Heap structure supporting fast in-place partial sorting
-
indexed_bitvec
An indexed bitvector with (hopefully) fast rank and select operations
-
anymap3
A safe and convenient store for one value of each type
-
tampon
Contains SAFE Rust functions, macro and trait to serialize / deserialize data structure and/or object and generate buffer
-
cacaos
Core library for CACAO traits and data structures
-
persistent_rope
An immutable persistent rope data structure
-
hubs
The horribly unsafe buffer structure
-
pi_slotmap_tree
A tree structure implemented by dense memory linked list
-
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
-
sortedlist-rs
A fast sorted list data structure in rust
-
flex-algo
Rust commonly used data structure and algorithms
-
string-err
String error type
-
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…
-
dynamic_graph
graph processing
-
gtrie
Generic trie implementation with a support of different key and value types
-
st_ring_buffer
A fixed-size String implementation using a ring buffer
-
trips
generic triple store written in Rust
-
single_byte_hashmap
HashMap for storing singular bytes as keys
-
dirty
Holds a value with a dirty flag which is set on writes and cleared on clear()
-
golomb-set
A Golomb Coded Set implementation
-
simple_trie
array backed trie
-
moonlight_collections
Collections for Rust
-
uniqueid
Generates a unique hash/identifier for a system given a set of parameters
-
treesome
tree creation, manipulation, traversal and visualization
-
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… -
tyght-map
A static type map implementation
-
svec
Dart-style list in Rust
-
cli_tree
A CLI tool to generate a tree of user defined nodes
-
tag-vec
A vector used for storing tags
-
fixed-queue
no_std, no_alloc, use [T; N]. support
Vec/VecDeque/History -
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
-
to_any
Auto derive ToAny trait for any structure
-
bipbuffer
Simon Cooke's Bip-Buffer
-
grafana-dashboard
grafana import/export data serializable structures
-
static-bytes
Bytes for embedded devices
-
compactmap
Compact Vec-based map that choses assigns IDs for your values on it's own. Very similar to Slab.
-
know_yaml
The Know Framework for Rust
-
digger
A trait for extracting data from recursive data structures
-
recasting
traits for one-to-one recasting of values in data structures
-
doubly-linked-list
double link list
-
staticbitset
A container like std::collections::BitSet but static storage + Copy trait
-
simple-stack
linked list-based implementation of the Stack data type
-
map-of-indexes
A compact key-value map for unique but not dense indexes
-
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)…
-
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
-
pathtree
An immutable tree data structure for fast path operations
-
default-vec
A specialized vector that has a default value
-
dependency-graph
building and resolving dependency graphs
-
stackvector
StackVec: vector-like facade for stack-allocated arrays
-
batching-queue
An Israeli Queue implementation
-
rdf_rs
RDF.rs
-
id-vec
Simplify Graphs in Rust. Introduces IdVec, which automatically creates Ids for each new object, reusing deleted Ids.
-
algo
Algorithms & Data Structure implementations
-
bigsi_rs
A in-memory implementation of a BIGSI-like data structure
-
compressed-sparse-fiber
Compressed sparse fiber implementation for Rust
-
gvec
Very simple implementation of generational indexing for vectors written in 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.
-
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
-
mut-binary-heap
Enhanced version of std::collections::BinaryHeap that supports increase and decrease key, max, min, and custom-order heaps
-
mini-linked-list
A package containing a minimal i32 LinkedList implementation
-
winvec
Windowed Vector (TTL) Collection for Rust
-
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. -
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…
-
iostream
the project is rust io stream.you can easily use it to manipulate files stream and memory stream
-
nanobox
NanoBoxoptimization: store small item on stack and fallback to heap for large item -
init_trait
A small helper trait to simplify the initialisation of 'indexable' data structures
-
trie-generic
A trie with generic content
-
ax_banyan
Persistent indexable tree data structure
-
dogged
Persistent vector, similar to Clojure
-
mitsein
Strongly typed APIs for non-empty collections, slices, and iterators
-
qlrumap
A HashMap with an LRU feature
-
plum
Probabilistic data structures for rust
-
const-arrayvec
A vec-like type backed by an array on the stack
-
pulz-bitset
bitset implementation
-
event-queue
crates.io için bir paket nasıl hazırlanırın ele alındığı öğrenme amaçlı modüldür
-
compacts
compact data structures
-
unempty
Non-empty data structures for Rust
-
c_linked_list
handling NULL-terminated C linked lists
-
linked_lista
LinkedList data structure
-
option_vec
Vec<Option<T>>-like container
-
flexible-string
A stack heap flexible string designed to improve performance
-
small_vec2
Vector on the stack or heap need nightly rustc
-
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 -
indexvec
Simplified copy of rustc's index crate
-
traitgraph-algo
Graph algorithms based on the traitgraph crate
-
shared_bytes
Owned string and byte slices
-
stacked_type_map
Compile time map of any type
-
kermit-iters
Iterators used in Kermit
-
trie_map
A trie with good iterator support backed by a hashmap
-
lineup_rust
queue implementation in Rust. This is a learning and a hobby project and is not intended for production use.
-
serde_fs
[De]serializing data structures as files
-
bitmaptrie
Bitmapped vector trie (mutable, not persistent). Word-size path-cached indexing into essentially a sparse vector. Requires rust-nightly.
-
smol_str
small-string optimized string type with O(1) clone
-
hamt
Purely functional hash array mapped tries
-
sortbuf
Data structure for sorting large numbers of items
-
tree-experiments
Experiments with tree-like data structures
-
blfilter
Bloom filter implementation using farmhash
-
calf-vec
Small copy-on-write arrays, essentially combining
SmallVecandCow -
transiter
An Iterator suitable for navigating recursive structures and DAGs
-
rimu-meta
A data structure template system
-
nopetgraph
Graph data structure library. Provides graph types and graph algorithms.
-
maybe-cell
An UnsafeCell optionally containing a value, with the state externally managed
-
guzzle
A derivable trait for consuming key value pairs into structs
-
vortex-dict
Vortex dictionary array
-
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
pointer-value-pair
A pair of a pointer and a small integer packed into a pointer-sized object
-
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
-
tindex
Vec, slice and bitset with custom index types -
power_map
A map with finite key and fixed size
-
toboggan-kv
abstraction layer over multiple KV stores
-
sorted-list
SortedList data structure which allows mapping an Ord key to multiple distinct PartialEq values
-
traitgraph-tsplib-io
Functions to read and write graphs in TSPLIB format
-
twilio-data
Twilio API data structures
-
vortex-zigzag
Vortex zig zag array
-
lupine
A bloom filter using FX Hash with Kirsch and Mitzenmacher optimization
-
rankmap
rust hash table supporting key ranking
-
graphrepresentations
providing efficient abstract implementations of different graph representations
-
functional_vec
Owning versions of mutable Vec methods
-
inexor-rgf-model-binary
Inexor - Reactive Graph Flow - Model - Binary
-
raw-vec
A Raw utility for managing contiguous heap allocations
-
phf_mac
Compiler plugin for perfect hash function data structures
-
sequence_buffer
Sequence buffer data structure implementation
-
binary_tree_zy
binary tree
-
branchless
Algorithms and data structures designed to maximize performance on superscalar processors
-
trait-based-collection
A trait-based collection library that implement different data structures using the same trait
-
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
-
vortex-datetime-dtype
Vortex datetime extension dtype
-
generic-json
Generic JSON traits
-
any_key
Dynamically typed keys for associative arrays
-
batbox-cmp
Traits & functions related to Ord
-
containers-rs
'Collections' interfaces for describing objects that contain other objects
-
pq-tree
consecutive ones property (C1P) and graph planarity testing
-
static-box
A stack-allocated box that stores trait objects
-
tree_multiset
A tree-based multiset for Rust
-
immutable-map
An immutable ordered map and set based on weight-balanced tree
-
enumap
A HashMap and HashSet like interface for enums backed by an array
-
priority-matrix
A matrix that supports per-row, per-column and whole-matrix maximum key queries
-
littlechestnutgames-trie
A generalized trie implementation for quick prefix searching
-
sif-rtree
immutable, flat R-tree
-
valued
Describe your data in terms of basic data structures. Get serialization and other facilities for free
-
indexed-vector
that implements vector container that can be indexed with specified function
-
const-buffer
A fixed-capacity memory buffer allocated on the stack using const generics
-
bitsets
BitSet implementations: Dense, Compressed, Memory-Mapped, and Roaring
-
faex
A fast and efficient Compact Data Structures Library
-
flashtext
algorithm to search and replace keywords in given text
-
mrslac
sparse matrix data structures
-
dimsum
multi-dimensional array library
-
safer-bytes
safe, non-panicking wrappers around the 'bytes' crate
-
yuuang_petgraph
Graph data structure library. Provides graph types and graph algorithms.
-
intrusive-containers
intrusive data structures
-
butils
shared by software included in BSuccinct
-
capillary
HashMap-like storage of key-value pairs, but allowing for step-by-step (partial) search of value
-
vector_mapp
A Vec based map
-
dynvec
DynVectype that acts like a vector to store any datatype -
sparse-slot
minimal sparse slot (sparse vector)
-
dogma
Dogma.rs
-
blocked-vec
A vector of byte blocks behaving like files
-
rdf-borsh
RDF.rs
-
tuco-core
Contains the Tuco trait, used by the Tuco crate
-
tibitset
bitset replacement for HashSet
-
pi_async_graph
async graph
-
stringz
A way to use strings in generic paramters
-
clouseau
A query language for inspecting Rust data structures at runtime
-
array-ops
Automatic method implementations for array data types
-
slice-deque
A double-ended queue that Deref's into a slice
-
justly
justified containers
-
ring_queue
A double-ended queue implemented using a vector that reuses space after elements are removed
-
packed_str
Store immutable strings in a single packed allocation
-
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
-
immutable-seq
Immutable sequence data structure
-
kvstructs
General basic key-value structs for Key-Value based storages
-
hff-core
Hierarchical File Format: core structure
-
dsll
Fast Thread Safe Doubly Sorted Linked List
-
aximate
core data structures and utilities
-
wl-tools
Wordlist tools – algorithms and data structures for working with lists of words
-
simple-binary-tree
binary tree view representation
-
uvector
access two slices as a single continuous vector
-
freezable
immutable data
-
tobz1000-petgraph
Pseudo-namespaced fork of
petgraph: Graph data structure library. Provides graph types and graph algorithms. -
recursion-schemes
cache-aware stack safe recursion (this is the really haskell brained one)
-
sqa-bounded-spsc-queue
A bounded SPSC queue (temporary version so I can publish sqa-engine)
-
collections-more
Common data structure and algorithms for rust-lang to complete the already excellent std::collections
-
divbuf
Buffer object that can be recursively divided into smaller buffers
-
maybe-string
newtype wrapper that represents a byte vector that may be a valid UTF-8 string
-
string32
A string that is indexed by u32 instead of usize
-
id_cache
A cache data structure which generates sequentially-assigned ids for unique values
-
dynstr
A string implementation optimized for manipulations
-
flit
Bloom filter backed by xxHash
-
lfbs
Lock-free stack with batched pop
-
xdag
DAG(Directed Acyclic Graph) lib
-
fera-graph
Graph data structures and algorithms
-
flattree
A series of functions to map a binary tree to a list
-
xsl-rs
A simple library
-
loaf
Why have a slice when you can have a loaf?
-
lighter
Macro for rewriting string matches as tries
-
hashindexed
A cache. A set which compares elements in a customisable way without overriding the eq() and hash() functions on the type itself.
-
lattice-graph
Set of Lattice(Grid) based Graph Structures
-
datastructures
A variety of data structures for learning purpose
-
low-map
A convenient wrapper around a vector of options
-
xio_instructionset
XIO instructionset data structures
-
stack-buf
Vector-like facade for arrays allocated entirely on the stack
-
graphster
High-performance DataGraph Library
-
holodeque
Array- and slice-backed double-ended queues in 100% safe Rust
-
hashmap_vec
A HashMap with lists a values
-
pyrpds
Python Wrapper for Rust Persistent Data Structures
-
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
-
index-set
An ordered set that stores indices in a sparse bit field
-
intset
Various integer set data structures, each efficient for different operations
-
keyed
Implement comparison traits by specifying a key
-
unstorable
An interface for requiring that a type is only used on the current stack frame
-
elastic-array-plus
Elastic vector backed by fixed size array
-
graphed
implement graph-based functionality
-
gardiz
integer geometry on 2D planes, focused on games
-
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.
-
embedrs-bytes
Types and traits for working with bytes
-
structurray
Easy psuedo-array generation for database optimization
-
quarkrs
A collection of small life improvements for rust
-
flow-graph
A representation of a graph data structure for flow-based programming
-
elu
Traits and implementations for EVAL-LINK-UPDATE data structures
-
prio-queue
priority queue implemented as a heap stored in a Vec
-
velect
A Vec with item / index selection
-
sexpr_matcher
Structural pattern matching macro for S-Expressions and other list-like data structures
-
slice-cell
A
Cell<[T]>-like mutable slice, that allows slice-like APIs -
internode
Smart references to your graph nodes
-
html-types
HTML Data structures
-
csgo-gsi-payload
Data structures for CSGO Game State Integration
-
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…
-
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
-
ethercat-types
Common EtherCAT data structures
-
neurarbor
manipulating tree graphs, for the analysis of neuronal arbors
-
immutable-avl
An Immutable map and set implement for rust based on an AVL tree
-
slicedvec
A segmented vector for iterating over slices
-
binary_search_tree
Binary search tree implementation
-
enum-map-derive
Macros 1.1 implementation of #[derive(Enum)]
-
randsort
A sorting library with an optimal complexity of O(n) (!!) by randomly sorting Vectors until they are sorted
-
rbloom
efficient and minimalistic bloom filter
-
tdf_utils
such as tree
-
arae
Cursed data structures
-
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…
-
u64_array_bigints_core
Core library for
u64_array_bigints -
ringvec
ring buffer implementation based on a vector
-
ninja-files-data
Core data structures for ninja files
-
gtfs-translations
Reads GTFS translations.txt into structures
-
immutable_string
Immutable Single Instance Strings for Rust
-
algods
A collection of data structures and algorithms
-
regex-map
Associative container where the keys are regular expressions
-
graphrs
package for the creation, manipulation and analysis of graphs
-
bloomy-rs
Fast bloom filter implementation
-
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
-
kudzu
concurrent, grow-only data structures
-
cursorvec
Cursored vector container
-
tournament_tree
A tournament tree library
-
sliding_window
A fixed size, heapless sliding window
-
const_queue
A stack-only, no_std queue using const generics
-
poison
writing poisoned types
-
nd-slice
Wrapping
std::slices to represent n-dimensional arrays -
castle_api
Castle API, graph api
-
rs-collections
generic collections (no dependency on std)
-
bitset-fixed
Bitset for DP
-
doubly
linked lists in rust
-
lifetimed-bytes
Bytes, but with attached lifetime
-
history_stack
A collection of containers that support generic history tracking mechanisms
-
labelgraph
graph implementation, allowing random access to nodes via labels
-
easy_graph
Data structure that represent generic vertices and undirected connections
-
heapq
Priority Queue with scoring function
-
texcraft-stdext
Rust data structures and algorithms used in the Texcraft project
-
ketsugou
merges two arrays
-
symbolmap-trait
A trait for generic implementation of symbol tables
-
im-rope
Unicode strings backed by RRB vectors
-
collectables
collections helpers for BTreeMap, BTreeSet, HashMapSet, etc. By SixArm.com.
-
lenses
An optics library loosely inspired by Julien Truffaut's Monocle
-
dag_compute
construction of arbitrary computation DAGs and the expression of dataflow graphs
-
fral
Functional random-access lists
-
simple-graph
Graph library with ability to serialize/deserialize Trivial Graph Format
-
cons-list
An immutable singly-linked list, as seen in basically every functional language
-
handlebox
A map-like collection that reuses unused keys
-
geen
Hashed based Accumulators
-
opt_arrayvec
Vector-like container with fixed capacity, using options instead of stored length
-
tileline
generate SVG block graph
-
gml_parser
A fast and simple Graph Modeling Language (GML) parser
-
bagofholding
collection types. Efficient data structures that look bigger on the inside.
-
btree_graph
A generic graph data structure
-
vortex-proto
Protocol buffer definitions for Vortex types
-
token_deque
A double-ended queue backed by a vector that allows access to interior values