-
hashbrown
port of Google's SwissTable hash map
-
bitvec
Addresses memory by bits, for packed collections and bitfields
-
phf
Runtime support for perfect hash function data structures
-
smallvec
'Small vector' optimization: store up to a small number of items on the stack
-
indexmap
A hash table with consistent order and fast iteration
-
half
Half-precision floating point f16 and bf16 types for Rust implementing the IEEE 754-2008 standard binary16 and bfloat16 types
-
num
A collection of numeric types and traits for Rust, including bigint, complex, rational, range iterators, generic integers, and more!
-
ropey
A fast and robust text rope for Rust
-
priority-queue
A Priority Queue implemented as a heap with a function to efficiently change the priority of an item
-
arrayvec
A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.
-
ndarray
An n-dimensional array for general elements and for numerics. Lightweight array views and slicing; views support chunking and splitting.
-
hdrhistogram
A port of HdrHistogram to Rust
-
bit-vec
A vector of bits
-
slotmap
data structure
-
smartstring
Compact inlined strings
-
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
-
roaring
A better compressed bitset - pure Rust implementation
-
bimap
Bijective maps
-
generic-array
Generic types implementing functionality of arrays
-
im
Immutable collection datatypes
-
enum-map
A map with C-like enum keys represented internally as an array
-
hashlink
HashMap-like containers that hold their key-value pairs in a user controllable order
-
fraction
Lossless fractions and decimals; drop-in float replacement
-
crdts
Practical, serializable, thoroughly tested CRDTs
-
zerovec
Zero-copy vector backed by a byte array
-
tinystr
A small ASCII-only bounded length string representation
-
bit-set
A set of bits
-
rpds
Persistent data structures with structural sharing
-
petgraph
Graph data structure library. Provides graph types and graph algorithms.
-
linked-hash-map
A HashMap wrapper that holds key-value pairs in insertion order
-
scroll
A suite of powerful, extensible, generic, endian-aware Read/Write traits for byte buffers
-
bcs
Binary Canonical Serialization (BCS)
-
tinyvec
tinyvec
provides 100% safe vec-like data structures -
generator
Stackfull Generator Library in Rust
-
radix_trie
Generic radix trie data-structure
-
rowan
generic lossless syntax trees
-
frunk
developers with a number of functional programming tools like HList, Coproduct, Generic, LabelledGeneric, Validated, Monoid, Semigroup and friends
-
either
The enum
Either
with variantsLeft
andRight
is a general purpose sum type with two cases -
intrusive-collections
Intrusive collections for Rust (linked list and red-black tree)
-
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.
-
wide
help you go wide
-
multimap
A multimap implementation
-
yrs
High performance implementation of the Yjs CRDT
-
vec1
a std Vec wrapper assuring that it has at least 1 element
-
string-interner
Efficient string interner with minimal memory footprint and fast access to the underlying strings
-
elsa
Append-only collections for Rust where borrows to entries can outlive insertions
-
fixedbitset
bitset collection
-
hecs
A fast, minimal, and ergonomic entity-component-system library
-
ndarray-stats
Statistical routines for ArrayBase, the n-dimensional array data structure provided by ndarray
-
enumset
creating compact sets of enums
-
ringbuffer
A fixed-size circular buffer
-
histogram
A collection of histogram data structures
-
gix-commitgraph
Read-only access to the git commitgraph file format
-
indextree
Arena based tree structure by using indices instead of reference counted pointers
-
bitmaps
Fixed size boolean arrays
-
bloomfilter
Bloom filter implementation
-
guppy
Track and query Cargo dependency graphs
-
modular-bitfield
Allows to easily define bitfield types with modular building blocks
-
smallbitvec
A bit vector optimized for size and inline storage
-
phf_codegen
Codegen library for PHF types
-
cita_trie
Modified Patricia Tree (aka Trie)
-
thin-vec
A vec that takes up less space on the stack
-
gix-diff
Calculate differences between various git objects
-
qp-trie
An idiomatic and fast QP-trie implementation in pure Rust, written with an emphasis on safety
-
biodivine-lib-bdd
thread-safe implementation of basic binary decision diagrams
-
weedle2
A WebIDL Parser
-
indxvec
Vecs sorting, merging, indexing, ranking, searching, reversing, intersecting, printing, etc
-
index_list
A doubly linked list implemented in safe Rust using vector indexes
-
litemap
A key-value Map implementation based on a flat, sorted Vec
-
linked_hash_set
HashSet with insertion ordering
-
array-init
Safe wrapper for initializing fixed-size arrays
-
hybrid-array
Hybrid typenum-based and const generic array types designed to provide the flexibility of typenum-based expressions while also allowing interoperability and a transition path to const generics
-
range-set-blaze
Integer sets as fast, sorted, integer ranges with full set operations
-
smallbox
Small Box
optimization: store small item on stack and fallback to heap for large item -
spade
Delaunay triangulations for the rust ecosystem
-
boa_interner
String interner for the Boa JavaScript engine
-
dlv-list
Semi-doubly linked list implemented using a vector
-
hdf5
Thread-safe Rust bindings for the HDF5 library
-
xorf
implementing xor filters - faster and smaller than bloom and cuckoo filters
-
bytes-utils
Additional utilities for working with the bytes crate
-
fpdec
Decimal fixed-point arithmetic
-
intervallum
Generic interval and interval set library
-
orx-split-vec
An efficient constant access time vector with dynamic capacity and pinned elements
-
trie-root
In-memory patricia trie operations
-
keyed_priority_queue
Priority queue that support changing priority or early remove by key
-
bv
Bit-vectors and bit-slices
-
warg-transparency
transparency data structures
-
egg
egraphs
-
fastbloom-rs
Some fast bloom filter implemented by Rust for Python and Rust!
-
ph
data structures based on perfect hashing
-
crop
A pretty fast text rope
-
lorawan
structures and tools for reading and writing LoRaWAN messages from and to a slice of bytes
-
patricia_tree
Memory-efficient data structures based on patricia tree
-
queue-file
lightning-fast, transactional, file-based FIFO
-
cc-traits
Common collection traits
-
arrow-ipc
Support for the Arrow IPC format
-
hashbag
An unordered multiset implementation using a hash bag
-
bounded-vec
Non-empty rust Vec wrapper with type guarantees on lower and upper bounds for items quantity
-
jsonptr
Data structures and logic for resolving, assigning, and deleting by JSON Pointers (RFC 6901)
-
modql
Model Query Language support
-
growable-bloom-filter
Scalable Bloom Filters with serde support
-
broccoli
broadphase collision detection algorithms
-
fixed-map
A fixed map where storage layout is calculated by a procedural macro
-
atone
A VecDeque and Vec variant that spreads resize load across pushes
-
sorted-vec
Create and maintain sorted vectors and vector-backed sets
-
slice-ring-buffer
A double-ended queue that Deref's into a slice
-
pi_slotmap
Slotmap data structure
-
imbl
Immutable collection datatypes
-
nuid
A highly performant unique identifier generator
-
ecow
Compact, clone-on-write vector and string
-
typed-index-collections
Typed index version of Rust slice and Vec containers
-
diff-struct
A trait for diffing and applying diffs to types
-
multi_index_map
MultiIndexMap: A generic multi index map inspired by boost multi index containers
-
simple_endian
A create for defining endianness within your data structures, to make handling portable data structures simpler
-
hibitset
Hierarchical bit set structure
-
rdf-types
Data-structures and traits definitions for RDF
-
v_frame
Video Frame data structures, originally part of rav1e
-
esaxx-rs
Wrapping around sentencepiece's esaxxx library
-
process_mining
Process Mining library for working with (object-centric) event data
-
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
-
sucds
Succinct data structures in Rust
-
differential-dataflow-master
An incremental data-parallel dataflow platform
-
vsmtp-config
Next-gen MTA. Secured, Faster and Greener
-
vob
Vector of Bits with Vec-like API and usize backing storage
-
jumprope
fast rope (fancy string) library built on top of Skiplists
-
trees
General purpose tree data structures
-
any-rope
A fast and robust arbitrary rope for Rust. Based on Ropey.
-
binary-heap-plus
Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps
-
array2d
A fixed sized two-dimensional array
-
caches
popular caches (support no_std)
-
iset
Map and set with interval keys (x..y)
-
id_tree
creating and modifying Tree structures
-
orx-linked-list
An efficient and recursive singly and doubly linked list implementation
-
gix-hashtable
that provides hashtable based data structures optimized to utilize ObjectId keys
-
deep_causality
Computational causality library. Provides causality graph, collections, context and causal reasoning.
-
avro-rs
working with Apache Avro in Rust
-
portgraph
Data structure library for directed graphs with first-level ports
-
log-once
Collection of helper macros for logging some events only once
-
dary_heap
A d-ary heap
-
array-macro
Array multiple elements constructor syntax
-
rsdict
Fast static rank and select data structure
-
ordered-multimap
Insertion ordered multimap
-
range_bounds_map
[
RangeBoundsMap
] and [RangeBoundsSet
], Data Structures for storing non-overlapping intervals based of [BTreeMap
] -
value-trait
Traits to deal with JSONesque values
-
skiplist
in rust, providing fast insertion and removal. A normal skiplist is implemented, as well as an ordered skiplist and a skipmap.
-
index_vec
Newtype-style helpers for
Vec
andusize
-
typed_floats
Types for handling floats with type checking at compile time
-
ffi-convert
A collection of utilities to ease conversion between Rust and C-compatible data structures
-
csaf-walker
work with CSAF data
-
utote
Stack allocated uint multiset, with optional SIMD implementations
-
arraydeque
A ring buffer with a fixed capacity, which can be stored on the stack
-
fastbloom
The fastest bloom filter in Rust. No accuracy compromises. Compatible with any hasher.
-
bitfield-struct
Struct-like procedural macro for bitfields
-
bridgetree
A space-efficient Merkle tree designed for linear appends with witnessing of marked leaves, checkpointing & state restoration
-
polytype
A Hindley-Milner polymorphic typing system
-
merkle-cbt
generating efficient Merkle tree and combined Merkle proof based on complete binary tree
-
cordyceps
Mycelium intrusive data structures
-
counter
package to count generic iterables
-
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…
-
x12-types
Bindings for the ASC X12 EDI definitions
-
phf_shared
Support code shared by PHF libraries
-
iso7816-tlv
tools and utilities for handling TLV data as defined in ISO/IEC 7816-4
-
chronologic
Time constraint reasoning (scheduling...)
-
qfilter
Efficient bloom filter like datastructure, based on the Rank Select Quotient Filter (RSQF)
-
range-collections
Sets and maps of ranges, backed by smallvec
-
csvenum
Generate code for enums with associated constants from a .csv in your command line
-
entity_data
A container for entity component data
-
ra_ap_ide_assists
TBD
-
qwt
Quad Wavelet Tree
-
newtype-uuid
Newtype wrapper around UUIDs
-
ego-tree
Vec-backed ID-tree
-
dachshund
graph mining library written in Rust. It provides high performance data structures for multiple kinds of graphs, from simple undirected graphs to typed hypergraphs. Dachshund also provides…
-
circular-buffer
Efficient, fixed-size, overwriting circular buffer
-
xml-builder
Easy and highly-configurable XML builder/writer
-
fixed-vec-deque
A fixed-size, zero-allocation circular buffer for Rust
-
data_reader
A data loading library for data scientist
-
avltriee
Customized version of AVLTree library.Process the same value in the third branch. One data is immovable from one row, and positional relationships such as left, right, and parent are all referenced by row numbers…
-
rc-u8-reader
A tiny implement for reading
u8
data from a reference counted instance -
identified_vec
Like HashSet but retaining INSERTION order and without
Hash
requirement on the Element type -
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
. -
nonempty-collections
Correct-by-construction non-empty collections
-
map_vec
The Map and Set APIs backed by Vec
-
iptrie
IPv4/v6 prefixes lookup structures (based on tries)
-
gpt_disk_types
GPT (GUID Partition Table) disk data types no_std library
-
hash_hasher
A hasher which is designed to work with already-hashed or hash-like data
-
equivalent
Traits for key comparison in maps
-
undo
An undo-redo library
-
narrow
Apache Arrow
-
converge
Layered configuration, can be expressed in a single line of code. The
Converge
trait merges instances of structures into a new instance of a structure. TheConverge
trait can be derived… -
garnish_lang_simple_data
Data implementation for garnish runtimes using simple list of variants
-
range-set
Smallvec-backed containers of sorted integer ranges
-
btree-range-map
B-tree range map implementation
-
bondrewd
Bit-Level field packing with proc_macros
-
sqrid
Square coordinates and grid-like arrays, with zero dependencies, in a single file
-
any_vec
Type erased vector. Most operations can be done without type knowledge. Mostly zero overhead.
-
iso7816
Types for ISO 7816
-
json_dotpath
Dotted path access to nested JSON objects (serde_json::Value)
-
nested_intervals
nested & overlapping interval set functions, overlap, union, etc
-
kempt
Ordered collection types with no unsafe code and no_std support
-
scapegoat
Safe, fallible, embedded-friendly ordered set/map via a scapegoat tree. Validated against BTreeSet/BTreeMap.
-
gdsl
graph data-structure library including graph containers, connected node strutures and efficient algorithms on those structures. Nodes are independent of a graph container and can be used as connected smart pointers
-
grid
Dynamic generic 2D data structure
-
melda
Delta-State JSON CRDT
-
ordered
A wrapper for adding arbitrary partial/total order to a type
-
cactus
Immutable parent pointer tree
-
tinyset
Size-optimized sets
-
lctree
Link-Cut-Tree: self-balancing data structure to maintain a forest of rooted trees
-
validit
Validate data structures internal state
-
small-map
An inline SIMD accelerated hashmap designed for small amount of data
-
ra_ap_tt
TBD
-
drain_filter_polyfill
current nightly implementation of Vec::drain_filter, copypasted out for use on stable
-
fastset
Fast set implementation for dense, bounded integer collections, optimized for quick updates and access
-
rust_decimal_macros
Shorthand macros to assist creating Decimal types
-
merkle-heapless
Statically-allocated Merkle Tree and Mountain Range
-
list-fn
A generic lazy list
-
trk-io
TrackVis (*.trk) reader and writer
-
bgpkit-commons
common BGP-related data and functions
-
gen_value
indexes and values with generations for vectors
-
ndstruct
Structures for N-dimensions
-
chat-prompts
Chat prompt template
-
manganis
Ergonomic, Automatic, cross crate asset collection
-
suggest
A minimal library to provide similar name suggestions like "Did you mean?"
-
zerofrom
trait for constructing
-
bitm
bit and bitmap (bit vector) manipulation
-
docker-compose-types
Deserialization and Serialization of docker-compose.yml files in a relatively strongly typed fashion
-
more_collections
Additional collections not found in std::collections
-
prio-graph
A lazily populated directed acyclic graph with top-level priority ordering
-
idlset
Fast u64 set operations library
-
pasture-core
A framework for working with point cloud data
-
crater
Very generic containers including KD trees, fibonacci heaps, minmax heaps,
-
orx-selfref-col
SelfRefCol
is a core data structure to conveniently build safe and efficient self referential collections, such as linked lists and trees -
string
A UTF-8 encoded string with configurable byte storage
-
owning_ref
creating references that carry their owner with them
-
bloom2
Fast, compressed 2-level bloom filter and bitmap
-
min-max-heap
An efficient, double-ended priority queue
-
cdylib-link-lines
Collection of link-lines useful to build correct cdylibs on targets
-
scryer-modular-bitfield
Allows to easily define bitfield types with modular building blocks. This is a forked version of the modular-bitfield crate with tweaks for use by Scryer Prolog.
-
flatk
Flat layout abstraction toolkit
-
xot
Full-featured XML tree library for Rust
-
rt_ref
Internal
Ref
types forrt_ref
andrt_vec
-
tuplez
Tuples represented in recursive form
-
gtfs-geojson
converter for GTFS to GeoJSON formats
-
cedarwood
efficiently-updatable double-array trie in Rust (ported from cedar)
-
binary-util
A panic-free binary utility crate to read/write binary streams over the wire
-
avl
A map and a set implemented with an AVL tree
-
slice_ring_buf
A ring buffer implementation optimized for working with slices
-
ux-primitives
Graphics Primitives for Angular Rust
-
vers-vecs
A collection of succinct data structures supported by fast implementations of rank and select queries
-
phf_generator
PHF generation logic
-
ex3-ic-stable-structures
A collection of data structures for fearless canister upgrades
-
test-assembler
A set of types for building complex binary streams
-
fqdn
FQDN (Fully Qualified Domain Name)
-
smallbitset
series of allocation free sets capable of holding small integer values
-
fixed-capacity-vec
Variable-length buffer backed by a fixed-size heap array
-
hrtb-lending-iterator
A lending iterator trait based on higher-rank trait bounds (HRTBs)
-
fiftyonedegrees
A wrapper around the 51Degrees device detection C library
-
optional
supplies a number of Option-like primitive types
-
hi_sparse_bitset
Hierarchical sparse bitset. Incredibly high performance. Compact memory usage.
-
velcro
Convenience macros for initializing vectors, hash maps and other Rust collections
-
balanced-tree-index
constant-time manipulation of a complete binary tree with a flat in-memory representation
-
pgdb_to_struct
CLI application to generate Rust struct files from PostgreSQL database tables
-
number-general
A generic number type for Rust which supports basic math and (de)serialization
-
tracker
A macro to track changes on structs
-
indexset
A two-level BTree with fast iteration and indexing operations
-
flat-tree
Series of functions to map a binary tree to a list
-
odht
hash tables that can be mapped from disk into memory without the need for up-front decoding
-
polars-ops
More operations on Polars data structures
-
metatensor
Self-describing sparse tensor data format for atomistic machine learning and beyond
-
datafrost
Data format and acceleration structure management
-
ordsearch
A data structure for efficient lower-bound lookups
-
valkyrie-ast
Strong typed abstract syntax tree of valkyrie language
-
erased_set
A set of erased types
-
loro
high-performance CRDTs framework. Make your app collaborative efforlessly.
-
strict
collections with strict bounds
-
starling
This tree structure is a binary merkle tree with branch compression via split indexes
-
primitive_fixed_point_decimal
Primitive fixed-point decimal types
-
bevy_spatial
tracking bevy entities in spatial indices
-
tagged-pointer
Platform-independent space-efficient tagged pointers
-
cranelift-bforest
A forest of B+-trees
-
sql-json-path
SQL/JSON Path implementation in Rust
-
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.
-
awint
Arbitrary width integers
-
billios
A soil library
-
cuckoofilter
Cuckoo Filter: Practically Better Than Bloom
-
epsg
EPSG Coordinate Reference System tools & data
-
ref_kind
Different reference kinds
-
b3-stable-structures
A collection of data structures for fearless canister upgrades
-
pact
Compact and streamable data format that works anywhere--from web apps to robots
-
nt-list
Compatible, type-safe, and idiomatic Rust implementations of Windows NT Linked Lists
-
rtree_rs
R-tree for Rust
-
identity-diff
Diff
trait to compute and merge data structure differences -
keyvi
key value index. It is an in-memory FST-based data structure highly optimized for size and lookup performance.
-
podded
Zero-copy types for constraint environments
-
csf
compressed static functions (maps) that use perfect hashing and value compression
-
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.
-
keyed-set
Keyed Set: a hashbrown-based HashSet that indexes based on projections of its elements
-
signvec
Vector implementation for fast, sign-based manipulation of dynamic collections under heavy mutation
-
ciborium-io
Simplified Read/Write traits for no_std usage
-
historian
a high performance zero-config histogram implementation
-
constructivism
Simplify the construction of structured data
-
rs-ecs
reasonably simple entity component system
-
vecmap-rs
A vector-based map and set implementation
-
wasmedge-types
The common data structures for WasmEdge Rust bindings
-
starlark_map
Map implementation with starlark-rust specific optimizations
-
tskit
rust interface to tskit
-
kbs-types
Rust (de)serializable types for KBS
-
enum2egui
derive macro that creates a set of egui ui databindings from arbitrary data structures. Supports egui v0.26
-
short-uuid
generate and parse short uuids
-
bao-tree
BLAKE3 verfiied streaming with custom chunk groups and range set queries
-
mzpeaks
representing peaks in mass spectrometry data
-
alot
A forbid-unsafe, generational slot map with usize-sized IDs
-
scalable_cuckoo_filter
A variant of Cuckoo Filter whose size automatically scales as necessary
-
lsm-tree
A K.I.S.S. implementation of log-structured merge trees (LSM-trees/LSMTs)
-
cmsketch
A count min sketch implementation in Rust
-
ofdb-boundary
Serializable, anemic data structures for accessing the OpenFairDB API in a type-safe manner
-
btree-slab
A memory compact Slab-based B-tree implementation
-
slice-dst
Slice-based custom DSTs
-
basic_trie
Trie implementation in Rust
-
map-macro
Declarative macros for statically initializing collections
-
lru-mem
An LRU cache implementation bounded by memory
-
validiter
Iterator adapters for validating iterations
-
im-rc
Immutable collection datatypes (the fast but not thread safe version)
-
arca
Various utilities used in my crates
-
enumoid
Enum Indexed Containers
-
cbsk_base
locked version cargo crates
-
dayendar
advanced days calendar operations
-
extindex
Persisted immutable index
-
weak-table
Weak hash maps and sets
-
disjoint
Fast and safe implementation of the disjoint-set data structure
-
mapgraph
A directed graph that can also be used as an arbitrary map
-
meminterval
interval-tree in Rust made to store memory mappings
-
smooth-json
Flatten serde_json Value variants into serde_json Objects ready for use in columnar or table-like usages
-
vector
The package provides a vector database allowing for efficient search of nearest neighbors
-
grit-data-prison
providing the struct Prison<T>, a Generational Arena that allows full interior mutability to each and every element
-
simple-grid
2d-grid structure
-
variant-rs
VARIANT support for Rust. Clean, idiomatic handling of WinAPI/COM results.
-
broomdog
A type-erased map with 'indefinite loanership'
-
plain
A small Rust library that allows users to reinterpret data of certain types safely
-
itybity
An itty bitty crate providing bit iterators and bit iterator accessories
-
fixed-macro
Macros for creating fixed-point constants for types in the
fixed
crate -
edtui-jagged
A jagged array data structure for the edtui editor
-
svd-rs
A CMSIS-SVD base structures
-
tree_by_path
A tree data structure featuring nodes addressable using a &Vec<usize> path and avoiding recursion and run-time borrow checking
-
selmr
Package to create and use Simple Explainable Language Multiset Representations
-
microkelvin
tree traversal over annotated data structures
-
bc-envelope
Gordian Envelope for Rust
-
packed_ptr
A configurable & generic tagged pointer implementation in Rust
-
incremental
computations, based on Jane Street's incremental
-
compact-rc
Low-memory reference-counting pointers
-
dup-indexer
Create a non-duplicated index from Strings, static str, Vec, or Box values
-
aatree
in Rust
-
cbsk_mut_data
ref mut tool
-
iter-tree
Convert between iterators and tree structures in both directions
-
intmap
Specialized HashMap for u64 keys
-
forest-ds
secure tree structure
-
emap
A map with a fixed capacity and integers as keys
-
space
providing abstractions for spatial datastructures and search
-
ibuilder
Interactive builder for Rust types
-
mc-oblivious-ram
Implementations of Oblivious RAM data structures
-
reconcile
A reconciliation service to sync a key-value map over multiple instances
-
flat_spatial
Flat spatial partitionning algorithms and data structures
-
dot2
generating Graphviz DOT language files for graphs
-
etwin_dinoparc_store
Dinoparc store implementation
-
hotel
Collection Data-structure to associate values with keys
-
catalan
binary tree of n variables where the parent node represents a function and the child node represents a value
-
smallstr
String-like container based on smallvec
-
redmaple
offers an oppinionated yet extremely flexible data modeling system based on events for backend applications
-
garage_model
Core data model for the Garage object store
-
unionfind
A union find library made for building type inference engines. Can be used as general purpose datastructure.
-
keysymdefs
A collection of key symbol definitions
-
mc-oblivious-map
Oblivious Hash Map data structures on top of Oblivious RAM
-
rust-box
odd set of tools for Rust programming
-
scribe
Text editor toolkit
-
do-notation
Monadic do syntactic sugar
-
product-os-command-control
Product OS : Command and Control provides a set of tools for running command and control across a distributed set of Product OS : Servers
-
leveled-hash-map
structure to separate values into different levels with keys. Every key-value entry which is not at the top level has a parent key at the superior level. Keys at the same level are unique…
-
ladata
& modular data model
-
sparse-merkle-tree
Sparse merkle tree implement in rust
-
graphplan
planning algorithm from Avrim L. Blum and Merrick L. Furst in Rust
-
vax-floating
VAX floating-point types
-
mset
/ multiset / bag implementation
-
blart
adaptive radix tree packaged as a BTreeMap replacement
-
lox
Fast polygon mesh library with different data structures and traits to abstract over those
-
swc-coverage-instrument
Istanbul compatible coverage instrumentation visitor for SWC
-
xor_name
Xor Type
-
quickselect
基于rust的选择算法
-
evento
A collection of libraries and tools that help you build DDD, CQRS, and event sourcing
-
xmltv
electronic program guide (EPG) parser and generator using serde
-
adapton
programming abstractions for general-purpose incremental computations
-
grdf
Generalized RDF graphs and datasets
-
ds-ext
Extensions to standard Rust data structures which provide additional capabilities
-
bitworks
meant to provide easy to use bitsets with emphasis on safety
-
feature-set
User defined feature set
-
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
Ord
trait -
aircraft_icao_country
aircraft ICAO codes and their country of origin
-
tree-flat
TreeFlat is the simplest way to build & traverse a pre-order Tree for Rust
-
json-number
JSON number parsing and storage
-
syzlang-parser
Parse Syzlang language
-
fingertrees
Immutable persisten finger trees
-
fallback
A helper library to implement fallback mechaism
-
arbitrary-chunks
An iterator that allows specifying an input array of arbitrary chunk-sizes with which to split a vector or array
-
gridly
managing fixed-size 2D spaces
-
akita
Mini orm for rust
-
rooting-forms
Generates HTML (rooting) forms from structures
-
rs-snowflake
Rust version of the Twitter snowflake algorithm
-
imbl-sized-chunks
Efficient sized chunk datatypes
-
cve
Mappings for parsing the CVE JSON files
-
rive
ecosystem crate
-
voxcov
Write something
-
rc-writer
A tiny implement for writing data to a reference counted instance
-
gecs
A generated entity component system
-
every_variant
EveryVariant trait that provides the every_variant method on types. Allows you to easily generate every combination of variants in structures that contains Enums, or in nested enum trees…
-
smart_led_effects
A collection of effects for LED strips
-
shardtree
A space-efficient Merkle tree with witnessing of marked leaves, checkpointing & state restoration
-
im_ternary_tree
Structural sharing ternary tree, i.e. immutable data structure
-
ndarray-ndimage
Multidimensional image processing for ArrayBase, the n-dimensional array data structure provided by ndarray
-
lurk-elsa
Append-only collections for Rust where borrows to entries can outlive insertions
-
cola-crdt
A text CRDT for real-time collaborative editing
-
validated
The cumulative sibling of
Result
andEither
-
exponential-decay-histogram
A histogram which exponentially weights in favor of recent values
-
thinset
A data structure for sparse sets of unsigned integers that sacrifices space for speed
-
not-so-fast
data validation with derive macro
-
subranges
manage non-interssecting integer intervals
-
trying
Basic trie crate
-
roadmap
model a project roadmap as a directed acyclic graph
-
walker-common
A common functionality for SBOM and CSAF walker
-
prefix-sum-vec
Compressed storage for highly repeating elements, with
O(log n)
lookups -
rb_tree
A Red Black Tree implementation in Rust
-
slack-blocks
Models + clientside validation for Slack's JSON Block Kit
-
bitvector
in Rust
-
superset_map
Map that stores distinct supersets based on the total order defined
-
flatcontainer
A flat container representation for Rust
-
vart
An immutable versioned adaptive radix trie
-
array-init-cursor
help keep track of arrays of MaybeUninit
-
disjoint-sets
Three union-find implementations
-
extensions-rs
File extension types in Rust
-
value_pool
implements a ValuePool struct that makes the creation of self-referential data structures easier and safer
-
tinyvecdeq
VecDeque
-like data structures -
hypergraph
data structure library to create a directed hypergraph in which an hyperedge can join any number of vertices
-
field_access
Dynamically access struct fields
-
overtone
An API for creation and management of rich (as in rich-text) musical-ish projects
-
atlv
Algebraic Tag Length Value encoding
-
garnish_lang
Single library for re-exporting and documenting all Garnish core libraries
-
metrix
metrics for application monitoring
-
rj
reactive json
-
school_library
structures to manage school-related data, including students, classes, and schools
-
lignin
A virtual DOM structure, primarily for web use
-
data_tree
Hierarchical data tree with pathing and search support
-
iterable
collection like types
-
digit-sequence
Sequence of u8 digits
-
convenient-skiplist
Convenient and Performant SkipList with serde support
-
slabigator
A linked list that doesn't do dynamic memory allocations
-
phtm
Re-exports for common uses of
PhantomData
-
signalk
parse signalk maritime data
-
golomb-coded-set
BIP158 Golomb-Coded Set data structure
-
pdatastructs
probabilistic data structures
-
gfa-reader
Reading gfa format v1
-
splay_tree
Splay Tree based Data Structures (map, set, heap)
-
traitgraph
Abstracting over different graph representations
-
product-os-authentication
Product OS : Authentication provides an entire pre-fabricated framework for user authentication and management including a set of APIs and a database structure of identities
-
graus-db
A high-performance, thread-safe key-value embedded data store
-
terrain-graph
Graph Library for Rust
-
HArcMut
mutable arc
-
flatbuffers-retained
allows a user to validate a flatbuffer once and the move it around or store it in a data structure without keeping the buffer borrowed. Then later it can be used again without re-validation.
-
libpna
PNA(Portable-Network-Archive) decoding and encoding library
-
easy_collections
Wrappers around standard collections for ease of use and quick prototyping
-
tree-sitter-traversal
Traversal of tree-sitter Trees and any arbitrary tree with a TreeCursor-like interface
-
qutee
A quadtree implementation
-
set_genome
A genetic data structure for neuroevolution algorithms
-
bittle
Zero-cost bitsets over native Rust types
-
enum-collections
Collections data structures optimized for Enum, initializable at runtime
-
elkai-rs
solving travelling salesman problems (TSP) based on elkai (LKH 3)
-
purse
Bag data structure implementation in Rust
-
stable-vec
A Vec-like collection which guarantees stable indices and features O(1) element deletion (semantically similar to
Vec<Option<T>>
). Useful for allocations in graphs or similar data structures. -
aabel-multihash-rs
extends Hasher trait. The added functionality allows users to get sequeces of hash values. It can be used inside of implementations of probabilistic data structures such bloom filter or count-min.
-
flange-flat-tree
A tree that can be expanded by attaching new values to the node without mutability of the old ones
-
messaging
two-way messaging crate
-
statiki
Static friendly data structures
-
discrete_range_map
DiscreteRangeMap and DiscreteRangeSet, Data Structures for storing non-overlapping discrete intervals based off BTreeMap
-
h3o-ice
Frozen{Map,Set} for H3 cells, based on finite state transducers
-
digits
Custom “numeric” incrementor without u64 MAX limit in size. Like a score flipper for a custom character set.
-
task-group
manage groups of tokio tasks
-
enumap
A HashMap and HashSet like interface for enums backed by an array
-
typemap_rev
A hashmap, but stores types as keys
-
mco-gen
Stackfull Generator Library in Rust
-
aabel-identifier-rs
defines identifier behavior, such comparing them, or generating sequences of identifiers
-
search_trail
manager of variables that can save and restore their values
-
dipa
dipa makes it easy to efficiently delta encode large Rust data structures
-
bicoro
Bidirectional co-routine data structures
-
crdt_tree
Tree Conflict-free Replicated Data Type (CRDT)
-
esl01-dag
DAG used for source control
-
ftree
A very fast fenwick tree implementation
-
stack-queue
Heapless auto-batching queue
-
eolib
A core rust library for writing applications related to Endless Online
-
crio
An easy to use persistent data storage library
-
hkalbasi-rustc-ap-rustc_data_structures
Automatically published version of the package
rustc_data_structures
in the hkalbasi/rust repository from commit e77366b57b799dfa3ce1fcb850c068723a3213ee The publishing script for this crate lives at: https://github… -
ssd-data
A service and data description format + a code generator based on rhai scripts and templates
-
scoped_stack
A scoped stack data structure
-
medianheap
A median heap for keeping track of a running median
-
sortedvec
a sorted vector that enables quick lookups
-
hit-data
Hierarchical Indexed Typed data structure
-
queues
Efficient FIFO Queue data structures
-
ldtk_map
reading ldtk maps for usage in games
-
associated_list
An associated list, for cases when the key implements neither Hash nor Ord
-
structured
Data structures to handle large, structured data
-
word-dictionary
data structure for word mapping. It can be used for language translation.
-
ordered_hash_map
HashMap which preserves insertion order
-
beach_map
slotmap
-
hexarr
working with hexagonal grids
-
vec_map
map based on a vector for small integer keys
-
ergo_avltree_rust
cryptographically authenticated dictionary based on AVL tree
-
moniker
Automatically derive variable binding and alpha equivalence for abstract syntax trees
-
stash
An amortized
O(1)
table for cases where you don’t need to choose the keys and want something faster than a HashTable -
yy-typings
A collection of typings for GameMaker Studio 2 YY and YYP files
-
pfds
Purely Functional Data Structures
-
sized-chunks
Efficient sized chunk datatypes
-
iceoryx-rs
Safe Rust bindings for Eclipse iceoryx - true zero-copy inter-process communication
-
phf_mut
Perfectly hashed mutable containers
-
densemap
A collection data structure that is permanently accessible by unique keys and fast iterable
-
suff_collections
Fast realization of suffix array and suffix tree
-
cmdtree
(Rust) commands tree
-
fid
FID (Fully Indexable Dictionary) implementation for Rust
-
ast2str
pretty-printing ASTs and other recursive data structures
-
toolshed
Arena allocator and a handful of useful data structures
-
sweep-bptree
In memory locality aware b+ tree, faster for ordered access
-
hvec
A Vec-like structure that can store different types of different sizes contiguous with each other in memory
-
typed_index_collection
Manage collection of objects
-
uid_store
Generate short random strings
-
oca-presentation
Lib providing struct for OCA presentation
-
open-coroutine-timer
The time utils
-
surface-grid
providing data structures for square-tiled grids wrapped around the surface of certain objects
-
probabilistic-collections
Various implementations of collections that use approximations to improve on running time or memory, but introduce a certain amount of error
-
truncate-integer
Truncate integers
-
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.
-
xsd-types
XSD data types
-
opt_struct
Optional collections
-
chronoflake
Generate unique IDs based on the Snowflake algorithm
-
endpoints
A collection of data structures for the OpenAI-compatible endpoints
-
mediumvec
Vector types optimized for space, including a 32-bit Vec
-
tyght-map
A static type map implementation
-
vec_mut_scan
Forward scan over a vector with mutation and item removal
-
ord-collections
offering collections which are pre-sorted automatically
-
tan-lints
A collection of lints for the Tan Language
-
point-nd
flexible no-std struct to model points on axes of any dimensions
-
datazoo
Bitset and jagged array data structures
-
generic_event_queue
generic event-queue API
-
cw-semver
Parser and evaluator for Cargo's flavor of Semantic Versioning
-
hextree
Location to value mapping
-
msg-store
A fast and light-weight message store designed to work as a priority queue in low hardware equiped devices
-
debounce
Data structures and helpers for debouncing a stream of events: removing duplicate events occurring closely in time
-
indexical
indexed collections
-
dia-i18n
ISO 3166-1 and ISO 639 codes
-
color-operators
Color data structures, converters, and arithmetic operators
-
threshold
data structures
-
blazemap
wrapper for replacing a small number of clumsy objects with identifiers, and also implements a vector-based slab-like map with an interface similar to that of HashMap
-
granular-id
ID numbers with arbitrary precision
-
priority-expiry-cache
A cache that evicts items based on their priority and expiry time (LRU + TTL) Add (O(1)), Get (O(1)), Evict (O(1)) in both time and space
-
merkle-cbt-lean
Special implementation of Complete Merkle Binary Tree for minimal memory footprint
-
typerat
Type-level rational numbers based on
typenum
-
stacked_errors
An error type for better
async
backtraces -
floating_bar
Representing rational numbers using the floating-bar number type
-
rs-car
CAR v1 and v2 specifications
-
ju-tcs-tbop-24-bebidek-endpoints
providing head and tail functionality
-
invade
reflect on Rust types and generate code
-
coca
Data structures with constant capacity
-
td-shim-interface
TD-shim metadata data structures and related functions. UEFI Platform Initializaiton data structures and accessors
-
nanotweaks-proc
moved to https://crates.io/crates/spread_macros
-
canadensis_dsdl_frontend
Compiler front-end for the Cyphal Data Structure Description Language
-
packbytes
Convert structures to and from packed representavises - byte arrays of fixed size that live on stack
-
kvv-efa-api
Rust bindings for the KVV (Karlsruher Verkehrs Verbund) "EFA"-API
-
orn
A general implementation of the sum type
-
shared_vector
Reference counted vector data structure
-
dst-container
Containers for DST objects
-
bstree-file-readonly
Query read-only binary-search tree file, supporting billions of entries in files of tens of GB
-
zarray
Cache-optimized 2D and 3D arrays using Morton order (aka Z-order) Z-indexed storage, with a convenient API for common 2D and 3D access patterns. Use of zarray in place of a Vec of Vecs often improves performance…
-
rosary
About Rose Trees
-
cow_vec_item
Copy-on-write Vec, available on stable rust
-
entity
that provides entity-like constructs
-
plexus
2D and 3D mesh processing
-
lazy-seq
constructing lazily evaluated sequences
-
dyn-slice
&dyn [Trait] implementation, inspired by a Reddit thread
-
cell-grid
fixed-size 2d grid container suitable for
no_std
game development -
cess-sp-porep
CESS Storage Proofs - Proofs of replication
-
standing-relations
Standing relations over a shifting dataset optimized for 'feedback loop' scenarios
-
tpntree
A N-dimensional generalization of region quad/oc-trees
-
context-mapper
Single rust macro for generating different maps
-
nimble-steps
Nimble Steps Collections
-
piece_table_rs
piece table data structure
-
ware
middleware chains
-
rtdlib
TDLib for rust
-
ffizz-passby
FFI helpers for implementing pass-by-value and pass-by-pointer
-
unicase_collections
Collection of UniCase datastructures
-
parallel_vec
A generic contiguous collection of heterogenous values
-
hedel-rs
A Hierarchical Doubly Linked List
-
fm-index
FM index and its variant implementations for Rust
-
kv6
Collection of structs to allow reading of Ken Silverman's voxel formats
-
bitvec_simd
bitvec with SIMD
-
slice-of-array
Extension traits for casting between slices and slices of arrays. (&[T] <-> &[[T; n]])
-
ast-grep-lsp
Search and Rewrite code at large scale using precise AST pattern
-
grids
2D grid data structure for games
-
read-copy-update
locking primitive
-
commitlog
Sequential, disk-backed commit log library
-
circular-queue
A circular buffer-like queue
-
gctree
cache-friendly, graph-like, arena-allocated datastructures
-
cnctd_smart_home
A collection of Smart Home APIs
-
datastruct
A pure-data structure builder
-
wasmrs-frames
WasmRS RSocket frame decoding, encoding, and data structures
-
hylo-fix
Fixed-point number types
-
product-os-openapi
Product OS : OpenAPI provides a set of structs for defining the structure of an OpenAPI / Swagger specification. This crate is intended to be used with Product OS : Connector.
-
light-curve-interpol
Interpolations tools for time series
-
codes-iso-639
This package contains an implementation of the ISO 639 (Parts 1, 3, and 5) Language Code specifications
-
lib-sokoban
Sokoban: compact, efficient data structures packed into contiguous byte arrays
-
generational-indextree
Arena based tree structure by using indices instead of reference counted pointers
-
colibri
Rust data structures for Jitsi Meet Colibri messages
-
oxrdf
providing basic data structures related to RDF
-
qualia
Basic semi-schemaless document store
-
msgpack_simple
Simplified, easy to use, pure Rust MessagePack implementation focused on handling dynamic data structures
-
monitor-common
Basic data structure and algorithm of linux-monitor tool
-
ambient_element
Element is a React-inspired virtual tree library for the Ambient runtime
-
recursive_reference
way to walk on recursive structures easily and safely
-
dynamic_dict
A lightweight basic crate to create dynamically typed dictionaries
-
Xorfilter
No alloc membership approximation
-
lapce-xi-rope
A generic rope data structure built on top of B-Trees
-
enso-data
A collection of useful data structures
-
subset-map
A map where the keys are subsets of an initial set of elements
-
yptoscr
writing yptoscr
-
panoradix
A generic map and a set, both backed by a Radix tree
-
terees
a collection of tree-like data structures
-
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.
-
radix-heap
Fast monotone priority queues
-
defaultmap
HashMap with an automatic default for missing keys
-
stdng
An enhancement for Rust standard library
-
aliasable
Basic aliasable (non unique pointer) types
-
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!
-
specs-hierarchy
Scene graph type hierarchy abstraction for use with specs
-
rive-models
Revolt API models for the Rive ecosystem
-
tdb-succinct
succinct data structures used by terminusdb
-
rasn-smi
Data types for handling Structure for Management Information
-
filetrack
persistent logrotated reading and other useful io things
-
lodtree
help create octrees and quadtrees for chunked level of detail
-
makods
The Jostle Tree, a data structure for working with long sequences of variable-width items
-
reunion
A generic implementation of the Union-Find w/ Rank data structure
-
rimu
A data structure template system
-
modular-bitfield-msb
Allows to easily define bitfield types with modular building blocks. MSB-first version.
-
im-pathtree
Immutable, path-addressable tree data structure
-
array-concat
Macros for concatenating const arrays
-
swaybar-types
building swaybar status commands in rust
-
persist-o-vec
A Vec type that aims to have stable indices and memory location
-
appendlist
An append-only list that preserves references to its elements
-
tugger-windows
Collection of packaging primitives specific to Windows
-
smart_access
A minimalistic "lazy bidirectional pointer" framework
-
merkle
tree implementation with support for generation of inclusion proofs
-
rsurf
A data structure providing range query filtering with Fast Succinct Tries
-
tbytes
A tiny library for reading and writing typed data into buffers
-
pi_slot
lock free Slotmap data structure
-
walker-extras
Additional functionality for SBOM and CSAF walker
-
std-ext
Extend the standard library functionality
-
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)
-
vbox
type erased Box of trait object
-
lim-bit-vec
Limited bit vectors
-
river-ring-buffer
ring buffer implementation
-
streaming_algorithms
SIMD-accelerated implementations of various streaming algorithms, including Count–min sketch, Top k, HyperLogLog, Reservoir sampling
-
cseq
compact sequences
-
yrs-kvstore
Generic persistence layer over Yrs documents
-
structures
collection data structures
-
corresponding
Move corresponding fields between structs
-
linked-vector
A hybrid linked list and vector data structure
-
implies
A parser for logical formulas
-
sharded
Safe, fast, and obvious concurrent collections
-
simple_tables
An easy to use rust crate for creating table structures. Including macros for easily creating these table structures.
-
hash_histogram
HashHistogram creates histograms with keys of any hashable data type. Features include rank ordering and mode.
-
yyid
Yyid generator (random tokens like UUIDv4, but using all the bits)
-
genmap
generational map data structure with no dependencies
-
l6t-file
A part of l6t library: reading, writing and deconding for L6T IFF data
-
contextual
deal with data in context
-
type-map
typemap container with FxHashMap
-
ball-tree
K-nearest neighbors
-
idbag
A bag of u32 identifiers
-
fav_core
Fav's core crate; A collection of traits
-
nonoverlapping_interval_tree
Map data structure keyed on (non-overlapping) ranges that allows lookup of a point within a range. Can be no_std (with use of alloc crate).
-
tinybox
Like
Box
, but with an optimization that avoids allocations for small data-structures -
bit_mask_ring_buf
A ring buffer implementation with cheap indexing
-
rexsgdata
Scatter-Gather Data Descriptors
-
undo_2
Undo and redo done the right-way
-
multi_containers
Ergonomically work with multiple values per key
-
llist
Lisp-style singly-linked list
-
kodiak-sets
manage generic sets supporting unique features
-
sbbf-rs
Split block bloom filter implementation
-
spatialtree
A fast and flexible generic spatial tree collection (Octree, Quadtree, etc)
-
galemu
workaround for generic associated types (GAT) limited to lifetimes (GAL)
-
bgp-models
Structs and other building blocks for BGP and MRT related Rust projects
-
mutable
keep track of changes in structures
-
type-rules
easily constrain a struct
-
big_unsigned_ints
Big Unsigned Integers ranging from U256 to U2048 using u64 arrays all under a fixed-size of 32
-
vecdeque-stableix
Deque with stable index values
-
slabmap
HashMap-like collection that automatically determines the key
-
rep
A small tool for representation/class invariants
-
workit
single-threaded work queueing utility
-
civs
Controllably Increasing/Inflating VectorS
-
fixed_bitmaps
A small crate implementing bitmap functionality around primitive Rust unsigned integers
-
tf-semver
Parser and evaluator for Cargo's flavor of Semantic Versioning
-
arc-bytes
A reference-counted byte buffer
-
chronofold
A conflict-free replicated data structure (a.k.a CRDT) for versioned text
-
sliding_window_alt
A structure that holds the last N items pushed to it
-
rust-3d
2D/3D library written in rust
-
table
A specialized map for storing values of varying types
-
tracing-rc
Cycle-aware reference-counted pointers with a safe, simple api
-
im-lists
Persistent unrolled linked lists and vlists
-
orx-fixed-vec
An efficient constant access time vector with fixed capacity and pinned elements
-
hirpdag
procedural macros for Hash Consed, Immutable, Reference Counted, Persistent, Directed Acyclic Graph data structures
-
range-mutex
A
Mutex<[T]>
-like type, that allows locking different ranges separately -
ux-dx
3D Graphics Primitives for Angular Rust
-
binary_vec_io
Some tools that are 'internal' for now because they are insufficiently refined and unstable, but which are used by other 'public' crates
-
dynamic-list
A powerful and efficient implementation of dynamic lists with versatile data structures, capable of storing any type!
-
indexedlinkedhashmap
An indexable LinkedHashMap. The user defines the data structure that controls order.
-
rustupolis_server
using space tuples in fog computing
-
stable_node_set
An ordered set with handles to values
-
rtlp-lib
This create provide structures to parse PCI TLPs
-
ux-dataflow
Data Processing Library
-
sorbus
A tree manipulation library
-
alt-std
Alternative Lightweight Std library for making small executables and shared objects
-
data_registry
An unordered data structure with immediate insertion, removal and access
-
re_string_interner
string interning library
-
simd_aligned
Safe and fast SIMD-aligned data structures with easy and transparent 'flat' access
-
combo_vec
A blazingly fast no-std vector-like ADT using the stack (and optionally heap for overflow)
-
higher
Functors, Applicatives, Monads and other bad ideas
-
higher-free-macro
macro that creates a (naive) Free Monad type based on a user-supplied Functor. It uses the traits from the "higher" crate. This macro is a port of the Control.Monad.Free part of the…
-
small-fixed-array
providing fixed length immutable collections with a low memory footprint
-
loaded_dice
sampler for loaded dices, implementing the alias method
-
host-port-pair
Host-port pair type
-
rc-dlist-deque
Doubly-linked list based on std::Rc
-
rpos
Cursor Manager on Table
-
try-lazy-init
Fallible lazy initialization
-
arc-atomic
atomic pointer to an
Arc
-
route_verification_bloom
Parse RPSL in the IRR to verify observed BGP routes
-
helgoboss-midi
Interfaces, data structures and utilities for dealing with MIDI messages according to the MIDI 1.0 specification
-
membuffer
A very fast flat memory buffer used to deserialize at a fast speed
-
fdec
A collection of macros for generating fixed-size fixed-point numeric types for Rust
-
patricia_router
Radix Tree implementation for Rust
-
slice-rbtree
A slice-based Red-black tree
-
serde_either
set to enums to deserialize and serialize data that can either be string, struct or vec
-
flowcom
collection of UI components for floem
-
smart-string
A collection of string types and traits designed for enhanced string manipulation
-
twie
fast and compact prefix tries
-
driftdb
A real-time data backend for browser-based applications (core library)
-
bigraph
Different representations with implemented operations on bigraphs
-
farmfe_core
Core types and data structures for farm
-
pax-properties-coproduct
Static container for program-variable data structures and polymorphic components
-
simple-canvas
generic 2 dimensional canvas struct
-
code_location
UNMAINTAINED! Use std::panic::Location instead!
-
text-document
Text document structure and management
-
bdaddr
Bluetooth Device Address
-
astack
offers a Stack data structure with fixed capacity capable of fast LIFO operations
-
threshold-dict
A data structure to find smallest key that is larger than the query
-
safe_index
Type-safe indexes
-
tst
Ternary search trie collection in rust with similar API to std::collections as it possible
-
bit-parallelism
Small integer specialized, word level, parallel algorithms and data structures
-
soa-vec
Vec-like API over a struct of arrays layout
-
ultragraph
Hypergraph data structure
-
write_x86_64
help you write x86_64 assembly code
-
attr
attr
is a library to provide external access to a datastructure through a typed path object, using all type information known about the data structure at hand -
kollect
Collections made ergonomic for gamedev usecases
-
rutenspitz
А procedural macro to be used for testing/fuzzing stateful models against a semantically equivalent but obviously correct implementation
-
autocomplete
Auto-complete feature using Trie data structure
-
vivalaakam_seattle_collection
Collection provider
-
compact-calendar
Compact representation of a set of days based on a bit-maps
-
moving_min_max
Tracking minimum or maximum of sliding windows
-
treez
A collection of useful data structures
-
text-style
Types and conversions for styled text
-
xsparseset
sparse set
-
aph_disjoint_set
Disjoint set implementation with optimized memory usage and ability to detach elements
-
lobster
A fast limit order book (LOB)
-
array_map
Map backed array for fixed size keys with O(1) performance
-
bfield
B-field datastructure implementation in Rust
-
ternary-tree
Ternary Search Trees, with no unsafe blocks
-
dequemap
A no_std compatible implementation of the dequemap crate
-
anchors
async incremental computations
-
sqlite-collections
Rust collection types backed by sqlite database files
-
dot_tree
Create, query and store binary trees
-
rudac
common data structures and algorithms
-
segment-tree
Quickly perform interval queries or modifications
-
b100m-filter
The fastest bloom filter in Rust. No accuracy compromises. Use any hasher.
-
grid-tree
Pixel quadtrees and voxel octrees
-
lookups
Improve the data retrieval operations for collections
-
minsize
Collections with a statically known minimum size (using const generics)
-
bayesic
A string matching library similar to NaiveBayes but optimized for many small classifications
-
manhattan-tree
A spatial tree which can effiently find closest key to a point, by manhattan distance
-
processing_chain
set up processing chains of large amounts of data
-
etc-os-release
Parse /etc/os-release file
-
ioc
An Inversion-of-Control library in Rust
-
kg-utils
Various collections and utilities
-
tri-mesh
A triangle mesh data structure including basic operations
-
chesspos
Basic structs for representing chess squares
-
errling
A collection of intrinsically useful errors
-
anylist
a list type for any type
-
memvec
Memory-backed vector, not buffer. Designed for for mmap. Not MemMap, but MemVec!
-
peapod
Ultra-compact storage for enums
-
compact_strings
A more compact but limited representation of a list of strings or bytestrings
-
timewheel
Hala timewheel implementation
-
hkalbasi-rustc-ap-rustc_serialize
Automatically published version of the package
rustc_serialize
in the hkalbasi/rust repository from commit e77366b57b799dfa3ce1fcb850c068723a3213ee The publishing script for this crate lives at: https://github… -
recursion-visualize
visualized cache-aware stack safe recursion
-
iowrap
Small helpers for using io::Read/io::Write
-
bitlab
Extracting a range of bits from a binary data source
-
tagged_ufs
A union-find-set implementation, in which sets can be associated with tags. When two sets are united, their tags are merged
-
chainbuf
Fast chained buffers
-
beehive
collections for 3D hexagonal maps
-
pvec
RRB-Tree based persistent vector implementation
-
vartyint
Read & Write varint encoded integers
-
standards
A collection of standards for international trade facilitation
-
rustc-ap-rustc_serialize
Automatically published version of the package
rustc_serialize
in the rust-lang/rust repository from commit 9a27044f42ace9eb652781b53f598e25d4e7e918 The publishing script for this crate lives at: https://github… -
zxcc
阿斯顿as
-
fvm_ipld_kamt
Sharded IPLD Map implementation with level skipping
-
ptrie
Generic trie data structure implementation (prefix tree) with support for different key and value types, and functions to search for common prefixes or postfixes
-
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.
-
art-tree
The Adaptive Radix Tree
-
intervaltree
generic implementation of an immutable interval tree
-
tudelft-dsmr-output-generator
Companion library for the TU Delft Software Fundamentals individual assignment
-
foyer-intrusive
intrusive data structures for foyer - the hybrid cache for Rust
-
libxinux
Collection of API & ABI for Xinux
-
stack-map
constant-size associative container for building higher-level data structures out of
-
unsized-vec
Like Vec, but for unsized values
-
aversion
Versioned data structures with auto-upgrading
-
netcrab
creating and exporting Petri nets
-
bufferring
Ring buffers for Rust
-
range_union_find
A union-find data structure for ranges
-
kstring
Key String: optimized for map keys
-
markov-generator
Highly customizable crate for building Markov chains and generating data from them
-
zngur-def
Data types that define the structure of a zng file
-
gw2timers
Iterate and collect Guild Wars 2 map meta event times
-
croaring-sys
Raw bindings to CRoaring
-
gauze
Probabilistic set membership filters with a simple interface
-
spaceindex
-
but
A common utils lib
-
fast_trie_tree
A fast
TrieTree
for multiple data types -
neighborhood-diversity
computing the neighborhood diversity of simple, undirected graphs
-
netlist
generic netlist data structure for VLSI design
-
goya
morphological analyzer for Rust and WebAssembly
-
seq_watcher
A pair of structures for monitoring a stream of data for one or more sequences
-
distant-protocol
Protocol library for distant, providing data structures used between the client and server
-
rytm-sys
Rust bindings for libanalogrytm
-
is_even_odd
categorizing and operating on integers
-
hicollections
C-liked Collections
-
whirlybird
generic type implementations for RedMaple library, that offers workflows for different events compatible with common contents like todos, blogs and etc
-
succinct
data structures for Rust
-
batbox-approx
Approximate comparison
-
histogram-sampler
Sampling from a distribution given by a histogram
-
foxy_utils
Common types and utilities for
foxy
submodules -
teardown_tree
A binary search tree that supports fast clone and delete-range operations
-
casbin-arangors-adapter
ArangoRs adapter for casbin-rs
-
precedence-net
Create and analyse precedence networks
-
json-node
A way to work with JSON as a node tree
-
nodit
Discrete Interval Tree Data-Structures, which are based off BTreeMap
-
wrapped_slab
WrappedSlab: Auto-generate newtype idiom based on a Slab
-
know
Framework for Rust
-
l6t-symbolic
A part of l6t library: symbolic data model for different known devices
-
vec-strings
Store any string efficiently in an immutable way
-
sif-kdtree
immutable, flat k-d tree
-
type-freak
Collection of typed data structures, trait operators and aliases
-
intervals-rs
intervals
-
landfill
Various types for dealing with on-disk data
-
avl-cont
A contiguous AVL Tree
-
v9
A slim data engine for Data Oriented Design
-
cad_import
importing CAD data from different formats into a uniform in-memory structure
-
boolvec
A vector of boolean stored contiguously in memory
-
awint_dag
DAG
awint
functionality -
python-packed-resources
Manage data structures containing Python resources
-
entry_put_ext
Map entry extension for put operations
-
shortlist
An efficient data structure to track the largest items pushed to it
-
nanoset-py
A memory-optimized wrapper for Python sets likely to be empty
-
biheap
A heap group that supports efficient removal of extreme elements
-
grove
A segment tree library enabling generic user-defined queries and actions on segments of your data
-
serde_single_or_vec
Type which can be deserialized from either a sequence or a single value
-
egui_suspense
Automatically show loading and error uis for egui
-
loro-rle
A internal library of loro for storing and manipulating run-length encoded data. Do not use it directly.
-
bitint
Integer types that have a logical size measured in bits
-
clap_flags
Collection of reusable flags for Clap
-
screech
A collection of helpers for handling audio data in real time
-
generic-btree
Generic BTree for versatile purposes
-
froop
A functional reactive stream library for rust
-
cvrdt-exposition
Understanding Convergent Replicated Data Types
-
retworkx
A python graph library implemented in Rust
-
large_int
An ease-of-use unbounded signed integer
-
uluru
fast, LRU cache implementation
-
ffi-toolkit
A collection of functions useful for working with the Rust FFI
-
nexum
collection of commonly used data structures
-
varflags
exporting varflags macro, allowing to use unit-like enums in conjunction with Varflags struct to create easy to use bitflags data structure defined over enum variants
-
dade
data definition for Rust structures
-
static-files
help automate static resource collection
-
traduki
Integrate translated assets into your application or library
-
dendron
Generic tree data structure
-
cfgmap
A special hashmap made with configuration in mind
-
singletonThread
thread in a singleton
-
fns
add common fn, eg: debounce, throttle
-
union-fn
Proc. macro for creating efficient "inline closures".
-
union-find-rs
Disjoint-set forest implementation to support the union-find algorithm in Rust
-
composite_types
Compose type definitions in the style of typescript
-
kg-tree
Generic object tree with Opath query language, similar to XPath
-
sum
General-purpose sum types
-
sidex
A format- and language-agnostic data structure and API definition language
-
triskell
A tri-partite ring buffer
-
branchless
Algorithms and data structures designed to maximize performance on superscalar processors
-
unique-id-collection
Collection with unique Id
-
relational_types
Manage relations between objects
-
kurobako_problems
A collection of black-box optimization problems
-
sweeper
A foundation for Minesweeper implementations in Rust
-
atree
An arena based tree structure with removal support
-
mut-rc
Temporarily mutable
Rc<T>
that decays intoRc<T>
-
hash-rings
Implementations of various hash rings
-
voml-collection
Collections for VOML
-
ord-by-set
providing a weakly ordered multi-set with compile-time configurable ordering scheme
-
prehash
storing values with precomputed hashes
-
tc-value
TinyChain's representation of a value which can be collated and stored
-
wavelet-matrix
A wavelet matrix implementation. Supports various near-O(1) queries on large number of symbols or integers.
-
pathlink
A URL type whose path can also be used as a filesystem path, for Rust
-
sawp-flags
SAWP BitFlags Handling and Storage
-
succinct_rs
Succinct Data Structures library for Rust
-
tree_multiset
A tree-based multiset for Rust
-
slab_tree
A vec-backed tree structure with tree-specific generational indexes
-
grit-bitvec
BitVec, a vector type that can store fixed-width data with irregular bit widths
-
paged
Read and create read-only paged database files
-
non-empty-collections
Non-empty hash-map and hash-set implementations
-
st2-logformat
Adapter-agnostic definitions for data types used by ST2
-
bailamos
notification manager
-
mergle
A data structure with fast merging and comparison
-
range_map_vec
range map data structure backed by a Vec
-
rbtset
A set based on a RB-Tree for efficient operations
-
granite
Generic backing storage framework for building data structures
-
loki-logger
A loki logger for the log facade
-
cons-rs
containing a Cons data structure
-
lending-library
A key-value store that loans full ownership of items
-
sets_multisets
API for working with sets and multisets of elements of type usize
-
region_quadtree
A lightweight Region Quadtree
-
cliquers
Manage filesequences with a common numeric component
-
static_merkle_tree
Static Merkle Tree is dedicated for generating Merkle Root and Merkle Proof for a static list of items
-
boxing
cross-platform implementations for NaN and ptr boxes
-
hayami
general use symbol table
-
slotmap-fork-otter
Slotmap data structure - temporary fork for Otter
-
b_trees
Implementations for various binary trees including AVL tree
-
i_shape
iShape is a compact and efficient library specifically designed for representing 2D data structures using FixVec
-
sequence_trie
Trie-like data-structure for storing sequences of values
-
liblet
learning about formal languages and grammars
-
aligned-utils
Common utilities to work with aligned values and allocation
-
field-ref
Field reference (like a member pointer to non-static data field in C++) for Rust
-
adflib
handle amiga disk files
-
arr-rs
arrays library
-
lumberjack
Read and modify constituency trees
-
jui_file
file tool
-
multiset
Multisets/bags
-
thincollections
Alternative implementations for vector, map and set that are faster/smaller for some use cases
-
bstree
A Binary Search Tree written in Rust
-
cervine
A slightly more flexible Cow; roughly to T: Borrow<R> as alloc::borrow::Cow is to B: ToOwned
-
statemachine-rs
A statemachine crate which have zero dependencies
-
rle_vec
A vector like struct that stores data as runs of identical values. Useful for storing sparse data.
-
hilbert_curve_generator
A WIP Hilbert Space-Filling Curve Coordinate Generator
-
system-config
storing application properties on disk
-
cast-rs
A collection of types cast for Rust
-
compt
A complete binary tree visitor library
-
sparseset
A Sparse Set
-
predicates-tree
Render boolean-valued predicate functions results as a tree
-
prototty_common
Definition of common ui elements and views for use with prototty
-
rustz
functional programming in Rust
-
btreemultimap
A multimap implementation with range support
-
contack
easy contact library
-
watermark
watermarking set for in-order insertions
-
nested_containment_list
A data structure for efficiently storing and querying nested intervals
-
espalier
Very simple flattened tree structure
-
dsa_sport
revision material for undergrads
-
pinus
A prickly BTreeMap. You can insert through shared references and values are pin-projected.
-
reactive-signals
dx-first scope-based fine-grained reactive system
-
mown
Maybe owned values. Wrappers for values that can be either owned or borrowed.
-
giftbox
A fun Rust crate called
giftbox
to help Rustlings learn and explore generics -
key-node-list
Doubly-linked list that stores key-node pairs
-
twitter/rustcommon-time
getting current and recent timestamps
-
bitset-core
Straightforward, no-std compatible, simd optimized, BitSet API
-
dakv_skiplist
skiplist for dakv
-
cueue
High performance SPSC circular byte buffer with batch operations
-
ofilter
fast thread-safe Bloom filter
-
recasting
traits for one-to-one recasting of values in data structures
-
object-collection
A collection that can store multiple values of types
-
libpaprika
read and generate Paprika recipe files and recipe collections
-
acme-types
Types for implementing ACME (RFC 8555) providers and clients
-
goodreads
deserializing a Goodreads library export
-
data-stream
serialization library based on streams
-
settrie
Fast subset and superset queries
-
myopic
A possibly bad lens library for Rust
-
ndsparse
Sparse structures for N-dimensions
-
flatbuffers-owned
that enables a more flexible usage of FlatBuffers
-
kd-tree-rs
k-d tree
-
restorable
An iterator adapter for saving and restoring iterator state
-
stupid_utils
that provides some simple and maybe stupid or useful tools
-
bktree
BK-tree datastructure
-
pointcloud
An accessor layer for goko
-
inspector
General purpose inspection for popular data structures
-
simple-matrix
generic matrix library
-
weak-self
WeakSelf is simple way to have a Weak pointer to yourself
-
yagraphc
working with Graph data structures and common algorithms on top of it
-
pna
PNA(Portable-Network-Archive) decoding and encoding library
-
bitaccess
Macro for efficient and type-checked access to individual bits of a variable
-
thot-core
Core functionality and types for Thot data management and analysis software
-
list-any
Type erased slices and Vecs
-
rolling-set
A first in first out set that never grows above a certain size
-
shiftnanigans
contains different iteration data structures for either iterating or for shifting iteratively forward and backward
-
upair
Unordered pair data structure
-
stonks
Sets that allow borrowing while inserting entries
-
rpds-pathtree
Immutable, path-addressable tree data structure
-
empty_type
Tools to define and convert between types and their corresponding "maybe types"
-
path-value
Universal type and access property(s) by path
-
wplot
Plot interface
-
modupipe
A modular and extensible ETL-like pipeline builder
-
range-map
Maps and sets implemented using ranges
-
equivalence
Trait and derive macro for comparing and hashing types modulo an equivalence relation
-
pulz-arena
A generational arena allocator with compact generational indices
-
bst-rs
Recursive & Iterative Binary Search Tree Implementations within Rust
-
ypwt
ypwang's personal toolbox
-
hashcons
Hash cons'ing for compact representations of shared, immutable data structures
-
nybbles
Efficient nibble-sized (4-bit) byte sequence data structure
-
flat-veb
Fast implementation of vEB trees without internal allocation
-
rimu-value
A data structure template system
-
fwdlist
A simply linked (forward) list
-
flat_enum
Expand nested enum into flattened enum
-
shogiutil
A collection of tools to handle shogi data
-
byte_set
Efficient sets of bytes
-
aterm
Annotated Terms data structure
-
xsl-rs
A simple library
-
hedge
An index based half-edge mesh implementation
-
aoc-framework-utils
such as data types, algorithms and functions for aoc-framework-rs
-
mih-rs
Multi-index hashing (MIH) for neighbor searches on binary codes in the Hamming space
-
better_peekable
Create a Peekable structure like Rust's Peekable except allowing for peeking n items ahead
-
keylist
Elixir keyword list in Rust
-
content-tree
An efficient data structure for compacted RLE data
-
c_vec
Structures to wrap C arrays
-
nakadi-types
A connector for the Nakadi Event Broker
-
ro
stuff read-only
-
vicardi
JSON VCardArray Generator that uses Serde
-
foxy_types
Types for
foxy
-
fenny
working with Fenwick trees
-
task-collection
Types for managing and waiting on groups of tasks
-
bitarr
A fast and efficient Rust implementation of a BitSet, supporting multiple backing stores
-
serde_single_or_vec2
Type which can be deserialized from either a sequence or a single value
-
learn_together
Curated collection of lists of useful resources to learn Rust together
-
retaker
ecs implementation
-
skog
Adobe's stlab::forest data structure
-
pciids
parse the pci.ids data file
-
priq
Array implementation of the min/max heap
-
generational_token_list
A doubly-linked list backed by generational-arena
-
mine_sweeperr
Minimalist interface to manage the backed of a mine sweeper game
-
mintaka-types
Mintaka Types
-
simple-undo
Easy to use undo-redo library
-
parity-map
For mapping integers based on their parity
-
finite-automata
A collection of extendable finite automata with immutable state and transition data
-
simple-vec-collections
Collections implemented using Vec
-
hash_table_datastruct
Adds a HashTable type, allowing to store values in a table with integer-indexed rows and hashable keys for columns
-
aspiesolutions_core
core types used by many crates
-
fixed-index-vec
A vector-like data structure whose indices do not change when elements are removed
-
cbloom
Concurrent implementation of Bloom filters
-
polystore
Polymorphic data store
-
dynprops
Creating and extending objects with typed dynamic properties
-
dsdl
Open Cyphal DSDL Rust Implementation
-
fvm_ipld_hamt
Sharded IPLD HashMap implementation
-
k2_tree
A space-efficient representation of sparsely populated bit-matrices
-
ransel
rank/select succinct data structures
-
eqlog
Datalog with equality
-
traitgraph-algo
Graph algorithms based on the traitgraph crate
-
designal
Procedural macro for use with futures-signals
-
cursieve
that makes it easy to deserialize byte arrays into annotated Rust structures
-
rolling_norm
Computes the rolling mean, variance, standard derivation and norm
-
rdc
generating Java code from rust structs
-
sum-queue
Queue struct that keeps a fixed number of items by time, not capacity, and allows to get summarized stats of its content
-
bengbenge
inifity array for round-robin dns, beng, beng
-
syntastica-parsers-git
Collection of tree-sitter parsers for syntastica, fetching with git in the build-script
-
butils
shared by software included in BSuccinct
-
deltastruct
Allows defining deltas for tagged structs for later application
-
sparse_set
sparse set data structure
-
wrapping
slices and arrays
-
try-push
A trait for attempting potentially expensive actions
-
weight-cache
A cache that holds a limited number of key-value-pairs according to a user defined criterion
-
arc-string-interner
An efficient cuncurrent string interning data structure with minimal memory-footprint and fast access to the underlying contents
-
gcollections
Generic traits over Rust collections library
-
one_way_slot_map
SlotMap with minimal restrictions on Keys and Values
-
make-message-bus
Generate a pub-sub bus for use in async applications
-
artful
Low-memory overhead and high-performance adaptive radix tree
-
vec-with-gaps
A data structure that behaves like a vec of vecs, but where the subvecs are kept in one contiguous section of memory, which improves cache performance for some workloads
-
map_err
map error values
-
int-vec-2d
Vectors, points, rectangles, etc. with
i16
coordinates. -
big_enum_set
creating sets of enums with a large number of variants
-
timer-queue
Pure, minimal, and scalable timers
-
optempty
Tools for working types that may be empty. E.g., an empty
String
,Vec
,HashMap
, etc. -
kravltree
AVL Tree implementation based on fastutil AVLTreeMap
-
folketinget-api-models
Autogenerated Rust structures based on the Danish Parliament's OData metadatafile
-
changed
change detection
-
cascara
TinyLFU cache
-
pair_macro
Create types consisting of the same type values such that Pair, Triplet, and so on
-
nested
A memory efficient container for nested collections (like
Vec<String>
orVec<Vec<T>>
) -
takeable
Container type that allows for temporarily moving out of the container, or permanently moving out and invalidating the container
-
hyperbitbit
data structure
-
enontekio
solve problems with data extraction and manipulation, like Advent of Code puzzles
-
crfsuite-sys
Rust binding to crfsuite
-
another-option
option data type; useful when allocations are expensive
-
simple_event_bus
A basic, simple event bus in Rust
-
win-variant
that aims to provide a more ergonomic way of working with variants in winapi based projects
-
evento-store
A collection of libraries and tools that help you build DDD, CQRS, and event sourcing
-
kdtree-simd
K-dimensional tree in Rust for fast geospatial indexing and nearest neighbors lookup
-
gavl
A fast implementation for a map and a set using an AVL tree
-
simple-rate-limit
Rate limit enforcement as simple data structures, no atomics
-
tiny-test
tiny-test
is collection of functions simplifying test assertions in rust -
optimistic_lock_coupling
A General Lock following paper 'Optimistic Lock Coupling: A Scalable and Efficient General-Purpose Synchronization Method'
-
any_handle
A thread-safe, type-safe smart pointer that can share, store and downcast a
dyn Any
-
algae-rs
A collection of abstract algebraic structures implemented in Rust
-
symbol_table
A symbol table that's fast, concurrent, and gives stable references
-
bitstring-trees
Trees based on bitstrings
-
anymap2
A safe and convenient store for one value of each type
-
dicetest_examples
A collection of examples for Dicetest
-
cdl-list-rs
A circular doubly linked list implementation using Rc<T> and RefCell<T>
-
rcbytes
Rc version bytes crate
-
nereon
Riboseinc configuration library for Rust
-
symbol-map
Memory-efficient mapping from values to integer identifiers (AKA a lexicon or symbol table), with options for fast bidirectional lookup
-
syntastic
Generic abstract syntax representation
-
wccg-models
WCCG Data
-
enumflags2
Enum-based bit flags
-
actions
Software without side-effects. Redo and Undo. Macro's.
-
velect
A Vec with item / index selection
-
rbitset
A bit set, being able to hold a fixed amount of booleans in an array of integers
-
index-map
A map with automatically generated usizes as keys
-
app_properties
reading application properties from a file
-
epoch-timestamp
Boilerplate collection for epoch timestamping
-
wick-settings
Wick's Resource Configuration file data structures and normalization logic
-
redox_simple_endian
A create for defining endianness within your data structures, to make handling portable data structures simpler
-
funnel
data structure that makes it easy to read from multiple channels from a single source
-
reservoir-buf
Dead simple interning
-
bitboard64
A 64-bit bitboard useful for chess programming
-
largeint
that supports large integer arithmetic
-
persistence
A resizable, mutable array type implemented on top of mmap, providing persistence for arrays of data in memory
-
parsable
A trait to easily parse data structures
-
leetcode-solutions
A collection of leetcode solution in rust
-
fervid_core
The core structures and utilities of fervid
-
canadensis_bit_length_set
A bit length set type used to calculate data type sizes when processing Cyphal data structure description language files
-
backtracking_iterator
generic iterator with an item history, capable of backtracking and forgetting
-
render_as_tree
visualizing tree data structures via text
-
usage
A convenient alternative to the newtype pattern
-
arbtree
A small library for general purpose tree data structures
-
combinations
give you all the combinations of values in a vec
-
synthax
Synthesize syntax with quasiquoting plugins
-
woodland
Easy to use implementations of popular tree data structures such as Binary, Binary Search, AVL, Red-Black, and more
-
colours
Color types for different color models with conversions between it
-
littlechestnutgames-trie
A generalized trie implementation for quick prefix searching
-
arraystring
Fixed capacity stack based generic string
-
vec-dimension-shift
N-Dimension shift features for Vec<T>
-
ABtree
AVL and Btree for rust
-
griddle
A HashMap variant that spreads resize load across inserts
-
tf2-types
a collection of types for tf2
-
inditech
A set of technical indicators for time series analysis
-
treeflection
that provides reflection for tree structures
-
bin-tree
Building Binary Tree
-
good_lp
Mixed Integer Linear Programming for Rust, with an user-friendly API. This crate allows modeling LP problems, and lets you solve them with various solvers.
-
queue-rs
queue
-
resizing-vec
An automatic resizing vector for data with linear increasing ids
-
simid
Universally Unique IDentifier (UUID)
-
ctxmap
A collection that can store references of different types and lifetimes
-
luthor
A collection of lexers for various languages/formats, and the tools required to build them
-
torro
A correct and easy-to-use BitTorrent library
-
compare
Experimental comparators for collections to be generic over
-
pi_append_vec
Only supports append vectors, lock free
-
dyn_vec
A Vec<T: ?Sized>
-
pinned_vec
Vec-like data structure whose elements never move
-
secured_linked_list
A cryptographically secured and provable linked list
-
mpt
Merkle Patricia Trie
-
maybe-cell
An UnsafeCell optionally containing a value, with the state externally managed
-
ninja-files-data
Core data structures for ninja files
-
zaplib_components
The widget toolkit for Zaplib
-
bit-index
A little-endian zero-indexed bitstring representation
-
fixedvec
A heapless version of the Rust vector type
-
wayrs-protocols
A collection of Wayland protocols to use with wayrs-client
-
ljprs_async_pool
async-friendly pool data structure using tokio
-
starbase-tools
A collection of tools created to help with ship building in the game Starbase by FrozenByte
-
hst-tw-images
working with Twitter profile images
-
ensure
target state of an object
-
fs-chunker
Turn a file into a list of chunks
-
petal-clustering
A collection of clustering algorithms
-
fast_forward
Quering collections blazing fast
-
bucket_queue
A Bucket Queue data structure that can be used as a Priority Queue
-
fastrie
Sequentialised memory-packed associative tries, buildable at compile time, useful for longest prefix matching
-
okasaki
A collection of peristent datastructures
-
visit_diff
Efficiently finding differences between data structures
-
zotero
Communicate with Zotero API
-
tetengo_trie
A trie library implemented with a double array
-
tcgeneric
Generic data types used internally by TinyChain
-
icu-data
International Components for Unicode (ICU) data in Rust structures
-
arc-swap
Atomically swappable Arc
-
puruda
Pure Rust DataFrame
-
id_collections
Index-oriented programming in Rust
-
ds-bst
Binary search tree implementation
-
bitrush-index
A serializable bitmap index library able to index millions values/sec on a single thread
-
libreda-splay
Splay map and splay set data structures
-
swap-queue
A lock-free thread-owned queue whereby tasks are taken by stealers in entirety via buffer swapping
-
brownstone
building fixed-size arrays
-
hamst
Hash Array Mapped Shareable Trie
-
multipath
split file path, like
/home/{user,admin}/file.txt
-
mkargs
Build command arguments
-
zang
A test crate which is also a collection of some libraries which I tend to use for hobby projects
-
run-loop
Run loop for thread, provide message post, deadline timer and future executor
-
crdt-sample
containing samples of crdts
-
sbbf-rs-safe
Split block bloom filter implementation
-
intervals-general
enabling general representation of and operations on intervals over generic types (e.g. supporting units of measure or arbitrary built-in types, or any type with PartialOrd implementation).
-
raii-map
Map and set types in Rust in which the presence of the entry in the data structure is tied to the lifetime of a RAII handle returned by the insertion
-
collect_result
collecting an iterator of results into a result of a collection
-
openpgp-keylist
An OpenPGP Keylist data structure
-
pinned-queue
Queue-like data structure whose elements can never move
-
mango-egui
My egui widgets
-
arrsingh
A top level crate in the workspace
-
slas
Static Linear Algebra System
-
lz_diet
An AVL balanced Discrete Interval Encoding Tree
-
hightorrent
High-level torrent library which supports Bittorrent v1, v2 and hybrid torrents
-
temporary-annex
Helper for creating temporary annex on a collection
-
luka
working with graphs
-
fix_float
Fixed floating types that allows useful trait implementations and datastructures on float numbers
-
zero_v
implementing iterators over function outputs for collections of types implementing a common trait, without using vtables/ dynamic polymorphism
-
partial
Optional monad with fake variant
-
fixed-slice-deque
A fixed size deque implementation
-
sparse-bin-mat
A sparse implementation of a binary matrix optimized for row operations
-
vf-rs
A set of classes generated from the ValueFlows RDF schema
-
restor
A dynamic resource storage system in rust
-
plurals
singular/plural forms, mostly in English
-
pl-hlist
support for heterogeneous lists (known as
HList
s), which are functional, tuple-like, strongly-typed data structures that can contain elements of differing types -
incremental-map
combinators for incremental immutable maps (see crate
incremental
) -
tinystr-raw
Raw string-to-integer conversions for tinystr
-
protect
A protected data structure
-
exosphere-core
Core crate for Exosphere
-
linked-syntax-tree
A doubly-linked syntax tree
-
bytes_to_type
facilitate byte conversion to specified types using macro generation
-
copy-range
core::ops::Range et al, but Copy and IntoIterator
-
ternary-tree-wasm
A simplified Wasm binding to ternary-tree crate
-
rusty_v8_m
Rust bindings to V8
-
pure-hfsm
A finite state machine library with a clear separation between the machine definition and its changing state
-
flow-graph
A representation of a graph data structure for flow-based programming
-
hashtree
A Merkle Tree implementation in Rust
-
foba
A test crate
-
ucd-trie
A trie for storing Unicode codepoint sets and maps
-
atomic_swapping
An arbitrary type atomic storage with swap operations
-
delay_map
HashMap collections whose entries expire after a given time
-
b-tree
A persistent B+ tree using freqfs
-
partial_const
way to handle constant and non-constant values in a unified way
-
gumbel-top-bucket
A bucket data structure that is sampled using the Gambel-Top trick, which allows for O(1) sampling from a softmax-like distribution
-
raphy
A graph data structure library
-
lazyfunctions
A collections of functions for lazy people, or highly efficient programmers
-
linear-map
A map implemented by searching linearly in a vector
-
dsll
Fast Thread Safe Doubly Sorted Linked List
-
prototty
Wrapper crate for frontend-independent prototty crates
-
batbox-android
Helper crate for android
-
expire
data structure for data maybe expired
-
ndarray-histogram
Histogram support for n-dimensional arrays
-
lambda-apigateway-response
Response object for AWS Lambda with API Gateway
-
motivations
a collection of motivating messages
-
num-bigint
Big integer implementation for Rust
-
vec-collections
Rust collections that are newtype wrappers around smallvec
-
milvus-sdk-rust
The official Milvus Rust SDK
-
win-idispatch
that aims to provide a more ergonomic way of working with idispatch in winapi based projects
-
ts-builder
Timestamp builder
-
dcl_data_structures
Data structures for for deep_causality crate
-
jec
My collection of general-purpose crates
-
cosmic_undo_2
Undo and redo done the right-way
-
struct_mapping
Token StructMapping for testing StructMapping implementations
-
building_blocks_partition
Acceleration structures for spatial queries on voxel data
-
slots
Fixed size data structure with constant-time operations
-
small-ord-set
A set data-structure represented by a sorted
SmallVec
-
collectable
Fallible, no_std-friendly collection traits
-
om2
A set of classes generated from the OM2 RDF schema (mainly Unit)
-
dinotree
An aabb space partitioning 2d tree data structure
-
rs-bush
Bush data structure
-
tinyvec_string
tinyvec based string types
-
bitsvec
A bit vector with the Rust standard library's portable SIMD API
-
fenwick
tree: data structure that efficiently calculates prefix sums in a changing array of numbers
-
short-lease-map
A map collection optimized for brief internship of values
-
rand_map
A map that creates a random handle on insertion to use when retrieving
-
apint
Arbitrary precision integers library
-
cset
Fine-grained and reversible struct transactions
-
codemap2
maintained fork of the codemap crate that contains a data structure for efficiently storing source code position and span information (e.g. in a compiler AST), and mapping it back to file/line/column locations for error…
-
dinvoke_data
Structures and data types definitions for dinvoke
-
azalea-inventory
Representations of various inventory data structures in Minecraft
-
arrayset
An array-backed ordered set type
-
kserd
Kurt's Self-Explanatory Rust Data
-
typed_graph
Staticly typed graph library
-
xml-schema
Structure generator from XSD source file
-
prometheus-tokio
A collection of tokio runtime metrics for prometheus consumption
-
anystruct
that provides traits for converting between JSON and Protocol Buffers (Proto) data structures
-
diskdata
A catalog of on-disk data structures
-
uguid
GUID (Globally Unique Identifier) no_std library
-
foliage
Abstract syntax tree for first-order logic with integer arithmetics
-
fill_canvas
FillCanvas is a wrapper around a matrix with special methods to fill the cells
-
sliced
A segmented vector for iterating over slices
-
proptest-recurse
Helper for defining mutually recursive strategies with proptest
-
zot
Option-like enums for working with ordered collections of zero, one, or two items (
Zot
), or ordered collections of one or two items (Ot
) -
naq_domain
Domain library for nordic air quality (naq) that defines shared domain data structures
-
file_graph-rs
A tiny crate to generate a tree like structure starting from a folder and branching inwards
-
atags
Parsing of linux ATAG data structures
-
irox-tools
Stuff that should have been in the Rust STL, but aren't
-
rust_fixed_width
that allows for easier manipulation of fixed width files allowing for the ability to name fields and such using specs
-
functional_vec
Owning versions of mutable Vec methods
-
pi_async_graph
async graph
-
version-lp
a version struct library for use with version comparing, and wildcard resolving
-
btree-vec
A growable array (vector) implemented using a B-tree
-
blobary
place for blobs
-
explicit-discriminant
Macro for enforcing enum discriminants
-
polars_arrow_rvsry99dx
Apache Arrow
-
applejack
Radix tree
-
motivation
A collection of motivating messages
-
sparsevec
Compress vectors using row displacement
-
rust_release_artefact
Safely extract installable files from Rust release artefacts
-
advancedresearch-higher_order_point
An experimental higher order data structure for 3D points
-
geogrid
Manipulate geographic data on a grid
-
arrsingh-lists
A test crate to test publishing
-
quantity
Representation of quantites, i.e. of unit valued scalars and arrays.
-
rs-arboretum
A study in trees
-
simple_bitfield
Create bitfields with the same memory structure as integers using a simple macro
-
trie-standardmap
Standard test map for profiling tries
-
miny
Box<T> with small value optimization
-
batbox-cli
cli interface
-
flag_set
FlagSet can process operations of the infinite complementary sets and the origin sets
-
sbf
Spatial Bloom Filter, a probabilistic data structure that maps elements of a space to indexed disjoint subsets of that space
-
lsph
Learned Spatial HashMap
-
untis
access the webuntis jsonrpc
-
mnemyme
Encode and decode integers based on the EFF large word list
-
byte-sequence
A little marco that creates structs to be used as byte sequences (for ApiKeys, SessionIds and so on)
-
handy
providing handles and handlemaps
-
ultrametric_matrix_tools
Toolbox that provides functions and data structures to generate and handle ultrametric matrices
-
raw-btree
Generic B-Tree implementation
-
rimu-parse
A data structure template system
-
gridd-euclid
euclid-compatible grid data structure (forked from Frosh_VII's gridd)
-
tree-index
Index a flat-tree
-
f1d2d2f924e986ac86fdf7b36c94bcdf32beec15
Test for XSS on docs.rs
-
nullvec
Rust nullable vector, which can contain null(missing) values as element
-
rudy
Judy array implementation in pure Rust
-
ccl_owning_ref
creating references that carry their owner with them
-
tilecoding
Dr. Richard S. Sutton's tile coding software.
-
implhm
Simplified library of collision-handling HashMaps
-
token-parser
parsing texts into data structures
-
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
-
fixed-queue
no_std, no_alloc, use [T; N]. support
Vec
/VecDeque
/History
-
kd_interval_tree
Implements a K-dimensional interval tree, for fast interval-overlap lookup. Binary-tree based implementation, i.e. O(log(n)) lookups.
-
tinysearch-cuckoofilter
Cuckoo Filter: Practically Better Than Bloom
-
petitset
An ordered set data structure, optimized for stack-allocated storage of a tiny number of elements with a fixed cap
-
sdsl
interface for the Succinct Data Structure Library
-
map1
@ErichDonGubler's fancy template for new Rust projects
-
Project2
Implementations of red black tree and AVL tree
-
dd_statechart
A Data-Driven implementation of Harel Statecharts designed for high-reliability systems
-
eclectic
Experimental collection traits
-
pin-list
A safe
Pin
-based intrusive doubly linked list -
num-bigint-dig
Big integer implementation for Rust
-
extended-rational
implementations of high-accuracy projectively-extended rational numbers and macros for creating them
-
sif-itree
immutable, flat interval tree
-
gsgdt
Generic Stringly Typed Graph Datatype
-
stackbt
A small collection of crates for game AI
-
elaru
Memory safe implementation of LRU cache
-
bitf
procedural macro to easily create a bitfield out of a struct
-
linked_lists
Different types of linked lists
-
intpack
collection of functions for packing/unpacking unsigned integers into other unsigned integers of different sizes. For example, packing 4 u8's into a u32.
-
whistlinoak
Annotated even-arity trees backed by mmaps
-
pati
Image data structure and format for the Patica editor
-
kdt
k-dimensional tree implemented with const generics
-
treers
Sedgewick's tree maps
-
pole
Flat tree data structure, as in branchless (pole) tree
-
bookfile
A container file format with chapters and an index
-
prefix_tree_map
generic prefix tree (trie) map with wildcard capture support
-
concordia
A distributed hash table based on the Chord algorithm
-
fxd
Fixed-point decimal implementation
-
identifier
Generate 128 bits id structs easily
-
nvpair-rs
Safe and rustic wrapper around nvpair
-
trie
An ordered map and set based on a trie
-
dynsequence
Sequence-Like data-structure for storing dynamically sized types
-
to_any
Auto derive ToAny trait for any structure
-
btree_monstrousity
a code port of BTreeMap but with comparator functions
-
binary_sort_tree
二叉树的new,insert,del,search等方法
-
libflow
grouping network flow data
-
model
model-based testing for data structures, with linearizability checking
-
mind-tree
Organize your thoughts in a tree-like structure
-
orx-pinned-vec
PinnedVec
trait defines the interface for vectors which guarantee that elements added to the vector are pinned to their memory locations unless explicitly changed -
tinymap
A map structure that stores its data on the stack
-
nolan
Commitlog/WAL Implmentation and Powerful Abstractions
-
tiny-artnet-bytes-no-atomic
Vendored copy of Bytes fork for use in tiny-artnet. Types and traits for working with bytes
-
faex
A fast and efficient Compact Data Structures Library
-
id-pool
Create and recycle integer ids using a ranged pool
-
proto-voxel
manipulate voxel data structures
-
mycelial-crdt
mycelial crdt
-
std_collection_traits
Abstraction of operations in std collection types
-
competitive-programming-rs
Competitive Programming Library in Rust
-
lineartree
tree data structure for rust
-
bpht
A bit-packed hash table implementation using hopscotch hashing for 32-bit keys and values
-
eirproject/libeir_ir
Erlang ecosystem common IR
-
unthbuf
Unsigned N-bit Buffer: A structure that holds a fixed buffer of
bits
-sized unsigned integer elements -
rt_vec
Runtime managed mutable borrowing from a vec
-
ritelinked
HashMap-like containers that hold their key-value pairs in a user controllable order
-
amplify
Amplifying Rust language capabilities: multiple generic trait implementations, type wrappers, derive macros
-
simple-observable
observable pointer for mutable and immutable data
-
key_set
KeySet representing concepts of All, None, Some(list), and AllExceptSome(list), with basic set calculations (intersection, difference, inverse)
-
swimmer
Thread-safe object pool type
-
data-query
Query library that allows for Querying Serializable data using string queries
-
reusable-vec
A Vec wrapper that allows reusing contained values
-
pi_phf_map
phf_map
-
bloom_filter_plus
rust_bloom_filter
-
hgg
Approximate nearest neighbor search collection
-
varlen
Ergonomic variable-length types
-
geomprim2d
2D geometric primitive types
-
courgette
Colour manipulation/conversion library
-
ttmap
Trivial implementation of type map
-
cycler
A simultainious write/read data structure
-
predicates
boolean-valued predicate functions
-
ckb_multi_index_map
MultiIndexMap: A generic multi index map inspired by boost multi index containers
-
json_tables
A structure that eases operations with a local json storage of undetermined items
-
sandpile
do sandpile computations
-
chtholly
Tree, a data structure originated from CF896C
-
graphvizier
A dot file generator
-
hpo
Human Phenotype Ontology Similarity
-
orx-imp-vec
ImpVec
, standing for immutable push vector 👿, is a data structure which allows appending elements with a shared reference -
generic-cursors
A generic way to mutably traverse acyclic recursive data structures
-
two_three
A two-three (2-3) tree implementation in Rust. Includes a map and set interface
-
variant-map
defines maps to store variants of enums
-
cursed-collections
Collections that (seem to) break Rust safety
-
rust-fp-pfds
A Functional Programming Library in Rust, Purely Functional Data Structure
-
evento-query
A collection of libraries and tools that help you build DDD, CQRS, and event sourcing
-
kvptree
a lightweight library for sending data around
-
loro-preload
Loro internal lib for loading data
-
sesstype
Multiparty Session Types
-
mismatch
abstract mismatching. Useful for error propagation.
-
construe
Compile-Time Growable Array: Vec & String for const!
-
sexpr_parser
Generic S-Expression parser
-
iodyn
An incremental collections library making use of Adapton
-
ordered-vecmap
Ordered map and set based on vectors and binary search
-
literally
Macro literals for members of std::collections
-
vfs-tools
A collection ofttools to work with VFS
-
tongrams
Tons of N-grams
-
dlist
List data structure based on AVL tree. It can store elements which have dimension and quickly search for elements by distance from 0.
-
simple_ringbuf
Ringbuf is a speedy lightweight fixed-size infinite-use collection optimized for straightforward single threaded use
-
flats
flattens nested structures into a flat single dimension map
-
twitter/rustcommon-streamstats
Statistics calculated for a stream of samples
-
vector-map
VecMap<K, V>: a Linear Search with Map API
-
transit_model_relations
Modeling the relations between objects
-
flat-zip
An iterator adaptor to help traverse two-level collections
-
evicting_cache_map
An Evicting LRU cache supporting prune hooks
-
data_structure_traits
data structure collection traits
-
incremental-topo
Data structure to maintain an incremental topological ordering over a collection of values
-
gapbuf
Generic gap buffer
-
debris
the data structure
-
benchmark-counters
Light-weight data structures to help with monitoring and benchmarking
-
python-objects
that implements the architecture of the CPython objects. with this crate you can crate a list with any data type from rust
-
know_yaml
The Know Framework for Rust
-
prefix_array
A generic container for searching on prefixes of keys
-
indexmap-nostd
A no_std compatible implementation of the indexmap crate
-
range-traits
Ranges related traits
-
qt-json
JSON library for QT
-
frbf
robust, and efficient implementation of the Bloom Filter data structure in Rust
-
latticequeries
Allows for fast hierarchical queries on Vecs
-
graphstack
Graph-structured stack
-
rstructure
A thread-safe data structure library
-
graphiti
macro dsl and builder for creating and describing arbitrary sets of related data using a serializable description type
-
mucell
A cell with the ability to mutate the value through an immutable reference when safe
-
binary-search
General binary search implementation
-
soak
Transform a struct into arrays of its fields
-
rbtree-arena
A cache friendly red black tree where nodes live on sequential memory
-
sequencetree
a new type of collection to store keys and their corresponding values
-
const_std_vec
const std vec
-
extended-collections
An extension to the collections in the standard library with various data structures
-
librualg
Collection of basic algorithms for everyday development
-
trait-map
Rust map for dynamic trait storage and references
-
recursion-schemes
cache-aware stack safe recursion (this is the really haskell brained one)
-
jsonnlp
JSON-NLP data structure
-
bsp-pathfinding
Runtime path finding using Binary Spatial Partitioning
-
pretree
package for storing and querying routing rules with prefix tree. Pretree 是一个用于存储和查询路由规则的包。它用前缀树存储路由规则,支持包含变量的路由。
-
rank1
BLIS in rust: Implements core matrix operations
-
idmap
Efficient maps of integer id keys to values, backed by an underlying
Vec
-
artsy
ART Tree data structure library
-
deferred_vector
A deferred vector implementation
-
fenwick-tree
binary indexed tree (Fenwick tree) data structure in Rust
-
crdt
Conflict-free Replicated Data Types for Rust
-
ax_banyan
Persistent indexable tree data structure
-
trie-generic
A trie with generic content
-
tsil_cev
LinkedList on Vec
-
moretypes
Named tuples, records, and more!
-
embedded-async-helpers
static
friendly helpers for async on embedded -
simple-file-manifest
Interact with lists of files through a storage-agnostic interface
-
smallbigint
Big integer types that have a small on-stack representation for small values. Uses num-bigint internally.
-
staticvec
Implements a fixed-capacity stack-allocated Vec alternative backed by an array, using const generics
-
parse_tree
A non-abstract syntax tree type
-
las
Read and write point clouds stored in the ASPRS las file format
-
arenavec
An arena backed implementation of vectors and related types
-
disjoint_set_forest
A disjoint set data structure implemented using a disjoint set forest
-
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"
-
anti-r
A spatial data structure outperforming r-trees for low numbers of elements
-
microcrates-bytes
Types and traits for working with bytes (with no_std support by default)
-
aabb-quadtree
A quadtree that maps bounding-boxes to elements
-
cumulfreqtable
A Cumulative Frequency Table implemented with a Binary Indexed Tree
-
dpc-simplemap
map with default value and compacting
-
colony
A fast associative data-structure that chooses its own keys
-
common-tree
common tree lib
-
blend-bindgen-rs
generated Blender's data structures
-
rust_twostack
Support for two-dimentional stacks for the Rust programming language
-
bitstruct
Better Bitfields
-
ranno
Annotations over recursive data structures
-
ident
wrapping types with an immutable identifier and storing/accessing such types in collections
-
field_accessor_pub
A procedural macro to get and set a struct field by String dynamically. This crate is a quick and dirty fork of field_accessor_pub.
-
multipeek
An adapter to peek at future elements in an iterator without advancing the iterator cursor
-
tracker-macros
Macros for the tracker crate
-
eztd
Quick start Rust
-
normalize_interval
Normalizing interval library
-
bittree
O(1) find functions in a special data structure called a bit tree
-
advanced_collections
advanced data structures (collections). Includes counter (hash-bag, multiset), disjoint set (union-find, merge-find), circular buffer (cyclic buffer) and interval (range)
-
causal-length
CRDT's based on causal length sets
-
m6coll
Small Smart Collections using prefix m6
-
suggestion_trie
A Radix trie for suggestion search, it allows to search for data indexed by a set of keywords fast
-
holium-rs-sdk
Holium Rust SDK
-
hash_ring
Consistent Hashing library for Rust
-
minidom
A small, simple DOM implementation on top of rxml, targeting the subset of XML useful for XMPP
-
lumberjack-utils
Read and modify constituency trees
-
forgetful
Track and forget values within a specific scope, enabling detection of repeated values
-
jirachi
A collision resistant runtime agnostic key-generator
-
abbrev-tree
highly inefficient data structure for text completion
-
nave
Thinking about the construction of distributed systems starting from the *consistent hash* algorithm
-
kodiak-taxonomy
manage generic taxonomies supporting unique features
-
shelves
Storing values referenced by a unique typed index
-
slice-cell
A
Cell<[T]>
-like mutable slice, that allows slice-like APIs -
any-range
AnyRange<T> enum can hold any Range*<T> type
-
bfilters
bloom filter implementation in Rust
-
enum-ref
Proc. macro for generating enum discriminant types.
-
xtree
general purpose tree data structure
-
scratchbuffer
A Vec<u8> like data-structure, that can be used as slices of different types
-
rustupolis
tuple space data structure in Rust
-
segment-map
A self-balancing binary search tree for mapping discrete, disjoint segments to values
-
ensf594-project-mmap
Final project for the ENSF 594 course of the University of Calgary, summer 2022
-
string-wrapper
A possibly-stack-allocated string with generic bytes storage
-
cmp_wrap
Let you compare structes by context
-
gridd
A generic, dirt-simple, two-dimensional grid
-
ndshape
fast linearization of N-dimensional array indices
-
radixt
A fast, memory-efficient radix tree implementation in Rust
-
batbox-range
Helpers for working with ranges
-
dynamic-matrix
work with matrices
-
beap
Bi-parental heap data structure implementation in Rust
-
cognitive-frames
Managing windows for
cognitive
-
old_norse_alphabet
Old Norse alphabet constants & sort for Rust
-
mtgjson
Unofficially provided lightweight models of the data provided by MTGJSON
-
quickphf_codegen
Code generator for creating static maps and sets for use with quickphf
-
fusebox
Mostly safe and sound append-only collection of trait objects
-
streamhist
streaming histogram
-
kvstructs
General basic key-value structs for Key-Value based storages
-
chtholly_tree
Rust bindings for Chtholly Tree
-
bounded
numeric types
-
rust-datastructures
some datastructures in rust
-
blocklist
The project is based on blocklistproject. It provides perfect hash map/set structures for fast lookup of blocklisted items.
-
front-vec
Efficiently-prependable Vec and String types
-
unrolled-linked-list
unrolled linked list in rust
-
field_accessor
A procedural macro to get and set a struct field by String dynamically
-
spectacle
Opt-in runtime introspection
-
batbox-collection
Collection of identifiable objects
-
roaring_bitmap
Roaring bitmap data structure implemented in Rust
-
memcell
providing a MemoryCell struct, which stores a current and previous value
-
anat-rs
represent natural numbers as well-founded sets
-
u64_array_bigints
biginteger library based on u64 arrays
-
typed_id
Make your IDs strongly typed!!
-
bonzai
An abstraction for optimizing the memory layout and pointer aliasing of trees
-
seq
The module 'seq' provides the lightweight, generic sequence container 'Seq' for unmovable data and is embedded into the program during compile time
-
p8n-types
Basic types for representing binary programs
-
asdl
Parser for ASDL format. Describes the abstract syntax of compiler intermediate representations and other tree-like data structures
-
algotrees
VERY early stage project to implement a library of algorithms and data structures in Rust. It has very little features and only supports one data structure (binary trees) at the moment…
-
dynarg
mechanism for dynamic robust argument handling
-
data-buffer
low-level data buffer type useful for IO and in homogeneous collections
-
cycle_map
Implementations of bi-directionally accessible hashmaps
-
mini-linked-list
A package containing a minimal i32 LinkedList implementation
-
uset
set and a map designed for speed, with unsigned integers as keys
-
simple-ref-fn
function wrappers that do not require virtual tables
-
indexed-bitfield
An indexed bitfield, to track presence or absence of up to 128 elements
-
intersection
Find the intersection over a collection of sets; when you need more than the intersection between two sets
-
cess-sp-core
CESS Storage Proofs - Core parts for proofs of storage
-
ensured_bufreader
A Bufreader ensures N bytes in buffer
-
unflatter
unflatter
is a Rust library providing extension traits for flattening and unwrapping nested structures, including nestedOption
andResult
types. It simplifies working with deeply… -
roaring-graphs
Graph data structure backed by roaring bitmaps
-
go-heap-rs
Golang's heap written in Rust
-
object-chain
Ad-hoc structure builder
-
la-arena
index-based arena without deletion
-
madeleine
Transparent object persistence with predefined operations and state containers
-
ramp_table
RampTable, a data structure useful for certain specialized situations
-
binartree
Binary Tree realisation
-
ulid-generator-rs
generating ULIDs
-
hash-unionfind
Union-Find data structure
-
disjoint-set
Tarjan's Union-Find Data Structure
-
exclusion-merkle-cbt
Complete Binary Merkle Tree for verify exclusion
-
foxy_util
Util for
foxy
-
static_merkel_tree
Static Merkel Tree is dedicated for generating Merkle Root and Merkle Proof for a static list of items
-
pds
Probabilistic Data Structures efficiently implemented in Rust
-
push-while-ref
push while having a reference
-
setting
The styles of all graphics elements
-
arenas
Arena data structure for efficiently adding & removing items with stable IDs
-
modql-macros
Macros for modql. Not intended to be used directly.
-
mexset
Implementing a set with MEX support
-
ati
Introduces the
At
trait, which allows collections to be indexed byu|i{8,16,32,64,128}
andisize
. Supports Python-like negative index, where -1 is last element. -
comprehend
Python like list, set and hashmap comprehensions via macros
-
rust-bloomfilter
bloom filter implementation in Rust programming language
-
hashbrown_tstd
port of Google's SwissTable hash map
-
tree-rizzen-yazston
Tree Library using the Any trait for data
-
indexed_vec
IndexVec
fromlibrustc_data_structures
-
pinned-bucket
Mutable container for pinned and immutable items
-
bipbuffer
Simon Cooke's Bip-Buffer
-
zallocators
Bringing Zig like allocators to Rust
-
unstorable
An interface for requiring that a type is only used on the current stack frame
-
rope_rd
A Read/Seek rope implementation
-
siraph
A node-based digital signal processing crate
-
skippable_map
deserialize wrapper around HashMap which skips non-conforming data
-
free-ranges
An efficient data structure for keeping track of indices which are either free or not
-
dsu-tree
A non-invasive disjoint-set-like data structure implementation
-
tree-cursor
non-intrusive tree cursor that supports node mutation without Cell/RefCell
-
solomondb
An embedded and distributed Gremlin-compatible graph database
-
vector2
2D vector library
-
wasmflow-interface
Types used by the Wasmflow tool chain
-
grid_trait
2D and 3D grids with combinators
-
grid2d
Two dimensional grid of runtime-defined, but unchangable size
-
gpt_disk_io
GPT (GUID Partition Table) disk IO no_std library
-
owned_chunks
a collection of traits and iterators to get owned chunks from collections
-
banyan
Persistent indexable tree data structure
-
guzzle
A derivable trait for consuming key value pairs into structs
-
packedvec
Store vectors of integers efficiently
-
at-collection
Collections with minimum or maximum number of entities
-
amazed
A graph maze building library
-
minivec
A version of Vec that's only the size of a single pointer
-
vec-option
A space optimized version of
Vec<Option<T>>
that stores the discriminant seperately -
snowflake_me
A distributed unique ID generator inspired by Twitter's Snowflake
-
vec-string
To print Vec<Display>
-
structdb
Persistent data structures using RocksDB
-
char_index
efficient charwise indexing into a string
-
version-rs
A struct for Versions, with the methods you expect
-
iron_rose
Invertable Bloom Filters & Strata Estimators as found in https://www.ics.uci.edu/~eppstein/pubs/EppGooUye-SIGCOMM-11.pdf
-
librqbit-clone-to-owned
Util traits to represent something that can be made owned and change type at the same time
-
hat_trie
A hat-trie implementation that support prefix match iteration
-
fsort
sort files in a fast, OS-independent and 'rusty' way
-
htmldom_read
HTML reader that parses the code into easy-use tree
-
pasture-derive
Macro implementations for #[derive(PointType)]
-
blocked-vec
A vector of byte blocks behaving like files
-
isl-rs
Rust bindings for Integer Set Library
-
rc-slice2
Reference-counted slices with easy subdivision
-
linked-list
An alternative implementation of std::collections::LinkedList
-
dimension_shiftable_buffer
A dimension shiftable buffer
-
gawires-diff
Gawires binary diff library
-
domain-lookup-tree
A tree structure in Rust optimized for looking up domain names, with wildcard support
-
treemap
Squarified Treemap algorithm
-
mqf
MQF, Mixed Quotient Filter, is a variant of CQF (Counting Quotient Filter)
-
offset
Glorified offsets for arbitrary structures
-
enum-tag
Proc. macro for generating enum discriminant types.
-
take-some
that provides a way to obtain *some* value from various collections
-
hdf5-dst
DST extensions for HDF5
-
ttm-rs
CLI to turn tuples into adjacency matrices
-
u64_array_bigints_core
Core library for
u64_array_bigints
-
bitmac
Structure for accessing to single bits
-
solana_libra_canonical_serialization
Libra canonical serialization
-
building_blocks_mesh
Fast meshing algorithms for voxel data structures
-
unsized_enum
Unsized enum implementation
-
last-git-commit
wrapper arround git2-rs to get info about the last commit. Useful for when you want to show the git hash in a program.
-
fplist
An immutable, persistent, singly-linked list
-
expanding_slice_rb
A self-expanding ring buffer similar to VecDeque optimized for working with slices of data
-
tagged-tree
A tree-like data structure where the values are tagged
-
ringbahn
an experimental safe API for io-uring
-
easy_strings
Ergonomic, garbage collected strings for Rust
-
plain-map
map that uses small_vec as backing storage, which is useful for having many tiny maps. For storing non-Copy types please use v1.x which is also supported.
-
id-set
A bitset implementation that stores data on the stack for small sizes
-
set-trie
A trie for fast subset and superset queries
-
cs-fetcher
Candlestick fetcher
-
pq-bincode
A wrapper crate of queue-file for bincode serializable structs
-
btree_monstousity
a code port of BTreeMap but with comparator functions
-
graphlib
powerful rust library for the graph data-structure
-
unsized-stack
Fast heterogeneous / unsized stack
-
dense_bitset
A variably sized, heap allocated, dense bitset implemented using no
unsafe
code -
vec-btree-map
Basically just a sorted Vec that can be used as a HashMap
-
store-interval-tree
A balanced unbounded interval-tree in Rust with associated values in the nodes
-
quickscope
Multi-layer HashMap and HashSet implementations for performant representation of variable scopes
-
valet
Stores your objects and gives you a tag to retrieve them later
-
checked
Implements a wrapper over the primitive Rust types that better indicates overflow during arithmetic
-
rustifact_extra
Extra features for Rustifact
-
insrcdata
Embed static data as source code
-
more_ranges
Range types not provided in the standard library
-
tc-state
TinyChain's general state enum
-
polars-ad-hoc
Polars
-
tensorism
Multidimensional arrays with bounds included in the type system
-
automatic-relations
Tree automatic relations
-
prust_core
encoding/decoding PUS-C packet data structures with ease
-
moka-cht
Lock-free resizeable concurrent hash table
-
hashheap
data structure that combines a hashmap and a min/max priority heap, with main operations requiring O(1) or O(log n) time
-
bucket_vec
A vector-like data structure that guarantees to never move its contained elements
-
rimu-eval
A data structure template system
-
sortedcontainers
An experimental sorted data structure
-
header-slice
Definitions for slices with headers, and a vec-like type with a header allocated inline
-
cartesian-tree
Construct a Cartesian Tree from a Slice in Linear Time
-
hamt-rs
A Hash Array Mapped Trie implementation based on the *Ideal Hash Trees* paper by Phil Bagwell
-
do_util
Discrete Optimization utilitary library (data-structures)
-
fieldfilter
trait that lets you filter stuff!
-
routee-compass-core
The core routing algorithms and data structures of the RouteE-Compass energy-aware routing engine
-
dag-cbor-references
Extract blake3 ipld links from dag-cbor blocks
-
pure_ref
making immutable references only
-
batbox-diff
Easy struct diffing
-
utah
dataframe structure and operations
-
negatable-set
Wrapper for sets that allows full boolean operations including negation
-
alg_ds
Algorithms & data structures
-
sbom-walker
work with SBOM data
-
stride
A strided slice type
-
dyobj
improved version of the ECS pattern
-
static-box
A stack-allocated box that stores trait objects
-
extract_map
A HashMap for memory efficent storage of value types which contain their own keys
-
outils
Graph and tree data structure library. Providing utilities which aren't easily available in Rust.
-
retrace
Safe, generic rollback log with predictable latency
-
bytes-quilt
data structure for tracking random-access writes to a buffer
-
typemap_core
A no_std typemap with trait-based value-presence guarantees (on nightly)
-
tournament-kway
k-way merge using a tournament tree
-
spigal
fixed-length ring buffer implementation, intended to be no-frills and easy to use, especially for embedded applications
-
collect-mac
collect!
macro, which can be used to easily construct arbitrary collections, includingVec
,String
, andHashMap
. It also endeavours to construct the collection with a single allocation, where possible. -
stavec
Stack-allocated vector with static capacity
-
hprtree
A Hilbert-Packed-R-Tree implementation for rust
-
lazy_concat
Lazy concatenation for Strings and Vecs
-
segmentmap
A collection that maintains insertion order
-
recursor
To iterate is human, to recurse divine
-
pin_array
Tiny crate providing an array with structurally projected pinning
-
cds
Collection of Optimized Data Structures
-
cbor-tag-index
Tag index
-
mvbitfield
Generates types to work with bit-aligned fields
-
collection_literals
macros for initializing std::collections
-
hopscotch
A FIFO queue for efficiently hopping and skipping between tagged items
-
xio_base_datatypes
XIO base data structures
-
ov
a collection of traits that allow you to chain off of anything
-
hdf5-hl
High level bindings to HDF5 High Level API
-
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.
-
charcoal
Implements tree data structures and interfaces to work with them
-
traitgraph-tsplib-io
Functions to read and write graphs in TSPLIB format
-
priority-set
A no_std Priority Set
-
lhlist
Labeled heterogeneous lists
-
art
adaptive radix trie
-
smt_map
A uint-to-uint map backed by Sparse Merkle Tree (SMT), which supports generating Merkle Proofs of key-values
-
cacaos
Core library for CACAO traits and data structures
-
sortedlist-rs
A fast sorted list data structure in rust
-
inplace-vec-builder
Build a vec from a vec, in place
-
ttl-queue
A queue that drops its content after a given amount of time
-
bounded-vec-deque
A double-ended queue|ringbuffer with an upper bound on its length
-
read-write-pipe
A trait for objects implementing Write, to write all content from a Read object
-
higher-cat
Functors, Applicatives, Monads and other bad ideas
-
erased-type-arena
A type-erased allocation arena with proper dropping
-
simple-tree
Create, edit and iterate over tree structures
-
enum-map-derive
Macros 1.1 implementation of #[derive(Enum)]
-
collect
An experimental extension of std::collections
-
recursive_array
arrays using recrusive data structures to avoid limitations of the rust compiler
-
be-tree
B𝛆 Tree library in Rust
-
const_enum_map
Get const value from enum handle
-
decoded-char
wrapper to keep track of the original byte length of a decoded character in the encoded source file
-
weakheap
Weak Heap data structure implementation in Rust
-
libnv
Safe and rustic wrapper around libnv-sys
-
disjoint-hash-set
A disjoint set / union-find data structure suitable for incremental tracking of connected component identified by their hash
-
double-map
A HashMap with double key to single data/value
-
pathtree
An immutable tree data structure for fast path operations
-
dot_json
Tools for dot map representations of serde_json Maps
-
cli_tree
A CLI tool to generate a tree of user defined nodes
-
enum_meta
Add metadata to Enum Variants
-
linked_list_c
Safely work with c compatible linked lists
-
dependency-graph
building and resolving dependency graphs
-
many-to-many
creating many-to-many data structures with the ability to query either side, useful for applications such as pubsub. Like a fusion between
bimap
andmultimap
. -
orange-trees
Tree data structure with several methods to query and manipulate nodes
-
trailer
Store a type with an associated buffer in contiguous memory
-
qt-json-rs
JSON library for QT
-
stable_bst
An ordered map and set based on a binary search tree. Works with stable Rust 1.9.0.
-
merkle_light
Light merkle tree implementation with SPV support and dependency agnostic
-
fastdivide
partial port of libdivide. It makes it possible to reduce the cost of divisions.
-
orbweaver
building query-able graph structures
-
fp-collections
An alternate collections library for rust
-
ast2str-lib
pretty-printing ASTs and other recursive data structures
-
pqueue
Priority Queue for Rust
-
hashable_rc
Hashable wrappers for reference countings
-
veho
a iterable toolset
-
vector_mapp
A Vec based map
-
id-map
Data structure of values indexed by IDs
-
dotreds-binary-heap-plus
Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps. Makes some previously internal function public
-
pui-arena
Generalized Arenas that can be used on
no_std
-
dgrambuf
A fixed capacity ring buffer for datagrams (byte slices)
-
an-rope
an rope for large text documents
-
pi_slotmap_tree
A tree structure implemented by dense memory linked list
-
bidirectional-map
A two-way map data structure for small keys and values
-
lockfree-cuckoohash
lockfree cuckoo hashmap
-
numeric-array
Wrapper around generic-array that adds efficient numeric trait implementations
-
taskforge
Task management shared functions and structures for the taskforge family of tools
-
passive
A trio of marker traits to classify passive data structures
-
chainmap
mutability of intermediate maps
-
bitsetium
One stop shop for all bitset needs
-
apid
Collection of type definitions from several APIs
-
tapestry
Generic 2D grid data structure and utilities
-
quarkrs
A collection of small life improvements for rust
-
fcsd
Front-coding string dictionary
-
array2ds
Package for handling sized 2d arrays in rust, without the usage of the keyword unsafe cuz why not
-
batbox-logger
logging
-
jmt-blake3
Jellyfish Merkle Tree based on BLAKE3 hash function
-
indexed_bitvec
An indexed bitvector with (hopefully) fast rank and select operations
-
truetree
Trees in Rust
-
strchunk
Data types for working with UTF-8 text in I/O
-
multi-stash
Vector-based arena data structure that reuses vacant slots
-
char-list
A persistent string type with the same API as a linked-list of characters
-
schemes
cache-aware recursion schemes in rust
-
shared-string
Split a string without another allocation
-
collection
Deterministic, copy-on-write balanced search trees
-
indexed_json
Index json files like a database
-
treelike
A trait to abstract over trees, and simplify implementing them, all in one handy crate
-
shifted_vec
A growable datastructure with positive and negative indexing built on top of
std::vec::Vec
calculating the offset automatically -
collectivity
Generic collection traits
-
rustgym
solutions
-
head
Common types with inline headers, such as HeaderVec for Vec
-
deepmesa
fast Data Structures and Algorithms in Rust. Every data structure is hand crafted for performance, well tested and has an extensive API.
-
higher_order_point
An experimental higher order data structure for 3D points
-
crdt_rs
work with Conflict-free replicated data types (CRDT) in Rust
-
component_table
Data structure for associating data with entities in an Entity Component System
-
loro-common
Common types and functions for Loro. This is an internal lib of Loro.
-
bit-long-vec
Vector with fixed bit sized values stored in long
-
calcit_fingertrees
(Calcit fork of )Immutable persisten
fingertrees
-
st_ring_buffer
A fixed-size String implementation using a ring buffer
-
prioq
Priority Queue implemented using std::collections::BinaryHeap
-
fusefilter
No alloc membership approximation
-
compressed-sparse-fiber
Compressed sparse fiber implementation for Rust
-
offset-views
Create and index offset views of arrays, slices, strings, etc
-
parity-hash
A collection of fixed-size byte array representations
-
dfb
Dynamic-Fifo-Buffer, like AnyMap but uses a VecDeque to store values and treats access as a Fifo
-
include-lua
that allows the embedding of a lua source tree into a Rust application binary
-
another_radix_trie
Rust built radix tree library
-
cyclic_data_types
Cyclic data types are series of structs, enums, types and functions to create a series of fast data types
-
insert_multiple
insert multiple items into a stream in reasonable runtime
-
same_elements
Function to test if two collections contain the same values
-
theban_interval_tree
Interval Tree implementation
-
k-bucket
Kademlia DHT K-bucket implementation as a binary tree
-
trips
generic triple store written in Rust
-
sliding_window
A fixed size, heapless sliding window
-
internode
Smart references to your graph nodes
-
hodgepodge
enums
-
opt_vec
A wrapper around Vec<Option<T> that makes deletion fast
-
int_ranges
ranges tools for integer
-
neighborgrid
A 2-D grid datastructure with easy to use iterators and adjacent cell methods
-
bloom_filter_plush
rust_bloom_filter
-
fremkit
broadcast log
-
prefix-tree
A map and set interfaces using trie data structure
-
pathtrie
A specialised trie for paths in the style of a Patricia or radix trie
-
plum
Probabilistic data structures for rust
-
apter
Trees in Rust
-
hyper-tree-router
Routing middleware for Hyper http library using Prefix tree (trie) for path finding
-
vhr_serde
A serde (de)serializer crate for the simplist possible binary format
-
bucket
Offers a very simple container for any value without mutation
-
general_storage
Interface to persistent storage
-
arraylist
wrapper built on top of rust vector implementation. Taste like Java Arraylist, and intuitive to use like Python list and JavaScript array.
-
skew-forest
Skew-binary random access lists
-
freezable
immutable data
-
seg-tree
segment tree library
-
miniqueue
A minimalistic single-thread job queue based on fold/reduce
-
nibble_vec
Vector data-structure for half-byte values
-
boxed_array_ringbuffer
A ring buffer of fixed size, that uses a boxed array as storage, therefore avoiding re-allocations when converting from Vec or to VecDeque
-
async_value
persistent, asynchronous values
-
bitsets
BitSet implementations: Dense, Compressed, Memory-Mapped, and Roaring
-
mikel_binary_tree
search binary tree implementation in rust
-
flex-algo
Rust commonly used data structure and algorithms
-
periodic-rs
Bounded datastructures
-
rimu-ast
A data structure template system
-
dst
Data structures for DSTs
-
automerge-persistent-sled
A sled adapter for persisting Automerge documents
-
fibheap
but actually useful Fibonacci Heaps
-
bigsi_rs
A in-memory implementation of a BIGSI-like data structure
-
mycelium-bitfield
Structured bitfields, courtesy of Mycelium
-
cola
A text CRDT for real-time collaborative editing
-
clampf
Clamped floating-point types
-
bmap
A bitmap with an internal counter
-
stackvector
StackVec: vector-like facade for stack-allocated arrays
-
pipebuf
Efficient byte-stream pipe buffer
-
onigiri
handling chars
-
gtrie
Generic trie implementation with a support of different key and value types
-
prefix_sum
prefix sum data structure
-
traitgraph-dimacs-io
Functions to read and write graphs in DIMACS format
-
dashmap-shard
port of Google's SwissTable hash map
-
tadm
A collection of algorithms and data structures wrote out while reading The Algorithm Design Manual book
-
prust-lib
Persistent & Immutable Data Structures in Rust
-
uniqueid
Generates a unique hash/identifier for a system given a set of parameters
-
im_interval_tree
An immutable data structure for storing and querying a collection of intervals
-
btree_dag
A generic DAG (undirected graph) data structure
-
holyhashmap
A hash map with stable indices
-
pegitan
A bunch of random algorithms library
-
gsrs
Generic Self Referencing Struct
-
history_stack
A collection of containers that support generic history tracking mechanisms
-
staticsort
Implements a macro providing a compile-time quicksort function for arrays of any length, containing any primitive Copy type with a PartialOrd implementation
-
flowerbloom
fast bloom filter implementation with thorough documentation and tests
-
phf_mac
Compiler plugin for perfect hash function data structures
-
fricgan
performing basic input and output on bytes
-
flow_arena
A HashMap managed Graph Model with the concept of ownership
-
rubbl_visdata
Preliminary work on generic data structures for radio interferometric visibility data
-
rs-bucket-filter
Skips slow scans using cache, bloom filter,
-
hashed
type you can convert any hashable type into and still do equality checks on
-
rubbl_fits
Core support for the FITS container format in the Rubbl framework
-
street_index
small utility crate for working with road name / street indexing for cartographic purposes
-
ahtable
Array Hash Table implementation
-
chunked-bytes
A rope-like non-contiguous buffer for efficient data structure serialization and vectored output
-
len-trait
Len trait for collectons
-
compacts
compact data structures
-
iostream
the project is rust io stream.you can easily use it to manipulate files stream and memory stream
-
numas
multidimensional array for efficient computing
-
eitherq
Queue which support two different types
-
dynamic_graph
graph processing
-
fastgraph
Graph abstraction providing a generic interface and powerful parallelized traversals
-
victor_tree
Victor makes vectors
-
trashmap
A HashMap and HashSet that operate directly on hashes instead of keys, avoiding rehashing
-
regroup
regrouping arrays
-
heapq
Priority Queue with scoring function
-
iunorm
Map normalized floating-point numbers to/from (un)signed integers
-
simple-bitrange
manipulating bit ranges which is common when working with IC registers
-
btree_network
A generic network (undirected graph) data structure
-
multi_mut
Methods on HashMap and BTreeMap for safely getting multiple mutable references to the contained values
-
byte_trie
A compressed trie based on bytes with some weird child node bucket sizes
-
bloomy
Bloom filter using only two hash functions
-
bittyset
A BitSet type for manipulating bit sets
-
lib_code
Add two integers
-
tranche
Tranches are an alternative to slices
-
modular-bitfield-ordering
Provide u8be..u128be, u8le..u128le for modular-bitfield
-
semver-store
An HashMap structure that uses semver strings as keys
-
bytes-expand
Types and traits for working with bytes
-
c_linked_list
handling NULL-terminated C linked lists
-
stable-bloom-filter
A Rust-implementation of a stable Bloom filter for filtering duplicates out of data streams
-
stacking
using a stack datastructure in rust
-
murmurhash64
MurmurHash2 (64bit version)
-
repc
APIs to calculate the layout of C types
-
flashtext
algorithm to search and replace keywords in given text
-
map-trait
Generic Map trait
-
rs-collections
generic collections (no dependency on std)
-
sac
A macro for constructing collections
-
flit
Bloom filter backed by xxHash
-
algods
A collection of data structures and algorithms
-
mut-binary-heap
Enhanced version of std::collections::BinaryHeap that supports increase and decrease key, max, min, and custom-order heaps
-
awint_core
Core no-std and no-alloc
awint
functionality -
graphed
implement graph-based functionality
-
enum-set
A structure for holding a set of enum variants
-
bs
bitset with small-set (single-word) optimization
-
compressed_map
'Static functions': compressed maps with the keys removed
-
lilbits
Super fast u8 set (ie bitmap) relying on the assumption that elements are <= 63
-
gentrix
that adds the Matrix typed using generics that is basically a wrapper around a 2D Vector
-
lobby-queue
Const-size queue-like data structure
-
sbf-blake3
Spatial Bloom Filter, a probabilistic data structure that maps elements of a space to indexed disjoint subsets of that space
-
tree-automata
Term Rewriting Systems
-
moonlight_collections
Collections for Rust
-
btree-map
A data structure for storing and manipulating fixed number of elements of a specific type
-
indexmap-amortized
hash table with consistent order and fast iteration. The indexmap is a hash table where the iteration order of the key-value pairs is independent of the hash values of the keys. It has the usual…
-
rs_trie
My first Rust crate. A simple implementation of a Trie datastructure with a struct and linked lists. Not intended for serious use.
-
nom-midi
Parse a simple midi file into data structures using nom
-
bloom
Fast Bloom Filter and Counting Bloom Filter implementation
-
sized-vec
Type level sized vectors
-
lightning-containers
A set of lock-free data structures
-
alo
ALO means At Least One. It could contain any number of item like
Vec
but it does not heap allocation if it contains only one item -
mapro
A tiny macro library for creating std::collections
-
hitree
Indexable containers for Rust: HiSet and HiMap
-
pokeapi-model
Data structures for PokéAPI v2
-
dynamization
Fast insertion for static containers
-
crdt-list
Abstract CRDTs for lists
-
tapa-trait-serde
A collection of Tapalogi's reusable crates
-
bellpepper-core
Core elements for a SNARK Circuit library
-
range-split
splitting sequences with range parameters
-
vec_key_value_pair
A drop-in replacement for std::HashMap that uses Vec on the backend
-
phf_macros
Macros to generate types in the phf crate
-
const_queue
A stack-only, no_std queue using const generics
-
ego-binary-tree
Binary tree API built by wrapping ego-tree
-
ascii_num
digit to ascii numbers
-
csf_benchmark
The program for benchmarking Compressed Static Functions
-
regex-map
Associative container where the keys are regular expressions
-
fallacy-hash
fallible hash collections
-
algo
Algorithms & Data Structure implementations
-
smolbox
Like a Box, but small objects are stored on the stack
-
terms
Tree terms and patterns data structures
-
doubly-linked-list
double link list
-
ommui_data
OMMUI data structures
-
serde-ordered-collections
Ordered serialization/deserialization serde functionality
-
simple-octree
octree implementation written in Rust
-
queueue
Queue-like data structures used in rCore
-
binary-data-schema
Meta language for raw binary serialization
-
graphrepresentations
providing efficient abstract implementations of different graph representations
-
final
Wrap a value in a type that does not give out mutable references
-
froggy
prototype for the Component Graph System programming model. It aims to combine the convenience of composition-style Object-Oriented Programming with the performance close to Entity-Component Systems
-
string-err
String error type
-
serde_fs
[De]serializing data structures as files
-
gap_query_interval_tree
that provides a gap-query optimized interval-tree data-structure
-
leonardo-heap
Heap structure supporting fast in-place partial sorting
-
bitstr
contiguous sequence of bits in memory
-
non-empty-vec
NonEmpty
vector implementation, ensure non-emptiness by construction -
tiny-interner
Easy to use string interner with fast access to underlying strings and minimal memory footprint
-
packed-integers
A growable array for integer types in the range
u1
tou31
-
slicedvec
A segmented vector for iterating over slices
-
lineup_rust
queue implementation in Rust. This is a learning and a hobby project and is not intended for production use.
-
closures
Abstraction for seperating code and state in closures
-
building_blocks_core
The core data types for defining 2D and 3D integer lattices
-
sortbuf
Data structure for sorting large numbers of items
-
svec
Dart-style list in Rust
-
nopetgraph
Graph data structure library. Provides graph types and graph algorithms.
-
map-of-indexes
A compact key-value map for unique but not dense indexes
-
unrecurse
Helper crate for rewriting your recursive code in iterative way
-
hash-chain
A tiered hashmap and hashset implementation that allows for easily representing lexically scoped variables
-
rotated-array-set
An ordered set supporting O(1) rank and O(√n) inserts and deletes
-
automap
pattern to implement key-value maps where the value type contains the key type
-
nclist
finding overlapping intervals using a nested containment list
-
splay
native implementation of a Splay Tree for Rust. Splay Trees are self-balancing binary search trees which adapt dynamically to lookups over time to allow common access patterns to frequently have better than log(n)…
-
golomb-set
A Golomb Coded Set implementation
-
ring_queue
A double-ended queue implemented using a vector that reuses space after elements are removed
-
bytesstr
An immutable reference-counted UTF8 String
-
udgraph
Universal dependency graphs
-
hubs
The horribly unsafe buffer structure
-
data_structures_SD
collection of data structures. In other words a collection of ways to handle your data in your code and/or program.
-
btreelist
A list data structure that has efficient insertion and removal in the middle
-
id-vec
Simplify Graphs in Rust. Introduces IdVec, which automatically creates Ids for each new object, reusing deleted Ids.
-
tampon
Contains SAFE Rust functions, macro and trait to serialize / deserialize data structure and/or object and generate buffer
-
gvec
Very simple implementation of generational indexing for vectors written in Rust
-
local_vec
fixed-capacity vector allocated on the stack
-
assoc
Treat vectors like associative arrays
-
hashmap-entry-ownable
Variation of HashMap::entry() that accepts borrowed forms of keys
-
stack-array
A data structure for storing and manipulating fixed number of elements of a specific type
-
hex-string
a data structure for managing hex strings in both string and byte vector representation
-
prototty_storage
Interface to persistent storage
-
atb
lock-free triple buffer
-
box-collections
A no_std compatible implementation of the queue crate
-
provenance
Container structures that generate key upon insertion that only works with the map that generated it
-
merkle-search-tree
A data structure for efficient state-based CRDT replication and anti-entropy
-
ngds
Rust bindings for AVFounation
-
grafana-dashboard
grafana import/export data serializable structures
-
atom_table
Assign easy-to-handle typed IDs to large, hard to handle things like strings
-
thin_str
A string type that’s smaller than
Box<str>
or String -
congruence
closure
-
kappendlist
Append to a growable list in O(1) without needing &mut
-
transient_map
Hashmap with eviction of unused elements
-
radixdb
a radix tree data structure for in memory or zero copy on disk storage
-
banyan-utils
work with banyan trees
-
index_many
A proof of concept for indexing an slice at multiple locations at once
-
unempty
Non-empty data structures for Rust
-
simha-bst
My custom binary search tree implementation
-
priority-matrix
A matrix that supports per-row, per-column and whole-matrix maximum key queries
-
thin-string
A String with a smaller stack footprint
-
mmap_json_file
parse, count, filter JSON files using memory mapped io library
-
batching-queue
An Israeli Queue implementation
-
simple-stack
linked list-based implementation of the Stack data type
-
altdeque
An alternative deque implementation
-
locale-decoder
Parser and data structure for dealing with locale strings
-
indexvec
Simplified copy of rustc's index crate
-
compactmap
Compact Vec-based map that choses assigns IDs for your values on it's own. Very similar to Slab.
-
hv-alchemy
Heavy Alchemy - the black arts of transmutation, wrapped for your safe usage and enjoyment
-
linked_lista
LinkedList data structure
-
persistent_rope
An immutable persistent rope data structure
-
csgo-gsi-payload
Data structures for CSGO Game State Integration
-
isomorphism
2 directional hashmaps
-
flexible-string
A stack heap flexible string designed to improve performance
-
lattice-graph
Set of Lattice(Grid) based Graph Structures
-
stacked
Stack-allocated data structures. This was a good learning experience, and these container types work well, but in the end, I was not able to beat the performance of Vec
-
slice-deque
A double-ended queue that Deref's into a slice
-
sharedvec
A fast but limited collection for storing values of a single type
-
dynvec
DynVec
type that acts like a vector to store any datatype -
louds-rs
High performance LOUDS (Level-Order Unary Degree Sequence) library
-
partial-array
potentially partially-filled arrays
-
const-vec
Vec-like data structure with immutable push method
-
rbloom
efficient and minimalistic bloom filter
-
inexor-rgf-model-binary
Inexor - Reactive Graph Flow - Model - Binary
-
one-stack-vec
OneStackVec could contain any number of item like
Vec
, and it does heap allocation only when it contains more than one item -
dirty
Holds a value with a dirty flag which is set on writes and cleared on clear()
-
jagged_array
Owned
[[T]]
-like 2D array where each row can differ in length -
toboggan-kv
abstraction layer over multiple KV stores
-
capillary
HashMap-like storage of key-value pairs, but allowing for step-by-step (partial) search of value
-
handlebox
A map-like collection that reuses unused keys
-
pointer-value-pair
A pair of a pointer and a small integer packed into a pointer-sized object
-
rb
A thread-safe ring buffer with blocking IO
-
r-collections
Created some collection example LinkedList, Stack and Queue
-
static-bytes
Bytes for embedded devices
-
bitstring
traits and implementations
-
comprende
Python-style collection comprehensions in Rust
-
tibitset
bitset replacement for HashSet
-
kurve
Adjacency list graph data structure
-
cseq_benchmark
The program for benchmarking compact sequences and bitmaps
-
collections-more
Common data structure and algorithms for rust-lang to complete the already excellent std::collections
-
hoop
Fixed ring buffer that allows non-consuming iteration both ways
-
quetta
Immutable, reference-counted strings for rust
-
transiter
An Iterator suitable for navigating recursive structures and DAGs
-
option_vec
Vec<Option<T>>-like container
-
pyrpds
Python Wrapper for Rust Persistent Data Structures
-
fera-graph
Graph data structures and algorithms
-
containerof
Macros and traits facilitating the use of intrusive structures in Rust
-
sss_fft
FFT and IFFT for arrays and iterateable collections with modular algorithm interface
-
svg-path-parser
Generate a list of points from SVG path strings
-
fral
Functional random-access lists
-
raw-vec
A Raw utility for managing contiguous heap allocations
-
pq-tree
consecutive ones property (C1P) and graph planarity testing
-
trie-rs
Memory efficient trie (prefix tree) and map library based on LOUDS
-
event-queue
crates.io için bir paket nasıl hazırlanırın ele alındığı öğrenme amaçlı modüldür
-
sorted_vector_map
maps and sets backed by sorted vectors
-
vec-2-10-10-10
A 32-bit vector, where 2 bits are dedicated for alpha, and 30 bits are dedicated for color. Compatible with GL_UNSIGNED_INT_2_10_10_10_REV vertex attribute format.
-
string_stupidify
Collection of helper functions to format strings in unusual ways
-
xio_instructionset
XIO instructionset data structures
-
transit_model_collection
Manage collection of objects
-
dynstr
A string implementation optimized for manipulations
-
immutable-seq
Immutable sequence data structure
-
ndcopy
Fast N-dimensional array memcpy
-
intrusive-containers
intrusive data structures
-
hff-core
Hierarchical File Format: core structure
-
freezie
small library that disables mutation for the contained type
-
rimu-meta
A data structure template system
-
associative_positional_list
AssociativePositionalList is a list-like container in which each value is associated with an index, but unlike other list containers, the index for a value can be determined efficiently
-
succinct_vec
A Vec-like datastructure with less memory overhead
-
xdag
DAG(Directed Acyclic Graph) lib
-
html-types
HTML Data structures
-
nuit-core
Core structures and traits for Nuit
-
datastructures
A variety of data structures for learning purpose
-
map-to-const
Easily convert HashMap<K, V> to constant [(K, V); N] values
-
arrow-select
Selection kernels for arrow arrays
-
nanovec
Arrays and Vec-likes of small integers packed in an integer or two
-
sot
Object Tree
-
mofurun
Multi variant Optimized Fun U....okay Mofu is just a cute name okay. Experimental implementation of Vec that stores the state of the underlying array through its enum.
-
sqa-bounded-spsc-queue
A bounded SPSC queue (temporary version so I can publish sqa-engine)
-
immutable-map
An immutable ordered map and set based on weight-balanced tree
-
yuuang_petgraph
Graph data structure library. Provides graph types and graph algorithms.
-
ax_banyan_utils
work with banyan trees
-
generic-arrayvec
Interop between the arrayvec and generic_array crates
-
binary_tree_zy
binary tree
-
matterdb
Persistent storage implementation based on RocksDB
-
digger
A trait for extracting data from recursive data structures
-
pulz-bitset
bitset implementation
-
nodegraph
A data structure in rust describing a graph of nodes, where each node may contain arbitrary data
-
doubly
linked lists in rust
-
ordered_hashmap
Ordered Hashmap implementation to overcome arbitrary order of key-values problem in Rust
-
noindexmap
hash table with consistent order and fast iteration. The indexmap is a hash table where the iteration order of the key-value pairs is independent of the hash values of the keys. It has the usual…
-
push-trait
Push trait for collectons
-
gvc-sys
graphviz rust bindings
-
ppar
Persistent immutable array
-
hashindexed
A cache. A set which compares elements in a customisable way without overriding the eq() and hash() functions on the type itself.
-
prio-queue
priority queue implemented as a heap stored in a Vec
-
stack-buf
Vector-like facade for arrays allocated entirely on the stack
-
buf-list
A list of buffers that implements the bytes::Buf trait
-
atlist-rs
LinkedList which is allowed to insert/remove element by immutable iterator.Adding, removing and moving the elements within the list or across several lists does not invalidate the iterators or references…
-
sequencer
Dependency graph processing libarary
-
lighter
Macro for rewriting string matches as tries
-
staticbitset
A container like std::collections::BitSet but static storage + Copy trait
-
indexmap-rmw
hash table with consistent order and fast iteration. The indexmap is a hash table where the iteration order of the key-value pairs is independent of the hash values of the keys. It has the usual…
-
containers-rs
'Collections' interfaces for describing objects that contain other objects
-
rahashmap
Fork of standard library HashMap with additional functionality
-
embedrs-bytes
Types and traits for working with bytes
-
aximate
core data structures and utilities
-
rustgym-util
handy macros, data types and traits for rustgym
-
tag-vec
A vector used for storing tags
-
im-rope
Unicode strings backed by RRB vectors
-
justly
justified containers
-
index-ext
Index slices with arbitrary ints and as arrays
-
safer-bytes
safe, non-panicking wrappers around the 'bytes' crate
-
diskmap
disk based HashMap-like for shared concurrent memory usage
-
simple-collection-macros
configurable macros for maps and sets
-
lifetimed-bytes
Bytes, but with attached lifetime
-
sorted-list
SortedList data structure which allows mapping an Ord key to multiple distinct PartialEq values
-
tobz1000-petgraph
Pseudo-namespaced fork of
petgraph
: Graph data structure library. Provides graph types and graph algorithms. -
openfga_common
Common OpenFGA package, contains shared data structures
-
rose_bloom
A concurrent growing element size linked list with stable pointers
-
valued
Describe your data in terms of basic data structures. Get serialization and other facilities for free
-
winvec
Windowed Vector (TTL) Collection for Rust
-
grafferous
graph library with a focus on generic data in nodes
-
string32
A string that is indexed by u32 instead of usize
-
clouseau
A query language for inspecting Rust data structures at runtime
-
sealingslice
A mutable slice that can seal its initial part off from mutability, and hand out the sealed parts as immutable references
-
pages
A dynamically-sized heap-backed data page. Comprises a user-chosen header and data array packed into a single allocation.
-
calf-vec
Small copy-on-write arrays, essentially combining
SmallVec
andCow
-
trait-based-collection
A trait-based collection library that implement different data structures using the same trait
-
index-set
An ordered set that stores indices in a sparse bit field
-
twilio-data
Twilio API data structures
-
afmt
Basic data structure parsing from strings
-
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…
-
id_cache
A cache data structure which generates sequentially-assigned ids for unique values
-
xfast
Trie- binary trie for storing integers
-
gardiz
integer geometry on 2D planes, focused on games
-
bisetmap
fast and thread-safe two-way hash map of sets. It is best suited where you need to associate two collumns uniquely. Each key is associated to one or more other unique values. The structure…
-
neurarbor
manipulating tree graphs, for the analysis of neuronal arbors
-
bloomin
A basic bloom filter library written in Rust
-
ringvec
ring buffer implementation based on a vector
-
history-buffer
A fixed capacity, write-only, ring buffer
-
construct
A macro for building container literals
-
louds
LOUDS implementation for Rust
-
hash-trie
Hash Array Mapped Trie (HAMT) Immutable Set Implementation
-
growable-bitmap
A growable (and shrinkable) compact boolean array
-
discord-indexmap
A fork of the popular
indexmap
library that adds a few extra APIs that are yet to be upstreamed -
shared_bytes
Owned string and byte slices
-
bitset-fixed
Bitset for DP
-
trs
Term Rewriting Systems
-
btree_graph
A generic graph data structure
-
flattree
A series of functions to map a binary tree to a list
-
generic-json
Generic JSON traits
-
maybe-string
newtype wrapper that represents a byte vector that may be a valid UTF-8 string
-
wl-tools
Wordlist tools – algorithms and data structures for working with lists of words
-
intset
Various integer set data structures, each efficient for different operations
-
bloomy-rs
Fast bloom filter implementation
-
collectables
collections helpers for BTreeMap, BTreeSet, HashMapSet, etc. By SixArm.com.
-
fera
An aggregation of algorithms, data structures and supporting crates
-
lfbs
Lock-free stack with batched pop
-
eytzinger
implements the "eytzinger" (aka BFS) array layout
-
uvector
access two slices as a single continuous vector
-
default-vec
A specialized vector that has a default value
-
chain-map
A chain of maps with a single view into the aggregated values
-
arae
Cursed data structures
-
array_trait
A generic trait for any array, with item as type and length as const parameter
-
collidea
Collision-prone memory-efficient collections
-
fast-btree
A fast B-tree implementation ported from tlx library
-
bytes
Types and traits for working with bytes
-
poison
writing poisoned types
-
no_vec
modifying sized arrays
-
loro-internal
Loro internal library. Do not use it directly as it's not stable.
-
cursorvec
Cursored vector container
-
const-buffer
A fixed-capacity memory buffer allocated on the stack using const generics
-
divbuf
Buffer object that can be recursively divided into smaller buffers
-
algostru
Algorithms (algo) and Data Structures (stru)
-
circular_vec
A fixed length vector that provides a next function that loops infinitely
-
vec_ptr
An unsafe vector that uses raw pointers to perform standard vector operations
-
break_array
For breaking array indexing
-
yyz
Directed graph types where nodes are associated with borrowed data and traversals are done in parallel
-
sorting-vec
Sorts a vector using a btreemap
-
smolmask
A small library for storing small binary masks in just a single integer
-
keyed
Implement comparison traits by specifying a key
-
labelgraph
graph implementation, allowing random access to nodes via labels
-
ketsugou
merges two arrays
-
ethercat-types
Common EtherCAT data structures
-
mrslac
sparse matrix data structures
-
dag_compute
construction of arbitrary computation DAGs and the expression of dataflow graphs
-
immutable-avl
An Immutable map and set implement for rust based on an AVL tree
-
dogged
Persistent vector, similar to Clojure
-
rankmap
rust hash table supporting key ranking
-
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
-
board
creating a single vector with coordinate based access, and a few nice functions for easy use
-
upto
Fixed-capacity and variable length stack allocated arrays
-
castle_api
Castle API, graph api
-
sexpr_matcher
Structural pattern matching macro for S-Expressions and other list-like data structures
-
xx-bloomfilter
Bloom filter implementation using xx hash
-
sequence_buffer
Sequence buffer data structure implementation
-
rotating-buffer
Small helper data structure that allows retaining unused data
-
kukoo
lockfree cuckoo hashmap
-
easy_graph
Data structure that represent generic vertices and undirected connections
-
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
recollection
implementations and reimplementations of common data structures and algorithms, and other personally commonly used utilities
-
quantized-density-fields
Quantized Density Fields data structure
-
tdf_utils
such as tree
-
runtime-sized-array
A variable-length array, also called runtime-sized
-
baffa
Generic buffer for bytes
-
tournament_tree
A tournament tree library
-
binary_search_tree
Binary search tree implementation
-
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
-
mori_parallel
parallel orientation library built around commonly used orientation representations used in crystallography and engineering applications. It contains conversion, rotation, and data…
-
metaldb
Persistent storage implementation based on RocksDB
-
pi_tree
A tree structure implemented by dense memory linked list
-
python_object
Represent Python internal data structures
-
static_map
A static hashmap implementation, based on the Round-Robin hashing algorithm found in rustc
-
small_vec2
Vector on the stack or heap need nightly rustc
-
keyed_vec
Vector type where the key is a custom object to avoid mixing indices between vectors
-
wheelbuf
wheelbuffer crate offers a ringbuffer-like structure without a read pointer, making multiple reads of a buffer possible. The store behind the buffer is flexible and can be a static array…
-
igraph
A graph representation data structure with a built in index on keys
-
simple-graph
Graph library with ability to serialize/deserialize Trivial Graph Format
-
prcn_lib
private library for atcoder
-
immutable_string
Immutable Single Instance Strings for Rust
-
geen
Hashed based Accumulators
-
gml_parser
A fast and simple Graph Modeling Language (GML) parser
-
packed_str
Store immutable strings in a single packed allocation
-
libarena
Arena allocated graph implementation
-
dlc-trie
Data structures for storage and retrival of numerical Discreet Log Contracts (DLC)
-
interval-map
A vector-based, non-duplicate range-keyed, sorted array
-
graphs
Graph data-structure implementations based off graph-traits
-
cons-list
An immutable singly-linked list, as seen in basically every functional language
-
holodeque
Array- and slice-backed double-ended queues in 100% safe Rust
-
j2ds
A small collection of data structures not found in the standard library
-
collection_macros
Collection of macros for collections
-
lenses
An optics library loosely inspired by Julien Truffaut's Monocle
-
collect-once-hashmap
A hashmap that can be collected only when there are unique keys in the iterator
-
graphsearch
graph search and representation library
-
bytebufrs
A ring buffer for bytes implementing io::Read and io::Write
-
symbolmap-trait
A trait for generic implementation of symbol tables
-
loaf
Why have a slice when you can have a loaf?
-
graphific
graph data structure library
-
deepmesa-collections
A collection of data structures and algorithms designed for performance
-
itc
Interval Tree Clocks as described in the itc2008 paper
-
smallvec-stableunion
Fork of the crate smallvec. Uses unions in stable rust. Please note that it can only store Copy types. No functional differences apart from that.
-
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.
-
array_stump
A data structure mixing dynamic array and sorted set semantics
-
tileline
generate SVG block graph
-
cinnabar
graph algorithms and data strctures
-
low-map
A convenient wrapper around a vector of options
-
allehanda
Miscellaneous data structures and algorithms
-
indexed-hash-set
A bidirectional set whose entries can either be accessed via an index or via hashing
-
bintrie
A performant binary trie data structure that doesnt store data or keys
-
vector-trees
Vector backed B and AVL trees
-
typeslice
type-level slices
-
vpb
key-value proto buffer for veladb
-
unnamed_entity
Strongly-typed indexing for vectors and other structures
-
ziku-pds
probabilist data structures
-
baggie
Container for storing mixed / heterogeneous values in a common structure
-
plant
Tree data structures
-
token_deque
A double-ended queue backed by a vector that allows access to interior values
-
bagofholding
collection types. Efficient data structures that look bigger on the inside.
-
multi_key_map
a hash table that shares one value across multiple keys
-
anycollections
Rust Vec and HashMap which can contain arbitrary types
-
dihardts_cstools
Collection of data structures and algorithms
-
tennis
data structures
-
nslice
Structures for interpreting slices of variable length as arrays
-
awint_macros
Accompanying procedural macros to
awint
-
ixlist
The “ixlist” is a linked list in a vector, or if you want a list in a pond or an arena-allocated linked index-chasing fest. Implements a queue interface and a cursor.
-
lazy-array
An array where entries are lazily initialized in any order
-
linked_lists_rs
various data structures using linked lists in rust
-
chunky-vec
A pin safe, append only vector never moves the backing store for an element
-
nd-slice
Wrapping
std::slice
s to represent n-dimensional arrays -
extensions
typemap container with FxHashMap
-
flat-multimap
A multimap and multiset implementation using a flattened hash table
-
projected-hash-map
projected HashMap over HashSet
-
persistent-list
A singly-linked persistent thread safe list
-
single_byte_hashmap
HashMap for storing singular bytes as keys
-
twodarray
A 2D array library