-
hashbrown
A Rust port of Google's SwissTable hash map
-
indexmap
A hash table with consistent order and fast iteration
-
phf
Runtime support for perfect hash function data structures
-
bitvec
Addresses memory by bits, for packed collections and bitfields
-
half
Half-precision floating point f16 and bf16 types for Rust implementing the IEEE 754-2008 standard binary16 and bfloat16 types
-
predicates
An implementation of boolean-valued predicate functions
-
either
The enum
Eitherwith variantsLeftandRightis a general purpose sum type with two cases -
uint
Large fixed-size integer arithmetic
-
priority-queue
A Priority Queue implemented as a heap with a function to efficiently change the priority of an item
-
smallvec
'Small vector' optimization: store up to a small number of items on the stack
-
ndarray
An n-dimensional array for general elements and for numerics. Lightweight array views and slicing; views support chunking and splitting.
-
num
A collection of numeric types and traits for Rust, including bigint, complex, rational, range iterators, generic integers, and more!
-
smartstring
Compact inlined strings
-
enum-map
A map with C-like enum keys represented internally as an array
-
generic-array
Generic types implementing functionality of arrays
-
fraction
Lossless fractions and decimals; drop-in float replacement
-
futures-intrusive
Futures based on intrusive data structures - for std and no-std environments
-
bit-set
A set of bits
-
guppy
Track and query Cargo dependency graphs
-
tinystr
A small ASCII-only bounded length string representation
-
bimap
Bijective maps
-
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
-
zerovec
Zero-copy vector backed by a byte array
-
enumset
A library for creating compact sets of enums
-
crdts
Practical, serializable, thoroughly tested CRDTs
-
amplify
Amplifying Rust language capabilities: multiple generic trait implementations, type wrappers, derive macros
-
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.
-
openapiv3
This crate provides data structures that represent the OpenAPI v3.0.x specification easily deserializable with serde
-
vec1
a std Vec wrapper assuring that it has at least 1 element
-
petgraph
Graph data structure library. Provides graph types and graph algorithms.
-
arrayvec
A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.
-
test-fuzz
To make fuzzing Rust easy
-
rowan
Library for generic lossless syntax trees
-
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
vmm-sys-util
A system utility set
-
tinyvec
tinyvecprovides 100% safe vec-like data structures -
egg
An implementation of egraphs
-
merkle-cbt
A library for generating efficient Merkle tree and combined Merkle proof based on complete binary tree
-
modular-bitfield
Allows to easily define bitfield types with modular building blocks
-
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
-
binary-heap-plus
Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps
-
indextree
Arena based tree structure by using indices instead of reference counted pointers
-
rstar
R*-tree library for the rust ecosystem
-
typed-index-collections
Typed index version of Rust slice and Vec containers
-
elsa
Append-only collections for Rust where borrows to entries can outlive insertions
-
roaring
https://roaringbitmap.org: A better compressed bitset - pure Rust implementation
-
fallible_collections
a crate which adds fallible allocation api to std collections
-
phf_generator
PHF generation logic
-
intrusive-collections
Intrusive collections for Rust (linked list and red-black tree)
-
vsmtp-config
Next-gen MTA. Secured, Faster and Greener
-
kiddo
Performant and ergonomic kd tree library. Generic over number of dimensions, stored items, and axes values. Ideal for geo- and astro- NN queries
-
generator
Stackfull Generator Library in Rust
-
bit-vec
A vector of bits
-
im-rc
Immutable collection datatypes (the fast but not thread safe version)
-
cranelift-entity
Data structures using entity references as mapping keys
-
ringbuffer
A fixed-size circular buffer
-
predicates-tree
Render boolean-valued predicate functions results as a tree
-
patricia_tree
Memory-efficient data structures based on patricia tree
-
deadqueue
Dead simple async queue
-
cita_trie
Modified Patricia Tree (aka Trie)
-
ndarray-stats
Statistical routines for ArrayBase, the n-dimensional array data structure provided by ndarray
-
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…
-
dlv-list
Semi-doubly linked list implemented using a vector
-
indxvec
Vecs sorting, merging, indexing, ranking, searching, reversing, intersecting, printing, etc
-
minidom
A small, simple DOM implementation on top of rxml, targeting the subset of XML useful for XMPP
-
xor_name
Xor Type
-
spade
Delaunay triangulations for the rust ecosystem
-
rust_decimal_macros
Shorthand macros to assist creating Decimal types
-
array-init
Safe wrapper for initializing fixed-size arrays
-
fixedbitset
FixedBitSet is a simple bitset collection
-
intmap
Specialized HashMap for u64 keys
-
bloomfilter
Bloom filter implementation
-
sized-chunks
Efficient sized chunk datatypes
-
git-worktree
A WIP crate of the gitoxide project dedicated implementing everything around working trees and git excludes
-
llvm-ir
LLVM IR in natural Rust data structures
-
phf_codegen
Codegen library for PHF types
-
fixed-map
A fixed map where storage layout is calculated by a procedural macro
-
enum-ordinalize
This crates provides a procedural macro to let enums not only get its variants' ordinal but also be constructed from an ordinal
-
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
-
kstring
Key String: optimized for map keys
-
bitmaps
Fixed size boolean arrays
-
cranelift-bforest
A forest of B+-trees
-
yrs
High performance implementation of the Yjs CRDT
-
array-macro
Array multiple elements constructor syntax
-
im
Immutable collection datatypes
-
arrow-select
Selection kernels for arrow arrays
-
map-macro
Declarative macros for statically initializing collections
-
ux-primitives
Graphics Primitives for Angular Rust
-
leb128
Read and write DWARF's "Little Endian Base 128" (LEB128) variable length integer encoding
-
cool_asserts
A collection of useful testing assertions and utilities
-
light-curve-dmdt
dm-dt maps generator library
-
sorted-iter
Typesafe extensions for sorted iterators, including set and relational operations
-
dbs-device
Device model for Dragonball Sandbox
-
rpds
Persistent data structures with structural sharing
-
weak-table
Weak hash maps and sets
-
queue-file
queue-file is a lightning-fast, transactional, file-based FIFO
-
mphf_benchmark
The program for benchmarking Minimal Perfect Hash Functions
-
index_vec
Newtype-style helpers for
Vecandusize -
oci-spec
Open Container Initiative Specifictions in Rust
-
codespan
Data structures for tracking locations in source code
-
typemap_rev
A hashmap, but stores types as keys
-
tinyset
Size-optimized sets
-
cc-traits
Common collection traits
-
arrow-ord
Ordering kernels for arrow arrays
-
ordered-multimap
Insertion ordered multimap
-
hashbag
An unordered multiset implementation using a hash bag
-
id_tree
A library for creating and modifying Tree structures
-
opentelemetry_api
OpenTelemetry is a metrics collection and distributed tracing framework
-
esaxx-rs
Wrapping around sentencepiece's esaxxx library
-
velcro
Convenience macros for initializing vectors, hash maps and other Rust collections
-
json_dotpath
Dotted path access to nested JSON objects (serde_json::Value)
-
kd-tree
k-dimensional tree
-
intervaltree
A simple and generic implementation of an immutable interval tree
-
array2d
A fixed sized two-dimensional array
-
bounded-vec
Non-empty rust Vec wrapper with type guarantees on lower and upper bounds for items quantity
-
phf_shared
Support code shared by PHF libraries
-
dbs-allocator
a resource allocator for virtual machine manager
-
wide
A crate to help you go wide
-
dachshund
Dachshund is a 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…
-
fixed-macro
Macros for creating fixed-point constants for types in the
fixedcrate -
radix_trie
Generic radix trie data-structure
-
trees
General purpose tree data structures
-
winx
Windows API helper library
-
test-assembler
A set of types for building complex binary streams
-
arrow-string
String kernels for arrow arrays
-
string-interner
Efficient string interner with minimal memory footprint and fast access to the underlying strings
-
guppy-summaries
Build summaries for Cargo, created by guppy
-
vsmtp-common
Next-gen MTA. Secured, Faster and Greener
-
arrow-schema
Defines the logical types for arrow arrays
-
tracker
A macro to track changes on structs
-
keyed_priority_queue
Priority queue that support changing priority or early remove by key
-
jumprope
Simple, fast rope (fancy string) library built on top of Skiplists
-
qp-trie
An idiomatic and fast QP-trie implementation in pure Rust, written with an emphasis on safety
-
mown
Maybe owned values. Wrappers for values that can be either owned or borrowed.
-
rio_api
Common data structures for RDF formats parsers and serializers
-
smallbitvec
A bit vector optimized for size and inline storage
-
vec_map
A simple map based on a vector for small integer keys
-
sqrid
Square coordinates and grid-like arrays, with zero dependencies, in a single file
-
v_frame
Video Frame data structures, originally part of rav1e
-
cryptographic-message-syntax
A pure Rust implementation of Crypographic Message Syntax (RFC 5652)
-
hdf5
Thread-safe Rust bindings for the HDF5 library
-
quantity
Representation of quantites, i.e. of unit valued scalars and arrays.
-
molecule
Rust bindings for molecule
-
starling
This tree structure is a binary merkle tree with branch compression via split indexes
-
hash_hasher
A hasher which is designed to work with already-hashed or hash-like data
-
doku
A framework for documenting Rust data structures
-
rsdict
Fast static rank and select data structure
-
r3bl_rs_utils
Async Redux library, TUI framework, and useful types
-
flatk
Flat layout abstraction toolkit
-
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.
-
btree-slab
A memory compact Slab-based B-tree implementation
-
git-object
Immutable and mutable git objects with decoding and encoding support
-
av-data
Multimedia data structures
-
dbs-address-space
address space manager for virtual machines
-
rc-u8-reader
A tiny implement for reading
u8data from a reference counted instance -
grid
Dynamic generic 2D data structure
-
microkelvin
A crate for tree traversal over annotated data structures
-
frc42_dispatch
Filecoin FRC-0042 calling convention/dispatch support library
-
automerge
A JSON-like data structure (a CRDT) that can be modified concurrently by different users, and merged again automatically
-
value-trait
Traits to deal with JSONesque values
-
vec-collections
Rust collections that are newtype wrappers around smallvec
-
ffi-convert
A collection of utilities to ease conversion between Rust and C-compatible data structures
-
grdf
Generalized RDF graphs and datasets
-
sucds
Succinct data structures in Rust
-
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. -
entity_data
A container for entity component data
-
polars-ops
More operations on polars data structures
-
solvent
Dependency Resolver library
-
spdx-rs
Parse and interact with SPDX Documents
-
bitvec_simd
bitvec with SIMD
-
bittle
Zero-cost bitsets over native Rust types
-
queues
Efficient FIFO Queue data structures
-
leveled-hash-map
A structure to separate values into different levels with keys. Every key-value entry which is not at the top level has a parent key at the superior level. Keys at the same level are unique…
-
idlset
Fast u64 set operations library
-
oxrdf
A library providing basic data structures related to RDF
-
ibuilder
Interactive builder for Rust types
-
tugger-file-manifest
Interact with lists of files through a storage-agnostic interface
-
bitfield-struct
Procedural macro for bitfields
-
xml-builder
Easy and highly-configurable XML builder/writer
-
environmental
Set scope-limited values can can be accessed statically
-
fixed-vec-deque
A fixed-size, zero-allocation circular buffer for Rust
-
ico
A library for encoding/decoding ICO image files
-
imbl
Immutable collection datatypes
-
any_vec
Type erased vector. Most operations can be done without type knowledge. Mostly zero overhead.
-
lambda-runtime-types
Common structures for lambda architecture
-
hypergraph
Hypergraph is data structure library to create a directed hypergraph in which an hyperedge can join any number of vertices
-
log-once
Collection of helper macros for logging some events only once
-
hyperloglogplus
HyperLogLog implementations
-
crash-handler
Allows running of user code during crash events
-
sorted-vec
Create and maintain sorted vectors and vector-backed sets
-
fastbloom-rs
Some fast bloom filter implemented by Rust for Python and Rust!
-
range-set
Smallvec-backed containers of sorted integer ranges
-
sparse-merkle-tree
Sparse merkle tree implement in rust
-
radix-heap
Fast monotone priority queues
-
tl-proto
A collection of traits for working with TL serialization/deserialization
-
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 -
git-pack
Implements git packs and related data structures
-
las
Read and write point clouds stored in the ASPRS las file format
-
bicoro
Bidirectional co-routine data structures
-
lib-sokoban
Sokoban: compact, efficient data structures packed into contiguous byte arrays
-
raphy
A graph data structure library
-
optional
This crate supplies a number of Option-like primitive types
-
list-fn
A generic lazy list
-
dot2
A library for generating Graphviz DOT language files for graphs
-
ritelinked
HashMap-like containers that hold their key-value pairs in a user controllable order
-
wasmedge-types
The common data structures for WasmEdge Rust bindings
-
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.
-
arraystring
Fixed capacity stack based generic string
-
mycelium-bitfield
Structured bitfields, courtesy of Mycelium
-
funspace
N-dimensional function spaces and transforms
-
tree-sitter-stack-graphs
Create stack graphs using tree-sitter parsers
-
vast
Verilog AST library
-
stainless_ffmpeg
Efficient Rust wrapper for FFmpeg
-
brb_membership
BRB Membership: Enables nodes to dynamically join and leave a BRB voting group
-
trie-root
In-memory patricia trie operations
-
sequence_trie
Trie-like data-structure for storing sequences of values
-
iset
Map and set with interval keys (x..y)
-
generational-indextree
Arena based tree structure by using indices instead of reference counted pointers
-
vob
Vector of Bits with Vec-like API and usize backing storage
-
min-max-heap
An efficient, double-ended priority queue
-
awint_ext
Externally allocating
awintfunctionality -
aatree
AATree implementation in Rust
-
python-packaging
Python packaging primitives implemented in Rust
-
buf-list
A list of buffers that implements the bytes::Buf trait
-
rc-writer
A tiny implement for writing data to a reference counted instance
-
awint_dag
DAG
awintfunctionality -
uluru
A simple, fast, LRU cache implementation
-
python-packed-resources
Manage data structures containing Python resources
-
undo
A undo-redo library
-
golomb-coded-set
An implementation of BIP158 Golomb-Coded Set data structure
-
digits
Custom “numeric” incrementor without u64 MAX limit in size. Like a score flipper for a custom character set.
-
zerofrom
ZeroFrom trait for constructing
-
vecdeque-stableix
Deque with stable index values
-
range_bounds_map
This crate provides
RangeBoundsMapandRangeBoundsSet -
msg-store
A fast and light-weight message store designed to work as a priority queue in low hardware equiped devices
-
sentry-contrib-breakpad
Unopinionated crash collection for Sentry reporting purposes
-
json-syntax
Strict JSON parsing and mapping library
-
mset
A mset / multiset / bag implementation
-
growable-bloom-filter
Scalable Bloom Filters with serde support
-
slice-rbtree
A slice-based Red-black tree
-
dary_heap
A d-ary heap
-
simple-grid
A simple 2d-grid structure
-
nstack
Arity 4 stack for the kelvin merkle toolkit
-
canadensis_dsdl_frontend
Compiler front-end for the Cyphal Data Structure Description Language
-
more_collections
Additional collections not found in std::collections
-
peapod
Ultra-compact storage for enums
-
pdatastructs
Simple probabilistic data structures
-
intervallum
Generic interval and interval set library
-
anymap2
A safe and convenient store for one value of each type
-
dicom-object
A high-level API for reading and manipulating DICOM objects
-
flange-flat-tree
A tree that can be expanded by attaching new values to the node without mutability of the old ones
-
cordyceps
Mycelium intrusive data structures
-
nested_containment_list
A data structure for efficiently storing and querying nested intervals
-
plain
A small Rust library that allows users to reinterpret data of certain types safely
-
swift-bridge-ir
Holds the data structures and logic for bridge module parsing and code generation
-
cuckoofilter
Cuckoo Filter: Practically Better Than Bloom
-
petal-clustering
A collection of clustering algorithms
-
fingertrees
Immutable persisten finger trees
-
pfds
Purely Functional Data Structures
-
bigraph
Different representations with implemented operations on bigraphs
-
scalable_cuckoo_filter
A variant of Cuckoo Filter whose size automatically scales as necessary
-
fenwick
Fenwick tree: data structure that efficiently calculates prefix sums in a changing array of numbers
-
bytes-utils
Additional utilities for working with the bytes crate
-
lsmtree
Implements a Sparse Merkle tree for a key-value store. The tree implements the same optimisations specified in the libra whitepaper, to reduce the number of hash operations required per tree operation to O(k)…
-
btree-range-map
B-tree range map implementation
-
smallstr
String-like container based on smallvec
-
libreda-db
Layout and netlist datastructures for chip design
-
fixed_bitmaps
A small crate implementing bitmap functionality around primitive Rust unsigned integers
-
ranged_integers
An integer restricted to a compile-time defined bounds driven by const generics
-
type-rules
A crate to easily constrain a struct
-
mih-rs
Multi-index hashing (MIH) for neighbor searches on binary codes in the Hamming space
-
iso7816-tlv
tools and utilities for handling TLV data as defined in ISO/IEC 7816-4
-
btree-vec
A growable array (vector) implemented using a B-tree
-
binn-ir
An implementation of Binn - https://github.com/liteserver/binn
-
tensorism
Multidimensional arrays with bounds included in the type system
-
multimap
A multimap implementation
-
bv
Bit-vectors and bit-slices
-
frc42_hasher
Filecoin FRC-0042 calling convention method hashing
-
takeable
Container type that allows for temporarily moving out of the container, or permanently moving out and invalidating the container
-
content-tree
An efficient data structure for compacted RLE data
-
im_ternary_tree
Structural sharing ternary tree, i.e. immutable data structure
-
splay_tree
Splay Tree based Data Structures (map, set, heap)
-
tagged-pointer
Platform-independent space-efficient tagged pointers
-
r3bl_rs_utils_core
Helper crate for proc-macro library for reading attributes into structs when implementing custom derives. Use https://crates.io/crates/r3bl_rs_utils in your code.
-
ndarray-ndimage
Multidimensional image processing for ArrayBase, the n-dimensional array data structure provided by ndarray
-
griddle
A HashMap variant that spreads resize load across inserts
-
packedvec
Store vectors of integers efficiently
-
trk-io
TrackVis (*.trk) reader and writer
-
import_map
An implementation of WICG Import Maps specification
-
sodg
Surging Object DiGraph (SODG)
-
traitgraph
Abstracting over different graph representations
-
cds
Collection of Optimized Data Structures
-
lta_models
🚍Models for lta-rs
-
awint
Arbitrary width integers
-
compact-genome
Representation of genomes
-
libmf
Large-scale sparse matrix factorization for Rust
-
sparsevec
Compress vectors using row displacement
-
defaultmap
Provides a HashMap with an automatic default for missing keys
-
cubic_spline
Function that calculates curve points for cubic spline
-
muds
Minimalistic Data Structures and Entity-Component-System Library
-
index_list
A doubly linked list implemented in safe Rust using vector indexes
-
iterable
An iterable library for Rust collection like types
-
misc_utils
A small collection of convenient and utility functions developed for personal use
-
email-format
Email message format (parser and data structure)
-
fast_paths
Fast shortest path calculations on directed graphs made possible by pre-processing the graph using Contraction Hierarchies
-
string
A UTF-8 encoded string with configurable byte storage
-
chronologic
Time constraint reasoning (scheduling...)
-
resiter
Helper crate for handling iterators over result
-
jsonptr
Data structures and logic for resolving, assigning, and deleting by JSON Pointers (RFC 6901)
-
range-collections
Sets and maps of ranges, backed by smallvec
-
stride
A strided slice type
-
extindex
Persisted immutable index
-
staticvec
Implements a fixed-capacity stack-allocated Vec alternative backed by an array, using const generics
-
incremental-topo
Data structure to maintain an incremental topological ordering over a collection of values
-
drying_paint
Implementation of observer pattern for Rust
-
tcgeneric
Generic data types used internally by TinyChain. Unstable.
-
fqdn
FQDN (Fully Qualified Domain Name)
-
cueue
High performance SPSC circular byte buffer with batch operations
-
flex-algo
Rust commonly used data structure and algorithms
-
parallel_vec
A generic contiguous collection of heterogenous values
-
eventio
A collection of event I/O processors for event-processing applications
-
python-objects
rust crate that implements the architecture of the CPython objects. with this crate you can crate a list with any data type from rust
-
disjoint-sets
Three union-find implementations
-
kodiak-taxonomy
A library to manage generic taxonomies supporting unique features
-
helgoboss-midi
Interfaces, data structures and utilities for dealing with MIDI messages according to the MIDI 1.0 specification
-
yyid
Yyid generator (random tokens like UUIDv4, but using all the bits)
-
fr-trie
Fuzzy Radix Trie
-
dbs-boot
Traits and structs for booting sandbox
-
trying
Basic trie crate
-
slice-of-array
Extension traits for casting between slices and slices of arrays. (&[T] <-> &[[T; n]])
-
peace_diff
Diff types for the peace automation framework
-
tree-flat
TreeFlat is the simplest way to build & traverse a pre-order Tree for Rust
-
engineer
The engineer is a master builder!
-
tar-no-std
Library to 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… -
keyvi
Keyvi - the key value index. It is an in-memory FST-based data structure highly optimized for size and lookup performance.
-
elementtree
Parse an XML file into Python elementtree like structure
-
text-document
Text document structure and management
-
memvec
Memory-backed vector, not buffer. Designed for for mmap. Not MemMap, but MemVec!
-
fuzzy_trie
Key-value collection to make fuzzy searches
-
rust_cascade
A simple bloom filter cascade implementation in Rust
-
sparseset
A Sparse Set
-
enumoid
Enum Indexed Containers
-
rc-dlist-deque
Doubly-linked list based on std::Rc
-
kdtree-ray
Fast Kdtree implementation for raytracer
-
sharded
Safe, fast, and obvious concurrent collections
-
serde_either
Simple set to enums to deserialize and serialize data that can either be string, struct or vec
-
key-node-list
Doubly-linked list that stores key-node pairs
-
dbs-arch
A collection of CPU architecture specific constants and utilities
-
sophia_inmem
A Rust toolkit for RDF and Linked Data - In-memory Graph and Dataset implementations
-
union-fn
Proc. macro for creating efficient "inline closures".
-
landon
A collection of tools, data structures and methods for exporting Blender data (such as meshes and armatures) and preparing it for your rendering pipeline
-
k2_tree
A space-efficient representation of sparsely populated bit-matrices
-
space
A library providing abstractions for spatial datastructures and search
-
identity-diff
Difftrait to compute and merge data structure differences -
structured
Data structures to handle large, structured data
-
combo_vec
An array that can be resized at runtime but allocated stack space at compile time and doesn't move any data off the stack when it overflows
-
compt
A complete binary tree visitor library
-
todo_lib
Collection of utilities for todo.txt format
-
dyn_size_of
The library to report approximate amount of memory consumed by variables, including the memory allocated on heap
-
avl
A map and a set implemented with an AVL tree
-
gapbuf
Generic gap buffer
-
polytype
A Hindley-Milner polymorphic typing system
-
exponential-decay-histogram
A histogram which exponentially weights in favor of recent values
-
lapce-xi-rope
A generic rope data structure built on top of B-Trees
-
fixed-queue
no_std, no_alloc, use [T; N]. support
Vec/VecDeque/History -
grenad
Tools to sort, merge, write, and read immutable key-value pairs
-
dbs-legacy-devices
dbs-legacy-devices provides emulation for legacy devices
-
compare
Experimental comparators for collections to be generic over
-
windowed-infinity
A data structure representing an infinite sequentially writable u8 vector of which a small view has writes to it preserved. This is primarily useful when implementing CoAP block-wise transfers…
-
atone
A VecDeque and Vec variant that spreads resize load across pushes
-
libnv
Safe and rustic wrapper around libnv-sys
-
higher
Functors, Applicatives, Monads and other bad ideas
-
kg-tree
Generic object tree with Opath query language, similar to XPath
-
tc-value
TinyChain's representation of a value which can be collated and stored
-
circular-queue
A circular buffer-like queue
-
crio
An easy to use persistent data storage library
-
lsph
Learned Spatial HashMap
-
field_accessor
A procedural macro to get and set a struct field by String dynamically
-
ena
Union-find, congruence closure, and other unification code. Based on code from rustc.
-
dia-i18n
ISO 3166-1 and ISO 639 codes
-
fixed-vectors
Library implementing fixed-length Vectors meant for representing dimensional values
-
fast-str
A flexible, easy-to-use, immutable, efficient
Stringreplacement for Rust -
adapton
programming abstractions for general-purpose incremental computations
-
tri-mesh
A triangle mesh data structure including basic operations
-
cw-semver
Parser and evaluator for Cargo's flavor of Semantic Versioning
-
traitgraph-algo
Graph algorithms based on the traitgraph crate
-
skiplist
Skiplist implementation in rust, providing fast insertion and removal. A normal skiplist is implemented, as well as an ordered skiplist and a skipmap.
-
dendron
Generic tree data structure
-
enum-collections
Collections data structures optimized for Enum, initializable at runtime
-
utote
Stack allocated uint multiset, with optional SIMD implementations
-
libes
Collection of Elliptic Curve Integrated Encryption Scheme(s)
-
number-general
A generic number type for Rust which supports basic math and (de)serialization
-
st_ring_buffer
A fixed-size String implementation using a ring buffer
-
prehash
A crate for storing values with precomputed hashes
-
undo_2
Undo and redo done the right-way
-
intervals-rs
A Rust crate for intervals
-
iroh-metrics
Iroh metrics
-
pi_map
Define a Triat: map for the mapped schema, and provide two built-in implementations of HashMap and vecmap
-
ofdb-boundary
Serializable, anemic data structures for accessing the OpenFairDB API in a type-safe manner
-
rtdlib
TDLib for rust
-
safe_index
Type-safe indexes
-
keylist
Elixir keyword list in Rust
-
rle_vec
A vector like struct that stores data as runs of identical values. Useful for storing sparse data.
-
fwdlist
A simply linked (forward) list
-
flat-tree
Rust module for encoding/decoding varints that doesn't do any IO. Inspired by the Node.js varint module
-
point-nd
A simple and flexible no-std struct to model points on axes of any dimensions
-
smallbitset
This crate provides a series of allocation free sets capable of holding small integer values
-
convenient-skiplist
Convenient and Performant SkipList with serde support
-
node-replication
An operation-log based approach that transform single-threaded data structures into concurrent, replicated structures
-
options
The package provides a data structure for managing named parameters
-
slab_tree
A vec-backed tree structure with tree-specific generational indexes
-
sparse_complex
A simple solver for complex sparse matrices
-
ohsl
A collection of numerical routines and mathematical types for use in scientific computing
-
block-grid
A quick, cache-conscious, tiled 2D array
-
toolshed
Arena allocator and a handful of useful data structures
-
array2ds
Simple Package for handling sized 2d arrays in rust, without the usage of the keyword unsafe cuz why not
-
iowrap
Small helpers for using io::Read/io::Write
-
object-collection
A collection that can store multiple values of types
-
corresponding
Move corresponding fields between structs
-
contextual
Utility crate to deal with data in context
-
espalier
Very simple flattened tree structure
-
chargrid_input
Normalized input type for chargrid applications
-
vec-strings
Store any string efficiently in an immutable way
-
colibri
Rust data structures for Jitsi Meet Colibri messages
-
qfilter
Approximate Membership Query Filter (AMQ-Filter) based on the Rank Select Quotient Filter (RSQF)
-
fix_float
Fixed floating types that allows useful trait implementations and datastructures on float numbers
-
fixedvec
A heapless version of the Rust vector type
-
tinyid
A tiny ID type that's like UUID except shorter and easier for a user to type in
-
toodee
A lightweight 2D wrapper around a Vec
-
entity_table
Data structure for associating data with entities in an Entity Component System
-
ego-tree
Vec-backed ID-tree
-
implhm
Simplified library of collision-handling HashMaps
-
write_x86_64
Crate to help you write x86_64 assembly code
-
ndata
A self-owned data structure with an internal heap and garbage collection
-
bitvector
BitVector implementation in Rust
-
traitsequence
Traits to abstract over sequences
-
stronghold-runtime
Data structures for memory protection at runtime
-
gcollections
Generic traits over Rust collections library
-
mc-oblivious-ram
Implementations of Oblivious RAM data structures
-
varlen
Ergonomic variable-length types
-
subranges
Library to manage non-interssecting integer intervals
-
union-fn-macro
Proc. macro implementation for creating efficient "inline closures".
-
afarray
Convenience methods for working with ArrayFire arrays in Rust
-
xsparseset
A rust sparse set
-
yy-typings
A collection of typings for GameMaker Studio 2 YY and YYP files
-
one_way_slot_map
An implementation of SlotMap with minimal restrictions on Keys and Values
-
debruijn
Tools for DNA sequences: efficient k-mer manipulation, De Bruijn graph construction and compaction and handling of DNA strings
-
better_peekable
Create a Peekable structure like Rust's Peekable except allowing for peeking n items ahead
-
daab
DAG aware artifact builder
-
boa_interner
String interner used in Boa
-
anchors
async incremental computations
-
tinybox
Like
Box, but with an optimization that avoids allocations for small data-structures -
rustc-ap-rustc_data_structures
Automatically published version of the package
rustc_data_structuresin the rust-lang/rust repository from commit 9a27044f42ace9eb652781b53f598e25d4e7e918 The publishing script for this crate lives at: https://github… -
rb_tree
A Red Black Tree implementation in Rust
-
array-concat
Macros for concatenating const arrays
-
ndsparse
Sparse structures for N-dimensions
-
gur
A undo-redo framework
-
bfilters
Simple bloom filter implementation in Rust
-
eris-rs
rust implementation of the Encoding for Robust Immutable Storage (ERIS) spec draft
-
densevec
Map like collection with usize indices that stores values contiguosly
-
ref_kind
Different reference kinds
-
tectonic_xetex_format
Tectonic/XeTeX engine data structures and their expression in TeX "format" files
-
traiter
Traits collection
-
shelves
Storing values referenced by a unique typed index
-
markov-generator
Highly customizable crate for building Markov chains and generating data from them
-
bitm
The library for bit and bitmap (bit vector) manipulation
-
unstructured
Generic types for unstructured data
-
forest-ds
Implementation of a secure tree structure
-
sparse-bin-mat
A sparse implementation of a binary matrix optimized for row operations
-
rbitset
A bit set, being able to hold a fixed amount of booleans in an array of integers
-
ansinator_ansi_image
A Library defining specific structures for representing and converting an image in ansi
-
indexmap-nostd
A no_std compatible implementation of the indexmap crate
-
secured_linked_list
A cryptographically secured and provable linked list
-
graphbench
A sparse graph analysis library
-
gtfs-geojson
A simple converter for GTFS to GeoJSON formats
-
sliding_window_alt
A structure that holds the last N items pushed to it
-
once_map
Single assignment and lazy maps
-
slack-blocks
Models + clientside validation for Slack's JSON Block Kit
-
fm-index
FM index and its variant implementations for Rust
-
arc-bytes
A reference-counted byte buffer
-
vecmap-rs
A vector-based map and set implementation
-
minsize
Collections with a statically known minimum size (using const generics)
-
rcbytes
Rc version bytes crate
-
fvm_actor_utils
Utils for authoring native actors for the Filecoin Virtual Machine
-
mdarray
Multidimensional array for Rust
-
docker-compose-types
Deserialization and Serialization of docker-compose.yml files in a relatively strongly typed fashion
-
dmidecode
Decode SMBIOS/DMI information into accessible data structures
-
awint_core
Core no-std and no-alloc
awintfunctionality -
simple-file-manifest
Interact with lists of files through a storage-agnostic interface
-
replicante_util_failure
Helper functions to manage failures
-
hash_histogram
HashHistogram creates histograms with keys of any hashable data type. Features include rank ordering and mode.
-
range_union_find
A union-find data structure for ranges
-
abin
A library for working with binaries and strings. The library tries to avoid heap-allocations / memory-copy whenever possible by automatically choosing a reasonable strategy: stack for…
-
gen_value
A library for indexes and values with generations for vectors
-
spdx-expression
SPDX Expression
-
collection_literals
Easy-to-use macros for initializing std::collections
-
json-number
JSON number parsing and storage
-
processing_chain
Rust library to set up processing chains of large amounts of data
-
bayesic
A string matching library similar to NaiveBayes but optimized for many small classifications
-
ladata
A simple & modular data model
-
lignin
A virtual DOM structure, primarily for web use
-
giga-segy-core
A library containing basic structures for working with SEG-Y
-
nanovec
Arrays and Vec-likes of small integers packed in an integer or two
-
generic-cursors
A generic way to mutably traverse acyclic recursive data structures
-
u64_array_bigints
Simple biginteger library based on u64 arrays
-
slice-ring-buffer
A double-ended queue that Deref's into a slice
-
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.
-
stavec
Stack-allocated vector with static capacity
-
bridgetree
A space-efficient Merkle tree with witnessing of marked leaves, checkpointing & state restoration
-
chargrid_ansi_terminal
chargrid context for ansi terminals
-
kvstructs
General basic key-value structs for Key-Value based storages
-
qbe
QBE IR for Rust
-
rs-snowflake
Rust version of the Twitter snowflake algorithm
-
radixdb
a radix tree data structure for in memory or zero copy on disk storage
-
hirpdag
Library and procedural macros for Hash Consed, Immutable, Reference Counted, Persistent, Directed Acyclic Graph data structures
-
tst
Ternary search trie collection in rust with similar API to std::collections as it possible
-
hkalbasi-rustc-ap-rustc_data_structures
Automatically published version of the package
rustc_data_structuresin the hkalbasi/rust repository from commit 56126fb149ea810db234e210893833e97a5c8e36 The publishing script for this crate lives at: https://github… -
replicante_models_agent
Replicante Agent API request/response models
-
modular-bitfield-impl
Bitfields for structs that allow for modular use of enums
-
fixed-slice-deque
A fixed size deque implementation
-
ssh-agent-lib
A collection of types for writing custom SSH agents
-
delay_map
HashMap collections whose entries expire after a given time
-
roadmap
model a project roadmap as a directed acyclic graph
-
fungus
Rust utilities to reduce code verbosity
-
coca
Data structures with constant capacity
-
modular-bitfield-msb
Allows to easily define bitfield types with modular building blocks. MSB-first version.
-
beam_bvm_interface
A direct interface to the Beam Virtual Machine functions and data structures
-
gaoya
Locality Sensitive Hashing Data Structures
-
dgrambuf
A fixed capacity ring buffer for datagrams (byte slices)
-
id_collections
Index-oriented programming in Rust
-
ph
The library of data structures based on perfect hashing
-
gdl
Graph Definition Language
-
multi_index_map
MultiIndexMap: A generic multi index map inspired by boost multi index containers
-
stack-array
A data structure for storing and manipulating fixed number of elements of a specific type
-
enum-map-derive
Macros 1.1 implementation of #[derive(Enum)]
-
store-interval-tree
A balanced unbounded interval-tree in Rust with associated values in the nodes
-
numeric-array
Wrapper around generic-array that adds efficient numeric trait implementations
-
arraydeque
A ring buffer with a fixed capacity, which can be stored on the stack
-
rudac
A crate for common data structures and algorithms
-
sparql-smith
A SPARQL test cases generator
-
sdsl
A Rust interface for the Succinct Data Structure Library
-
libpaprika
A library to read and generate Paprika recipe files and recipe collections
-
subject-classifier
Library for classifying a commit by it's subject
-
snaplog
A library for easily recording changes to values
-
fid
FID (Fully Indexable Dictionary) implementation for Rust
-
not_empty
Slices and vectors that are statically guaranteed to be not empty
-
merkle
Merkle tree implementation with support for generation of inclusion proofs
-
canadensis_dsdl_parser
Parser for the Cyphal Data Structure Description Language
-
hierarchical_hash_wheel_timer
A low-level timer implementantion using a hierarchical four-level hash wheel with overflow
-
voml-collection
Collections for VOML
-
hextree
Location to value mapping
-
git-hashtable
A crate that provides hashtable based data structures optimized to utilize ObjectId keys
-
phf_macros
Macros to generate types in the phf crate
-
aliasable
Basic aliasable (non unique pointer) types
-
offset
Glorified offsets for arbitrary structures
-
multiset
Multisets/bags
-
chargrid_gamepad
Gamepad handler for chargrid frontends
-
dotreds-binary-heap-plus
Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps. Makes some previously internal function public
-
cursed-collections
Collections that (seem to) break Rust safety
-
elephantry-extras
A collection of additional components for elephantry
-
bpf-ins
A library for working with eBPF instructions
-
dynsequence
Sequence-Like data-structure for storing dynamically sized types
-
banyan
Persistent indexable tree data structure
-
cactus
Immutable parent pointer tree
-
ord-by-set
A library providing a weakly ordered multi-set with compile-time configurable ordering scheme
-
contest-algorithms
Common algorithms and data structures for programming contests
-
variant-rs
VARIANT support for Rust. Clean, idiomatic handling of WinAPI/COM results.
-
probabilistic-collections
Various implementations of collections that use approximations to improve on running time or memory, but introduce a certain amount of error
-
scoped_stack
A scoped stack data structure
-
ternary-tree
A Rust implementation of Ternary Search Trees, with no unsafe blocks
-
map-trait
Generic Map trait
-
c_vec
Structures to wrap C arrays
-
static-files
The library to help automate static resource collection
-
swaybar-types
A library for building swaybar status commands in rust
-
rubbl_visdata
Preliminary work on generic data structures for radio interferometric visibility data
-
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.
-
cacaos
Core library for CACAO traits and data structures
-
dipa
dipa makes it easy to efficiently delta encode large Rust data structures
-
rust_decimal_macro_impls
Shorthand macros to assist creating Decimal types. Do not depend on this directly; use rust_decimal_macros
-
succinct
Succinct data structures for Rust
-
lim-bit-vec
Limited bit vectors
-
quickscope
Multi-layer HashMap and HashSet implementations for performant representation of variable scopes
-
decoded-char
Simple wrapper to keep track of the original byte length of a decoded character in the encoded source file
-
tongrams
Tons of N-grams
-
bitf
This crate provides a procedural macro to easily create a bitfield out of a struct
-
suff_collections
Fast realization of suffix array and suffix tree
-
string-wrapper
A possibly-stack-allocated string with generic bytes storage
-
typed_index_collection
Manage collection of objects
-
fixed_heap
A fixed-size heap structure with manually provided stateful comparison function
-
edit_tree
Edit trees in rust
-
fenny
A library for working with Fenwick trees
-
nibble_vec
Vector data-structure for half-byte values
-
threshold
Threshold data structures
-
trie-generic
A trie with generic content
-
hlist2
Compile-time heterogeneous list implementation
-
heapz
Heap/Priority Queue implementations
-
istio-api-rs
A collection of CRDs for api used in Istio
-
fixed_free_list
A fixed-size free-list with optional key lifetime safety and macroless unique typing
-
sbf
Spatial Bloom Filter, a probabilistic data structure that maps elements of a space to indexed disjoint subsets of that space
-
cervine
A slightly more flexible Cow; roughly to T: Borrow<R> as alloc::borrow::Cow is to B: ToOwned
-
cobalt-async
This library provides a collection of helpful functions for working with async Rust
-
bitlab
Extracting a range of bits from a binary data source
-
entity
Library that provides entity-like constructs
-
chargrid
Text UI component framework
-
altdeque
An alternative deque implementation
-
dbs-utils
helpers and utilities used by dragonball-sandbox components
-
base_custom
Use any characters as your own numeric base and convert to and from decimal
-
xdag
A simple Rust DAG(Directed Acyclic Graph) lib
-
retriever
Retriever is an embedded in-memory data store for rust applications
-
screech
A collection of helpers for handling audio data in real time
-
general_storage
Interface to persistent storage
-
chargrid_web
Web frontend for chargrid
-
vicardi
JSON VCardArray Generator that uses Serde
-
mucell
A cell with the ability to mutate the value through an immutable reference when safe
-
nested
A memory efficient container for nested collections (like
Vec<String>orVec<Vec<T>>) -
rosary
A Library About Rose Trees
-
simple-collection-macros
Simple and configurable macros for maps and sets
-
compact-calendar
Compact representation of a set of days based on a bit-maps
-
hayami
A simple, general use symbol table
-
fastdivide
Fastdivide is a partial port of libdivide. It makes it possible to reduce the cost of divisions.
-
graphlib
Graphlib is a simple and powerful rust library for the graph data-structure
-
retworkx
A python graph library implemented in Rust
-
canadensis_bit_length_set
A bit length set type used to calculate data type sizes when processing Cyphal data structure description language files
-
netlist
generic netlist data structure for VLSI design
-
contack
A simple and easy contact library
-
hashtree
A Merkle Tree implementation in Rust
-
ordsearch
A data structure for efficient lower-bound lookups
-
tappet
Strongly typed wrapper for the official Valve's Steam API
-
array_map
Map backed array for fixed size keys with O(1) performance
-
wownero
Rust Wownero Library
-
rt_ref
Internal
Reftypes forrt_refandrt_vec -
modupipe
A modular and extensible ETL-like pipeline builder
-
libfj
An unofficial collection of APIs used in FreeJam games and mods
-
fusebox
Mostly safe and sound append-only collection of trait objects
-
do-notation
Monadic do syntactic sugar
-
symbol_table
A symbol table that's fast, concurrent, and gives stable references
-
threshold-dict
A data structure to find smallest key that is larger than the query
-
kurobako_solvers
A collection of black-box optimization solvers
-
treez
A collection of useful data structures
-
ttmap
Trivial implementation of type map
-
serde_single_or_vec2
Type which can be deserialized from either a sequence or a single value
-
union-find-rs
Disjoint-set forest implementation to support the union-find algorithm in Rust
-
periodic-rs
Bounded datastructures
-
pathext
A small path trait extension with some convenience methods
-
petitset
An ordered set data structure, optimized for stack-allocated storage of a tiny number of elements with a fixed cap
-
bpf-script
A small scripting language and compiler for creating eBPF programs at runtime
-
memcell
A crate providing a MemoryCell struct, which stores a current and previous value
-
mutable
Mutable is a crate to keep track of changes in structures
-
nombytes
A library that provides a wrapper for the bytes::Bytes byte container for use with nom
-
sortedvec
a sorted vector that enables quick lookups
-
dequemap
A no_std compatible implementation of the dequemap crate
-
yuuang_petgraph
Graph data structure library. Provides graph types and graph algorithms.
-
d3_delaunay_rs
A port of D3/d3-delauany
-
hvec
A Vec-like structure that can store different types of different sizes contiguous with each other in memory
-
coordinates_outliers
A simple outlier detection in 2D paths taken
-
btreelist
A list data structure that has efficient insertion and removal in the middle
-
unsized-vec
Like Vec, but for unsized values
-
succinct_rs
Succinct Data Structures library for Rust
-
iunorm
Map normalized floating-point numbers to/from (un)signed integers
-
unthbuf
Unsigned N-bit Buffer: A structure that holds a fixed buffer of
bits-sized unsigned integer elements -
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!
-
sortedlist-rs
A fast sorted list data structure in rust
-
double-map
A HashMap with double key to single data/value
-
simple-matrix
A simple generic matrix library
-
arraylist
A rust wrapper built on top of rust vector implementation. Taste like Java Arraylist, and intuitive to use like Python list and JavaScript array.
-
hash-rings
Implementations of various hash rings
-
quork
A collection of small things that don't deserve their own crate
-
rustupolis_server
A library for using space tuples in fog computing
-
whistlinoak
Annotated even-arity trees backed by mmaps
-
fns
add common fn, eg: debounce, throttle
-
append-only-bytes
Shareable append-only bytes
-
beetle-collatz
A collection of functions relating to the Collatz conjecture
-
index-ext
Index slices with arbitrary ints and as arrays
-
indexmap-amortized
A hash table with consistent order and fast iteration. The indexmap is a hash table where the iteration order of the key-value pairs is independent of the hash values of the keys. It has the usual…
-
priq
Array implementation of the min/max heap
-
simplegraph
A simple graph implementation
-
simple_event_bus
A basic, simple event bus in Rust
-
fdec
A collection of macros for generating fixed-size fixed-point numeric types for Rust
-
data-view
This library provides a data view for reading and writing data in a byte array
-
tracker-macros
Macros for the tracker crate
-
eitherq
Queue which support two different types
-
path-value
Universal type and access property(s) by path
-
dependency-graph
Library for building and resolving dependency graphs
-
bitstr
BitStr is a contiguous sequence of bits in memory
-
struct_mapping
Token StructMapping for testing StructMapping implementations
-
cbor-tag-index
Tag index
-
bucket_queue
A Bucket Queue data structure that can be used as a Priority Queue
-
minivec
A version of Vec that's only the size of a single pointer
-
csgo-gsi-payload
Data structures for CSGO Game State Integration
-
broxus-util
A collection of utils used at Broxus
-
aligned-vec
Aligned vector and box containers
-
mismatch
Crate for abstract mismatching. Useful for error propagation.
-
replicante_util_upkeep
Controll when a process should exit
-
linked_lists_rs
Implementation of various data structures using linked lists in rust
-
qlrumap
A HashMap with an LRU feature
-
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.
-
luka
Library for working with graphs
-
slice-cell
A
Cell<[T]>-like mutable slice, that allows slice-like APIs -
queue-rs
A Rust crate for queue
-
csc411_rpegio
A collection functions to handle rpeg data i/o. Intended for use in URI's CSC 411 class.
-
generic-arrayvec
Interop between the arrayvec and generic_array crates
-
collidea
Collision-prone memory-efficient collections
-
list-any
Type erased slices and Vecs
-
ndshape
Simple, fast linearization of N-dimensional array indices
-
no_debug
Helper types to omit debug info for select values
-
ctxmap
A collection that can store references of different types and lifetimes
-
secp256k1-zkp-sys
FFI for
libsecp256k1-zkplibrary -
value-box-ffi
Provides C-like api to family of value-box crates
-
bloom
Fast Bloom Filter and Counting Bloom Filter implementation
-
redmaple
RedMaple offers an oppinionated yet extremely flexible data modeling system based on events for backend applications
-
optempty
Tools for working types that may be empty. E.g., an empty
String,Vec,HashMap, etc. -
set_genome
A genetic data structure for neuroevolution algorithms
-
persist-o-vec
A Vec type that aims to have stable indices and memory location
-
trait-based-collection
A trait-based collection library that implement different data structures using the same trait
-
varintrs
A Rust implementation of Golang Variable-Length Integers
-
wavelet-matrix
A wavelet matrix implementation. Supports various near-O(1) queries on large number of symbols or integers.
-
gzbbinarydoc
this is a json like object structure to organize data.supported data types are binary(Vec<u8>),string,i64,f64,null,Vec<self> and hashmap<string,self>. the document can be parsed from and to a vec<u8>.
-
keyed-set
Keyed Set: a hashbrown-based HashSet that indexes based on projections of its elements
-
bitrush-index
A serializable bitmap index library able to index millions values/sec on a single thread
-
ambient-weather-api
A library for accessing the Ambient Weather API
-
slabigator
A linked list that doesn't do dynamic memory allocations
-
ldpc
A toolbox for classical and quantum LDPC codes
-
bevis
Fiat-Shamir without the Hassle
-
prefix_tree_map
A Rust implementation of generic prefix tree (trie) map with wildcard capture support
-
kukoo
A rust implementation of lockfree cuckoo hashmap
-
evento
A collection of libraries and tools that help you build DDD, CQRS, and event sourcing
-
atree
An arena based tree structure with removal support
-
traitgraph-tsplib-io
Functions to read and write graphs in TSPLIB format
-
bitset-core
Straightforward, no-std compatible, simd optimized, BitSet API
-
commitlog
Sequential, disk-backed commit log library
-
hash_ring
Consistent Hashing library for Rust
-
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…
-
modql
Rust implementation for Model Query Language support
-
type-freak
Collection of typed data structures, trait operators and aliases
-
siiir_points
Data structures representing points in 2D & 3D space
-
eventree
A library for creating lossless syntax trees
-
map-of-indexes
A compact key-value map for unique but not dense indexes
-
hdf5-sys
Native bindings to the HDF5 library
-
scratchbuffer
A Vec<u8> like data-structure, that can be used as slices of different types
-
slice_ring_buf
A fast ring buffer implementation optimized for working with slices
-
panoradix
A generic map and a set, both backed by a Radix tree
-
kdtree-simd
K-dimensional tree in Rust for fast geospatial indexing and nearest neighbors lookup
-
loaded_dice
A simple sampler for loaded dices, implementing the alias method
-
grove
A segment tree library enabling generic user-defined queries and actions on segments of your data
-
strchunk
Data types for working with UTF-8 text in I/O
-
traitgraph-dimacs-io
Functions to read and write graphs in DIMACS format
-
nanoset-py
A memory-optimized wrapper for Python sets likely to be empty
-
spdx-toolkit
Toolkit for interacting with SPDX Documents
-
bitmac
Structure for accessing to single bits
-
blend-bindgen-rs
A Rust library to generated Blender's data structures
-
array-box
Create Rust vector from C data, either owned or not owned
-
linked_list_c
Safely work with c compatible linked lists
-
blocked-vec
A vector of byte blocks behaving like files
-
rbtree
the rbtree for Rust
-
stackvector
StackVec: vector-like facade for stack-allocated arrays
-
onigiri
This crate is a tool of handling chars
-
tpntree
A N-dimensional generalization of region quad/oc-trees
-
sparse_table
SparseTable Struct / ST表数据结构
-
fallback
A helper library to implement fallback mechaism
-
whirlybird
whirlybird is a library of generic type implementations for RedMaple library, that offers workflows for different events compatible with common contents like todos, blogs and etc
-
hitree
Indexable containers for Rust: HiSet and HiMap
-
circular-buffer
Efficient, fixed-size, overwriting circular buffer
-
weight-cache
A cache that holds a limited number of key-value-pairs according to a user defined criterion
-
artful
Low-memory overhead and high-performance adaptive radix tree
-
rdf-types
Common RDF types definitions
-
beach_map
Implementation of a slotmap
-
clippet
Provides a teeny way to have some nice byte structures that's easy to use
-
xsd-types
Built-in XSD data types
-
serde_columnar
Easily convert Vector and HashMap structure data into Column-oriented data
-
ioc
An Inversion-of-Control library in Rust
-
dade
dade is data definition for Rust structures
-
lodtree
A simple crate to help create octrees and quadtrees for chunked level of detail
-
austinhellerrepo-common-rust
This library contains all general algorithms and functionality that can easily be shared between my other projects
-
roaring_bitmap
Roaring bitmap data structure implemented in Rust
-
ware
Immutable middleware chains
-
lattice-graph
Set of Lattice(Grid) based Graph Structures
-
sot
Simple Object Tree
-
cryptohelpers
Collection of helpers and simplifying functions for cryptography things
-
swap-queue
A lock-free thread-owned queue whereby tasks are taken by stealers in entirety via buffer swapping
-
yuuang_dominators
null
-
klu-rs
Save bindings to SuiteSparse's KLU sparse matrix solver
-
vk_api
The Vulkan API XML exposed as a byte string constant
-
big_unsigned_ints
A Crate For Big Unsigned Integers ranging from U256 to U2048 using u64 arrays all under a fixed-size of 32
-
mini-rx
bare-bones "reactive programming" (change propogation) using a central data dependency graph
-
spigal
A simple fixed-length ring buffer implementation, intended to be no-frills and easy to use, especially for embedded applications
-
simple-graph
Graph library with ability to serialize/deserialize Trivial Graph Format
-
ahtable
Array Hash Table implementation
-
floating_bar
Representing rational numbers using the floating-bar number type
-
deqmap
A double-ended queue with optional keys
-
bucket_vec
A vector-like data structure that guarantees to never move its contained elements
-
wayrs-protocols
A collection of Wayland protocols to use with wayrs-client
-
hashbrown_tstd
A Rust port of Google's SwissTable hash map
-
parsable
A trait to easily parse data structures
-
robin_merge
A Rust crate for merging vectors round-robin style
-
remus
Modular emulator creation toolkit
-
fcsd
Front-coding string dictionary
-
type-map
Provides a typemap container with FxHashMap
-
num-bigint
Big integer implementation for Rust
-
flat-multimap
A multimap and multiset implementation using a flattened hash table
-
postman_collection
A Postman Collection serialization & deserialization library
-
osm-xml
OSM xml parser for Rust
-
sgf-parse
A parser for the SGF file format for Go games
-
array-matrix
Treats two-dimensional arrays as matrices and introduces matrix operations
-
indexed_vec
IndexVecfromlibrustc_data_structures -
histogram-sampler
Sampling from a distribution given by a histogram
-
vector_mapp
A Vec based map
-
guided_digraph
A data structure for incremental live and dead state detection in an abstract transition system
-
art
adaptive radix trie
-
gentrix
A library that adds the Matrix typed using generics that is basically a wrapper around a 2D Vector
-
cow_vec_item
Copy-on-write Vec, available on stable rust
-
fplist
An immutable, persistent, singly-linked list
-
datastructures
A variety of data structures for learning purpose
-
subset-map
A map where the keys are subsets of an initial set of elements
-
geohash-tools
A collection of functions to manipulate GeoHashes
-
binary-search
General binary search implementation
-
simple-vec-collections
Collections implemented using Vec
-
zang
A test crate which is also a collection of some libraries which I tend to use for hobby projects
-
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.
-
bit_mask_ring_buf
A fast ring buffer implementation with cheap and safe indexing
-
bitmaptrie
Bitmapped vector trie (mutable, not persistent). Word-size path-cached indexing into essentially a sparse vector. Requires rust-nightly.
-
shortlist
An efficient data structure to track the largest items pushed to it
-
rdftk_memgraph
This crate provides an implementation of the Graph traits from rdftk_core::graph for simple in-memory usage
-
gtrie
Generic trie implementation with a support of different key and value types
-
simd_aligned
Safe and fast SIMD-aligned data structures with easy and transparent 'flat' access
-
chronofold
A conflict-free replicated data structure (a.k.a CRDT) for versioned text
-
toolbox-rs
A toolbox of basic data structures and algorithms
-
activation_functions
This is a collection of activation functions
-
conlife
Backend-only implementation of Game of Life with minimal dependencies
-
fed
A sketch implementation of anonymous, tagged unions in stable Rust
-
serde_str_helpers
Helpers for using serde with strings
-
atlv
Algebraic Tag Length Value encoding
-
xi-rope
A generic rope data structure built on top of B-Trees
-
adflib
adflib is a library to handle amiga disk files
-
pepegsitter
Collection of Tree-Sitter parsers
-
rain
Visualize vertical data inside your terminal
-
chargrid_ggez
Graphical chargrid context which renders with ggez
-
try-lazy-init
Fallible lazy initialization
-
character-stream
Helper data structures for reading UTF-8 characters from a stream
-
pinus
A prickly BTreeMap. You can insert through shared references and values are pin-projected.
-
gemstone
collection of utilities
-
graph-algo-ptas
PTAS on planars and other graph classes
-
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.
-
trie
An ordered map and set based on a trie
-
afi
Audio & video structures, plus encoder & decoder traits
-
cw-paginate
Helper function for iterating CosmWasm storage maps with pagination
-
rt_vec
Runtime managed mutable borrowing from a vec
-
sidex
A format- and language-agnostic data structure and API definition language
-
cset
Fine-grained and reversible struct transactions
-
moniker
Automatically derive variable binding and alpha equivalence for abstract syntax trees
-
designal
Procedural macro for use with futures-signals
-
logic-long
Supercell's Logic Long implemented in Rust
-
binary-utils
Binary utilities
-
dists
2d distribution generator
-
twodarray
A 2D array library
-
openfga_common
Common OpenFGA package, contains shared data structures
-
vec-dimension-shift
N-Dimension shift features for Vec<T>
-
simple-ref-fn
Simple function wrappers that do not require virtual tables
-
hyper-tree-router
Routing middleware for Hyper http library using Prefix tree (trie) for path finding
-
pvec
RRB-Tree based persistent vector implementation
-
membuffer
A very fast flat memory buffer used to deserialize at a fast speed
-
id-vec
Simplify Graphs in Rust. Introduces IdVec, which automatically creates Ids for each new object, reusing deleted Ids.
-
intersection
Find the intersection over a collection of sets; when you need more than the intersection between two sets
-
bpht
A bit-packed hash table implementation using hopscotch hashing for 32-bit keys and values
-
galemu
Provides a workaround for generic associated types (GAT) limited to lifetimes (GAL)
-
arc-string-interner
An efficient cuncurrent string interning data structure with minimal memory-footprint and fast access to the underlying contents
-
arenas
Simple Arena data structure for efficiently adding & removing items with stable IDs
-
type-rules-derive
type-rules derive macro
-
tl-scheme
TL language grammar
-
memtable
Inmemory tables for use in Rust
-
seg-tree
A simple segment tree library
-
rusty-priority-queue
A priority queue implementation
-
fxd
Fixed-point decimal implementation
-
hotel
Collection Data-structure to associate values with keys
-
grid2d
Two dimensional grid of runtime-defined, but unchangable size
-
hibitset
Hierarchical bit set structure
-
local_vec
fixed-capacity vector allocated on the stack
-
qptrie
A QP-Trie implementation for Rust
-
shared-string
Split a string without another allocation
-
regex-collection
常用正则表达式合集
-
beap
Bi-parental heap data structure implementation in Rust
-
genmap
A simple generational map data structure with no dependencies
-
varuint
Variable length signed and unsigned integer types
-
ux-dataflow
Data Processing Library
-
trie-standardmap
Standard test map for profiling tries
-
eo
Data structures and methods for Endless Online
-
Xorfilter
No alloc membership approximation
-
awint_macros
Accompanying procedural macros to
awint -
vector-map
VecMap<K, V>: a Linear Search with Map API
-
buffer-trigger
A data collection trigger based on the maximum number and refresh time
-
bidimensional
A collection of 2D utilities for coordinate representation and manipulation
-
collectable
Fallible, no_std-friendly collection traits
-
wasmflow-packet
Rust library encapsulating the message packets sent across Wasmflow components
-
manhattan-tree
A spatial tree which can effiently find closest key to a point, by manhattan distance
-
pl-hlist
Provides support for heterogeneous lists (known as
HLists), which are functional, tuple-like, strongly-typed data structures that can contain elements of differing types -
bluejay-parser
A GraphQL parser
-
embedded-async-helpers
staticfriendly helpers for async on embedded -
makods
The Jostle Tree, a data structure for working with long sequences of variable-width items
-
linked-list
An alternative implementation of std::collections::LinkedList
-
rep
A small tool for representation/class invariants
-
comparator
A Java-like Comparator type
-
mori
An orientation library built around commonly used orientation representations used in crystallography and engineering applications. It contains conversion, rotation, and data analysis…
-
higher_order_functions
A small collection of traits for implementing higher order functions
-
cursorvec
Cursored vector container
-
nested_intervals
nested & overlapping interval set functions, overlap, union, etc
-
bloom_filter_plus
rust_bloom_filter
-
mtgjson
Unofficially provided lightweight models of the data provided by MTGJSON
-
bengbenge
Simple inifity array for round-robin dns, beng, beng
-
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. -
makepad-draw-2d
Makepad 2d drawing API
-
loggs
A simple opinionated logger for Windows and Linux applications
-
simple-observable
Simple observable pointer for mutable and immutable data
-
multipeek
An adapter to peek at future elements in an iterator without advancing the iterator cursor
-
mkargs
Build command arguments
-
bitmap
A dense bitmap
-
serde_single_or_vec
Type which can be deserialized from either a sequence or a single value
-
ffi-toolkit
A collection of functions useful for working with the Rust FFI
-
hit-data
Hierarchical Indexed Typed data structure
-
graphannis-core
This crate supports graph representation and generic query-functionality
-
chargrid_core
Core types for chargrid framework
-
dkg
Distributed key generation over ff/group
-
mango-egui
My egui widgets
-
ternary-tree-wasm
A simplified Wasm binding to ternary-tree crate
-
automap
Simple pattern to implement key-value maps where the value type contains the key type
-
outils
Graph and tree data structure library. Providing utilities which aren't easily available in Rust.
-
rasn-smi
Data types for handling Structure for Management Information
-
imbl-sized-chunks
Efficient sized chunk datatypes
-
dyn_vec
A Vec<T: ?Sized>
-
replicante_logging
Replicante common logging logic
-
indexed
Convenient allocator for index-linked data structures
-
weakheap
Weak Heap data structure implementation in Rust
-
data_structure_traits
data structure collection traits
-
general_storage_file
Implementation of general_storage::Storage backed by files
-
map_vec
The Map and Set APIs backed by Vec
-
flo_rope
An attributed and streaming implementation of the rope data structure
-
bloom2
Fast, compressed 2-level bloom filter and bitmap
-
cycle_map
Implementations of bi-directionally accessible hashmaps
-
watermark
A simple watermarking set for in-order insertions
-
expire
data structure for data maybe expired
-
peace_static_check_macros
Compile time validation macros for the peace automation framework
-
large_int
An ease-of-use unbounded signed integer
-
appendlist
An append-only list that preserves references to its elements
-
staticsort
Implements a macro providing a compile-time quicksort function for arrays of any length, containing any primitive Copy type with a PartialOrd implementation
-
building_blocks_partition
Acceleration structures for spatial queries on voxel data
-
bk-tree
A Rust BK-tree implementation
-
tinystr-raw
Raw string-to-integer conversions for tinystr
-
task-collection
Types for managing and waiting on groups of tasks
-
grid-tree
Pixel quadtrees and voxel octrees
-
radixtree
A radix trie implementation for router, and provides CRUD operations
-
tectonic_bundles
Tectonic "bundle" (support file collection) implementations
-
partial-array
Provides potentially partially-filled arrays
-
apint
Arbitrary precision integers library
-
pokeapi-model
Data structures for PokéAPI v2
-
largeint
A library that supports large integer arithmetic
-
u64_array_bigints_core
Core library for
u64_array_bigints -
divsufsort
Rust port of Yuta Mori's divsufsort
-
indextree-ng
Arena based tree structure by using indices instead of reference counted pointers. Fork of indextree by Sascha Grunert which allows to remove nodes
-
chtholly_tree
Rust bindings for Chtholly Tree
-
fern-masking
Embedded data masking handlers for Fern proxy
-
arbitrary-chunks
An iterator that allows specifying an input array of arbitrary chunk-sizes with which to split a vector or array
-
banyan-utils
Utilities to work with banyan trees
-
board-game-traits
Traits for abstract game position representations
-
ergothic
Rust library for setting up and running distributed Monte-Carlo statistical simulations. Designed primarily for lattice QCD.
-
non-empty-vec
NonEmptyvector implementation, ensure non-emptiness by construction -
chargrid_common
Common utilities for making text UIs with chargrid
-
field-ref
Field reference (like a member pointer to non-static data field in C++) for Rust
-
block-array-cow
In memory array de-duplication, useful for efficient storing of a history of data versions
-
hat_trie
A hat-trie implementation that support prefix match iteration
-
tree-sitter-traversal
Traversal of tree-sitter Trees and any arbitrary tree with a TreeCursor-like interface
-
numas
numas library is implementation of multidimensional array for efficient computing
-
velcro_macros
Procedural macros used by the
velcrocrate. Seevelcrofor documentation. It is not advised to depend on this crate directly; it is an internal dependency ofvelcroand may be subject to breaking changes. -
hash-chain
A tiered hashmap and hashset implementation that allows for easily representing lexically scoped variables
-
aversion
Versioned data structures with auto-upgrading
-
pulz-arena
A generational arena allocator with compact generational indices
-
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"
-
fastgraph
Graph abstraction providing a generic interface and powerful parallelized traversals
-
ppar
Persistent immutable array
-
xtree
A simple general purpose tree data structure
-
fux_kdtree
K-dimensional tree implemented in Rust for fast NN querying
-
flatbuffers-retained
This library 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.
-
permu-rs
A collection of utilities for permutations. It contains useful tools to create, manage and experiment with permutations.
-
segment-tree
Quickly perform interval queries or modifications
-
dst-container
Containers for DST objects
-
msgpack_simple
Simplified, easy to use, pure Rust MessagePack implementation focused on handling dynamic data structures
-
lending-library
A key-value store that loans full ownership of items
-
dlc-trie
Data structures for storage and retrival of numerical Discreet Log Contracts (DLC)
-
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
-
bst-rs
Recursive & Iterative Binary Search Tree Implementations within Rust
-
chainmap
A ChainMap with mutability of intermediate maps
-
static_merkle_tree
Static Merkle Tree is dedicated for generating Merkle Root and Merkle Proof for a static list of items
-
sp-im
Immutable datatypes for no_std use within Substrate
-
dimension_shiftable_buffer
A dimension shiftable buffer
-
setting
The styles of all graphics elements
-
diskmap
disk based HashMap-like for shared concurrent memory usage
-
siraph
A node-based digital signal processing crate
-
bdaddr
Bluetooth Device Address
-
bsp-pathfinding
Runtime path finding using Binary Spatial Partitioning
-
stash
An amortized
O(1)table for cases where you don’t need to choose the keys and want something faster than a HashTable -
tracing-span-tree
Simple tracing subscriber for hierarchical profiling
-
bitaccess
Macro for efficient and type-checked access to individual bits of a variable
-
kserd
Kurt's Self-Explanatory Rust Data
-
sum
General-purpose sum types
-
ident
A utility crate for wrapping types with an immutable identifier and storing/accessing such types in collections
-
influxdb-dispatcher
Batch metrics collection using influxdb
-
finn
An Ikea shark companion for your Rust project
-
rust-bloomfilter
A simple bloom filter implementation in Rust programming language
-
tsil_cev
LinkedList on Vec
-
catvec
Persistent, catenable vectors
-
flag_set
FlagSet can process operations of the infinite complementary sets and the origin sets
-
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 -
offset-views
Create and index offset views of arrays, slices, strings, etc
-
clouseau
A query language for inspecting Rust data structures at runtime
-
mco-gen
Stackfull Generator Library in Rust
-
id_graph_sccs
Find the strongly-connected components of a graph with nodes labeled by integer ids
-
word-dictionary
This crate provides a data structure for word mapping. It can be used for language translation.
-
statiki
Static friendly data structures
-
bonzai
An abstraction for optimizing the memory layout and pointer aliasing of trees
-
stack-buf
Vector-like facade for arrays allocated entirely on the stack
-
identifier
Generate 128 bits id structs easily
-
holyhashmap
A hash map with stable indices
-
bitsvec
A bit vector with the Rust standard library's portable SIMD API
-
vpb
key-value proto buffer for veladb
-
sequencetree
a new type of collection to store keys and their corresponding values
-
error
A fancy error type for highly generic cases
-
scutiger-core
a set of shared functionality for the other Scutiger crates
-
packed_array
Packed Array aka sparse set structure with compile-time known size
-
slots
Fixed size data structure with constant-time operations
-
cartesian-tree
Construct a Cartesian Tree from a Slice in Linear Time
-
patricia_router
Radix Tree implementation for Rust
-
coitrees
A very fast data structure for overlap queries on sets of intervals
-
moka-cht
Lock-free resizeable concurrent hash table
-
indexmap-rmw
A hash table with consistent order and fast iteration. The indexmap is a hash table where the iteration order of the key-value pairs is independent of the hash values of the keys. It has the usual…
-
collectables
Collectables: Rust crate of collections helpers for BTreeMap, BTreeSet, HashMapSet, etc. By SixArm.com.
-
mediumvec
Vector types optimized for space, including a 32-bit Vec
-
fral
Functional random-access lists
-
weak-self
WeakSelf is simple way to have a Weak pointer to yourself
-
stacked_type_map
Compile time map of any type
-
gridly
A library for managing fixed-size 2D spaces
-
ethercat-types
Common EtherCAT data structures
-
bipbuffer
A Rust implementation of Simon Cooke's Bip-Buffer
-
ndstruct
Structures for N-dimensions
-
depot
A (disk) persistent queue library
-
ndcopy
Fast N-dimensional array memcpy
-
chargrid_runtime
Helpers for implementing chargrid frontends
-
pl-lens
Provides support for lenses, which are a mechanism in functional programming for focusing on a part of a complex data structure
-
fixed-map-derive
A fixed map where storage layout is calculated by a procedural macro. This crate contains the procedural macros
-
blender-mesh
Serialize / deserialize Blender armatures
-
compactmap
Compact Vec-based map that choses assigns IDs for your values on it's own. Very similar to Slab.
-
willowtree
Lazily evaluated trees
-
idcontain
Generational (or tagged) ID-based containers
-
pair_macro
Create types consisting of the same type values such that Pair, Triplet, and so on
-
building_blocks_mesh
Fast meshing algorithms for voxel data structures
-
graph_solver
An undirected graph constraint solver for node and edge colors
-
libarena
Arena allocated graph implementation
-
fungi-lang
Fungi: A typed, functional language for programs that name their cached dependency graphs
-
flow_arena
A HashMap managed Graph Model with the concept of ownership
-
elastic-array-plus
Elastic vector backed by fixed size array
-
slabmap
HashMap-like collection that automatically determines the key
-
microcrates-bytes
Types and traits for working with bytes (with no_std support by default)
-
diffus-derive
Finds the difference between two instances of any data structure. Supports derive on structs and enums.
-
slab_typesafe
A wrapper for Slab that provides type-safe tokens instead of usize
-
rbtset
A set based on a RB-Tree for efficient operations
-
thincollections
Alternative implementations for vector, map and set that are faster/smaller for some use cases
-
bigs
A bipartite graph sampler
-
ux-dx
3D Graphics Primitives for Angular Rust
-
apid
Collection of type definitions from several APIs
-
street_index
street_index is a small utility crate for working with road name / street indexing for cartographic purposes
-
guzzle
A derivable trait for consuming key value pairs into structs
-
collect
An experimental extension of std::collections
-
tensorism-gen
Multidimensional arrays with bounds included in the type system
-
ilyvion-util
Collection of utility functions and types for use in my personal projects
-
lz_diet
An AVL balanced Discrete Interval Encoding Tree
-
light-curve-common
Common tools for light-curve-* packages
-
grapes
Persistent graph data structures: Tree, Graph, Arena & more
-
calcit_fingertrees
(Calcit fork of )Immutable persisten
fingertrees -
bounded-vec-deque
A double-ended queue|ringbuffer with an upper bound on its length
-
k8s-openapi-ext
Collection of fluent builder traits for Kubernetes objects
-
key_set
KeySet representing concepts of All, None, Some(list), and AllExceptSome(list), with basic set calculations (intersection, difference, inverse)
-
loaf
Why have a slice when you can have a loaf?
-
no_vec
A library for modifying sized arrays
-
moretypes
Named tuples, records, and more!
-
semver-store
An HashMap structure that uses semver strings as keys
-
appendix
Append-only, on-disk key-value index
-
enum_meta
Add metadata to Enum Variants
-
charcoal
Implements tree data structures and interfaces to work with them
-
prime-data
Prime Number Data Library
-
foreign_vec
Unofficial implementation of Apache Arrow spec in safe Rust
-
unrolled-linked-list
The implementation of the unrolled linked list in rust
-
reference-box
Allows developers to pass non-owned references to Rust-allocated structures over ffi
-
ring_queue
A double-ended queue implemented using a vector that reuses space after elements are removed
-
typed_id
Make your IDs strongly typed!!
-
backtracking_iterator
A simple implementation of a generic iterator with an item history, capable of backtracking and forgetting
-
soa-vec
A simple Vec-like API over a struct of arrays layout
-
index_many
A proof of concept for indexing an slice at multiple locations at once
-
binary_search_tree
Binary search tree implementation
-
atags
Parsing of linux ATAG data structures
-
json-trait-rs
Rust interface (aka trait) to deal with objects as they are JSON objects
-
bravery_router
Radix Tree implementation
-
v9
A slim data engine for Data Oriented Design
-
free-ranges
An efficient data structure for keeping track of indices which are either free or not
-
seq_watcher
A pair of structures for monitoring a stream of data for one or more sequences
-
many-to-many
Rust crate for creating many-to-many data structures with the ability to query either side, useful for applications such as pubsub. Like a fusion between
bimapandmultimap. -
cast-rs
A collection of types cast for Rust
-
core_collections
This is a copy of libstd::collections with all the parts that don't work in core removed. Most importantly, it provides HashMap and HashSet. This crate is (mostly) automatically generated from the rust git source…
-
ast2str-lib
A crate for pretty-printing ASTs and other recursive data structures
-
big_enum_set
A library for creating sets of enums with a large number of variants
-
chunked-bytes
A rope-like non-contiguous buffer for efficient data structure serialization and vectored output
-
bidir-map
Bidirectional map implementation for Rust
-
dsalgo
A package for Datastructures and Algorithms
-
expanding_slice_rb
A self-expanding ring buffer similar to VecDeque optimized for working with slices of data
-
btree_graph
A generic graph data structure
-
version-lp
a version struct library for use with version comparing, and wildcard resolving
-
snake_helper
My personal collection of helper scripts
-
isolation_forest
An implementation of the Isolation Forest anomoly detection algorithm
-
ball-tree
Ball-tree implementation for K-nearest neighbors
-
verify
A validation library
-
dynvec
This crate provides the
DynVectype that acts like a vector to store any datatype -
easy_collections
Wrappers around standard collections for ease of use and quick prototyping
-
generic-json
Generic JSON traits
-
redox_uefi
UEFI support library
-
ensure
Ensure target state of an object
-
accelerate-blas-sys
Apple's vecLib Binding to Rust
-
rust_dna
Common Data Structures and Algorithms
-
fsum
The library to calculate accurate sum of floats
-
osm-tags
OSM Tags Datatype
-
simple_bitfield
Create bitfields with the same memory structure as integers using a simple macro
-
froop
A functional reactive stream library for rust
-
dynstack
A stack for trait objects that minimizes allocations
-
front-vec
Efficiently-prependable Vec and String types
-
sorted_vector_map
maps and sets backed by sorted vectors
-
chargrid_graphical
Graphical chargrid context
-
pareto_front
Builds a Pareto front incrementaly
-
libera
liberating libraries and utilities
-
bvrs
A lightweight rust library for BitVector Rank&Select operations, coupled with a generic Sparse Array implementation
-
isomorphism
2 directional hashmaps
-
dashmap-shard
A Rust port of Google's SwissTable hash map
-
graphsearch
A simple graph search and representation library
-
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)
-
rexsgdata
Scatter-Gather Data Descriptors
-
nopetgraph
Graph data structure library. Provides graph types and graph algorithms.
-
non-empty-collections
Non-empty hash-map and hash-set implementations
-
reso_dd
Structures and Enumerations that implement the Real Estate Standards Organization (RESO) Data Dictionary
-
rustz
A library for functional programming in Rust
-
index-map
A map with automatically generated usizes as keys
-
bitstring
Bitstring traits and implementations
-
rust-freqdist
An implementation of a Frequency Distribution in Rust
-
pin-list
A safe
Pin-based intrusive doubly linked list -
data-buffer
A simple low-level data buffer type useful for IO and in homogeneous collections
-
unempty
Non-empty data structures for Rust
-
ranno
Annotations over recursive data structures
-
mackerel_plugin
Mackerel plugin helper library
-
discord-indexmap
A fork of the popular
indexmaplibrary that adds a few extra APIs that are yet to be upstreamed -
hamster_wheel
Looping code generator that allows for generating code over a collection
-
mergle
A data structure with fast merging and comparison
-
simple_trie
simple array backed trie
-
lfa
Native rust implementations of linear function approximators
-
xio_instructionset
XIO instructionset data structures
-
snake_case
SnakeCase is a String-like type that can only contain valid non-empty snake_case
-
glace
A type-safe, user-friendly proc macro for embedding a file tree into your code
-
byte_trie
A compressed trie based on bytes with some weird child node bucket sizes
-
hashcons
Hash cons'ing for compact representations of shared, immutable data structures
-
graphrepresentations
A crate providing efficient abstract implementations of different graph representations
-
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
-
unique
ptr::Unique for stable Rust
-
modular-bitfield-msb-impl
Bitfields for structs that allow for modular use of enums. MSB-first version.
-
system-config
A library for storing application properties on disk
-
tampon
Contains SAFE Rust functions, macro and trait to serialize / deserialize data structure and/or object and generate buffer
-
validbr
Provides data structure and validation for Brazilian Registries, such as CPF, CNPJ and CNH (currently only CPF and CNPJ is supported)
-
btreemultimap
A multimap implementation with range support
-
virt-sys
Native bindings to the libvirt C library
-
serde_fs
[De]serializing data structures as files
-
inplace-vec-builder
Build a vec from a vec, in place
-
prototty
Wrapper crate for frontend-independent prototty crates
-
btree_network
A generic network (undirected graph) data structure
-
erased_set
A set of erased types
-
checked
Implements a wrapper over the primitive Rust types that better indicates overflow during arithmetic
-
cmp_wrap
Let you compare structes by context
-
rolling_norm
Computes the rolling mean, variance, standard derivation and norm
-
segmentmap
A collection that maintains insertion order
-
collections-more
Common data structure and algorithms for rust-lang to complete the already excellent std::collections
-
c_linked_list
Utilities for handling NULL-terminated C linked lists
-
prototty_unix
Prototty context for unix terminals
-
any-range
AnyRange<T> enum can hold any Range*<T> type
-
eclectic
Experimental collection traits
-
array-const-fn-init
Initializes an array with constant values calculated by a
const fn -
rahashmap
Fork of standard library HashMap with additional functionality
-
hash-trie
Hash Array Mapped Trie (HAMT) Immutable Set Implementation
-
persistent_rope
An immutable persistent rope data structure
-
incr
Simple, fast and self-contained data structures for checking whether a new value is greater than the previous maximum
-
hoop
Fixed ring buffer that allows non-consuming iteration both ways
-
tf2-types
a collection of types for tf2
-
asyncapi
This crate aims to provide data structures that represent the AsyncAPI specification easily deserializable with serde
-
granite
Generic backing storage framework for building data structures
-
artsy
ART Tree data structure library
-
half_edge_mesh
A basic implementation of the half-edge mesh data structure. It has a bunch of the functions you probably want in a half-edge mesh, but probably not all of them. I'm intending to add more methods and mutation techniques…
-
giftbox
A fun Rust crate called
giftboxto help Rustlings learn and explore generics -
hyperbitbit
Implementation of HyperBitBit data structure
-
plum
Probabilistic data structures for rust
-
lumberjack
Read and modify constituency trees
-
darts
A double array trie, A Forward Maximum Matching Searcher
-
alcs
All Longest Common Subsequences and String Fuzzy Search
-
prototty_input
Normalized input type for prototty applications
-
treers
Simple implementation of Sedgewick's tree maps
-
fera
An aggregation of algorithms, data structures and supporting crates
-
modql-macros
Macros for modql. Not intended to be used directly.
-
deltastruct
Allows defining deltas for tagged structs for later application
-
xml-schema
Structure generator from XSD source file
-
cons-list
An immutable singly-linked list, as seen in basically every functional language
-
im-lists
Persistent unrolled linked lists
-
tilecoding
Rust implementation of Dr. Richard S. Sutton's tile coding software.
-
last-git-commit
Simple wrapper arround git2-rs to get info about the last commit. Useful for when you want to show the git hash in a program.
-
const-buffer
A fixed-capacity memory buffer allocated on the stack using const generics
-
lineartree
A simple tree data structure for rust
-
smol-graph
A simple and to-the-point Rust graph implementation
-
art-tree
The Adaptive Radix Tree
-
seximal
A seximal (base6) equivalent of Rust's type system
-
calf-vec
Small copy-on-write arrays, essentially combining
SmallVecandCow -
prototty_file_storage
Implementation of prototty_storage::Storage backed by files
-
msiz_rustc-ap-rustc_data_structures
Automatically published version of the package
rustc_data_structuresin the rust-lang/rust repository from commit 74d5c70b174f06843049af2d764ff57ddc81c81c The publishing script for this crate lives at: https://github… -
package-json
package.json manager for Rust
-
compacts
compact data structures
-
take-some
A simple library that provides a way to obtain *some* value from various collections
-
hamt-rs
A Hash Array Mapped Trie implementation based on the *Ideal Hash Trees* paper by Phil Bagwell
-
std_collection_traits
Abstraction of operations in std collection types
-
default_macro
My default!() macro
-
hgg
Approximate nearest neighbor search collection
-
collection_macros
Collection of macros for collections
-
beehive
Utilities and collections for 3D hexagonal maps
-
lockfree-cuckoohash
A rust implementation of lockfree cuckoo hashmap
-
eytzinger
This crate implements the "eytzinger" (aka BFS) array layout
-
ligature
Ligature is a knowledge graph library written in Rust
-
tf_playlist
The playlist feature used in Tubefeeder
-
monster
Collection of random utilities
-
sharedvec
A fast but limited collection for storing values of a single type
-
iter-group
Library for grouping (key,value) iterators into maps of collections
-
prototty_common
Definition of common ui elements and views for use with prototty
-
recollection
implementations and reimplementations of common data structures and algorithms, and other personally commonly used utilities
-
touch-selection
Selection data structure intended for touch and single button devices
-
sealingslice
A mutable slice that can seal its initial part off from mutability, and hand out the sealed parts as immutable references
-
marked-yaml
A simplified YAML structure with provenance spans
-
sorting-vec
Sorts a vector using a btreemap
-
contigious-tree
Write and read tree graphs to and from contigious blocks of memory
-
labelgraph
A simple to use graph implementation, allowing random access to nodes via labels
-
range-split
Utilities for splitting sequences with range parameters
-
dfb
Dynamic-Fifo-Buffer, like AnyMap but uses a VecDeque to store values and treats access as a Fifo
-
rust_linked_list
implementation of various data structures using linked lists in rust
-
tibitset
TiBitSet is a simple bitset replacement for HashSet
-
model_macro
traits collection
-
pasture-core
A framework for working with point cloud data
-
avlsort
Rust crate of AVL tree holding the rank and the number of duplicates of elements
-
aximate
Aximate core data structures and utilities