-
bitvec
Addresses memory by bits, for packed collections and bitfields
-
hashbrown
A Rust port of Google’s SwissTable hash map
-
half
Half-precision floating point f16 and bf16 types for Rust implementing the IEEE 754-2008 standard binary16 and bfloat16 types
-
predicates
An implementation of boolean-valued predicate functions
-
priority-queue
A Priority Queue implemented as a heap with a function to efficiently change the priority of an item
-
hdrhistogram
A port of HdrHistogram to Rust
-
arrayvec
A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.
-
rangemap
Map and set data structures whose keys are stored as ranges. Contiguous and overlapping ranges that map to the same value are coalesced into a single range
-
tinyvec
tinyvecprovides 100% safe vec-like data structures -
bimap
Bijective maps
-
rust_decimal_macros
Shorthand macros to assist creating Decimal types
-
smartstring
Compact inlined strings
-
generic-array
Generic types implementing functionality of arrays
-
guppy
Track and query Cargo dependency graphs
-
num
A collection of numeric types and traits for Rust, including bigint, complex, rational, range iterators, generic integers, and more!
-
zerovec
Zero-copy vector backed by a byte array
-
smallvec
‘Small vector’ optimization: store up to a small number of items on the stack
-
enum-map
A map with C-like enum keys represented internally as an array
-
rowan
Library for generic lossless syntax trees
-
petgraph
Graph data structure library. Provides graph types and graph algorithms.
-
egg
An implementation of egraphs
-
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.
-
indexmap
A hash table with consistent order and fast iteration
-
merkle-cbt
A library for generating efficient Merkle tree and combined Merkle proof based on complete binary tree
-
tinystr
A small ASCII-only bounded length string representation
-
oci-spec
Open Container Initiative Specifictions in Rust
-
rpds
Persistent data structures with structural sharing
-
typed-index-collections
Typed index version of Rust slice and Vec containers
-
sized-chunks
Efficient sized chunk datatypes
-
fraction
Lossless fractions and decimals; drop-in float replacement
-
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
-
kiddo
Performant and ergonomic kd tree library. Generic over number of dimensions, stored items, and axes values. Ideal for geo- and astro- NN queries
-
indextree
Arena based tree structure by using indices instead of reference counted pointers
-
im-rc
Immutable collection datatypes (the fast but not thread safe version)
-
string-interner
Efficient string interner with minimal memory footprint and fast access to the underlying strings
-
bit-vec
A vector of bits
-
index_vec
Newtype-style helpers for
Vecandusize -
enumset
A library for creating compact sets of enums
-
kstring
Key String: optimized for map keys
-
roaring
https://roaringbitmap.org: A better compressed bitset - pure Rust implementation
-
scapegoat
Safe, fallible, embedded-friendly ordered set/map via a scapegoat tree. Validated against BTreeSet/BTreeMap.
-
radix_trie
Generic radix trie data-structure
-
indxvec
Efficiently sorting, merging, ranking, searching, reversing, intersecting, etc
-
spade
Delaunay triangulations for the rust ecosystem
-
qp-trie
An idiomatic and fast QP-trie implementation in pure Rust, written with an emphasis on safety
-
patricia_tree
Memory-efficient data structures based on patricia tree
-
array-init
Safe wrapper for initializing fixed-size arrays
-
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…
-
ringbuffer
A fixed-size circular buffer
-
crdts
Practical, serializable, thoroughly tested CRDTs
-
enum-ordinalize
This crates provides a procedural macro to let enums not only get its variants’ ordinal but also be constructed from an ordinal
-
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.
-
rstar
R*-tree library for the rust ecosystem
-
trees
General purpose tree data structures
-
rustfst
Library for constructing, combining, optimizing, and searching weighted finite-state transducers (FSTs)
-
queue-file
queue-file is a lightning-fast, transactional, file-based FIFO
-
bloomfilter
Bloom filter implementation
-
keyed_priority_queue
Priority queue that support changing priority or early remove by key
-
elsa
Append-only collections for Rust where borrows to entries can outlive insertions
-
flatk
Flat layout abstraction toolkit
-
uint
Large fixed-size integer arithmetic
-
smallbitvec
A bit vector optimized for size and inline storage
-
vec1
a std Vec wrapper assuring that it has at least 1 element
-
ndarray
An n-dimensional array for general elements and for numerics. Lightweight array views and slicing; views support chunking and splitting.
-
generator
Stackfull Generator Library in Rust
-
sorted-iter
Typesafe extensions for sorted iterators, including set and relational operations
-
undo
A undo-redo library
-
molecule
Rust bindings for molecule
-
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.
-
binary-heap-plus
Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps
-
r3bl_rs_utils
Async Redux library, TUI utilities, and useful data structures
-
flexstr
A flexible, simple to use, immutable, clone-efficient
Stringreplacement for Rust -
trie-root
In-memory patricia trie operations
-
bitstream-io
Library for reading/writing un-aligned values from/to streams in big-endian and little-endian formats
-
string
A UTF-8 encoded string with configurable byte storage
-
ciborium
serde implementation of CBOR using ciborium-basic
-
griddle
A HashMap variant that spreads resize load across inserts
-
vec-collections
Rust collections that are newtype wrappers around smallvec
-
intmap
Specialized HashMap for u64 keys
-
esaxx-rs
Wrapping around sentencepiece’s esaxxx library
-
modular-bitfield
Allows to easily define bitfield types with modular building blocks
-
intrusive-collections
Intrusive collections for Rust (linked list and red-black tree)
-
intervallum
Generic interval and interval set library
-
id_tree
A library for creating and modifying Tree structures
-
solvent
Dependency Resolver library
-
hdf5
Thread-safe Rust bindings for the HDF5 library
-
microkelvin
A library for tree traversal over annotated datastructures
-
funspace
N-dimensional function spaces and transforms
-
ritelinked
HashMap-like containers that hold their key-value pairs in a user controllable order
-
vec_map
A simple map based on a vector for small integer keys
-
ntex-bytes
Types and traits for working with bytes (bytes crate fork)
-
staticvec
Implements a fixed-capacity stack-allocated Vec alternative backed by an array, using const generics
-
leb128
Read and write DWARF’s “Little Endian Base 128” (LEB128) variable length integer encoding
-
ucd-trie
A trie for storing Unicode codepoint sets and maps
-
flatgeobuf
FlatGeobuf for Rust
-
growable-bloom-filter
Scalable Bloom Filters with serde support
-
sqrid
Square coordinates and grid-like arrays, with zero dependencies, in a single file
-
sorted-vec
Create and maintain sorted vectors and vector-backed sets
-
ordered-multimap
Insertion ordered multimap
-
ibuilder
Interactive builder for Rust types
-
hashbag
An unordered multiset implementation using a hash bag
-
ndarray-stats
Statistical routines for ArrayBase, the n-dimensional array data structure provided by ndarray
-
smallstr
String-like container based on smallvec
-
slice-of-array
Extension traits for casting between slices and slices of arrays. (&[T] <-> &[[T; n]])
-
idlset
Fast u64 set operations library
-
rc-u8-reader
A tiny implement for reading
u8data from a reference counted instance -
bitmaps
Fixed size boolean arrays
-
uluru
A simple, fast, LRU cache implementation
-
lambda-runtime-types
Common structures for lambda architecture
-
hash_hasher
A hasher which is designed to work with already-hashed or hash-like data
-
hypergraph
Hypergraph is data structure library to create a directed hypergraph in which an hyperedge can join any number of vertices
-
predicates-tree
Render boolean-valued predicate functions results as a tree
-
fixed_bitmaps
A small crate implementing bitmap functionality around primitive Rust unsigned integers
-
histogram
histogram storage and percentile metrics with precision guarentees
-
vsmtp-config
Next-gen MTA. Secured, Faster and Greener
-
traitgraph
Abstracting over different graph representations
-
slice-deque
A double-ended queue that Deref’s into a slice
-
simple-grid
A simple 2d-grid structure
-
helgoboss-midi
Interfaces, data structures and utilities for dealing with MIDI messages according to the MIDI 1.0 specification
-
intervaltree
A simple and generic implementation of an immutable interval tree
-
json_dotpath
Dotted path access to nested JSON objects (serde_json::Value)
-
vob
Vector of Bits with Vec-like API and usize backing storage
-
ux-primitives
Graphics Primitives for Angular Rust
-
fixedbitset
FixedBitSet is a simple bitset collection
-
bondrewd
Bit-Level field packing with proc_macros
-
space
A library providing abstractions for spatial datastructures and search
-
generational-indextree
Arena based tree structure by using indices instead of reference counted pointers
-
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. -
bitvec_simd
bitvec with SIMD
-
oxidebpf
A pure-Rust library for managing eBPF programs
-
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
-
grdf
Generalized RDF graphs and datasets
-
cita_trie
Modified Patricia Tree (aka Trie)
-
cedarwood
efficiently-updatable double-array trie in Rust (ported from cedar)
-
coca
Data structures with constant capacity
-
leveled-hash-map
A structure to separate values into different levels with keys. Every key-value entry which is not at the top level has a parent key at the superior level. Keys at the same level are unique…
-
varlen
Ergonomic variable-length types
-
slas
Static Linear Algebra System
-
bitlab
Extracting a range of bits from a binary data source
-
odht
A Rust crate for hash tables that can be mapped from disk into memory without the need for up-front decoding
-
mt-dom
A library for generating patches as a result diffing virtual DOM tree
-
any_vec
Type erased vector. Most operations can be done without type knowledge. Mostly zero overhead.
-
queues
Efficient FIFO Queue data structures
-
nstack
Arity 4 stack for the kelvin merkle toolkit
-
sentry-contrib-breakpad
Unopinionated crash collection for Sentry reporting purposes
-
secured_linked_list
A cryptographically secured and provable linked list
-
mih-rs
Multi-index hashing (MIH) for neighbor searches on binary codes in the Hamming space
-
tc-value
TinyChain’s representation of a value which can be collated and stored. Unstable.
-
trk-io
TrackVis (*.trk) reader and writer
-
fn_graph
Dynamically managed function graph execution
-
ndsparse
Sparse structures for N-dimensions
-
block-grid
A quick, cache-conscious, tiled 2D array
-
sparse-bin-mat
A sparse implementation of a binary matrix optimized for row operations
-
imbl
Immutable collection datatypes
-
packedvec
Store vectors of integers efficiently
-
digits
Custom “numeric” incrementor without u64 MAX limit in size. Like a score flipper for a custom character set.
-
fastbloom-rs
Some fast bloom filter implemented by Rust for Python and Rust!
-
optional
This crate supplies a number of Option-like primitive types
-
min-max-heap
An efficient, double-ended priority queue
-
plain
A small Rust library that allows users to reinterpret data of certain types safely
-
debruijn
Tools for DNA sequences: efficient k-mer manipulation, De Bruijn graph construction and compaction and handling of DNA strings
-
type-rules
A crate to easily constrain a struct
-
dary_heap
A d-ary heap
-
circular-queue
A circular buffer-like queue
-
rs-snowflake
Rust version of the Twitter snowflake algorithm
-
petal-clustering
A collection of clustering algorithms
-
converge
Layered configuration, can be expressed in a single line of code. The
Convergetrait merges instances of structures into a new instance of a structure. TheConvergetrait can be derived… -
nested_containment_list
A data structure for efficiently storing and querying nested intervals
-
blender-mesh
Serialize / deserialize Blender armatures
-
dot2
A library for generating Graphviz DOT language files for graphs
-
llvm-ir
LLVM IR in natural Rust data structures
-
dachshund
Dachshund is a graph mining library written in Rust. It provides high performance data structures for multiple kinds of graphs, from simple undirected graphs to typed hypergraphs. Dachshund…
-
biodivine-lib-bdd
A simple thread-safe implementation of basic binary decision diagrams
-
dims
Unit-Aware Types Library
-
keyvi
Keyvi - the key value index. It is an in-memory FST-based data structure highly optimized for size and lookup performance.
-
point-nd
A simple and flexible no-std struct to model points on axes of any dimensions
-
bit-set
A set of bits
-
fid
FID (Fully Indexable Dictionary) implementation for Rust
-
bytes-utils
Additional utilities for working with the bytes crate
-
polytype
A Hindley-Milner polymorphic typing system
-
commitlog
Sequential, disk-backed commit log library
-
kvdb-rocksdb
kvdb implementation backed by RocksDB
-
guppy-summaries
Build summaries for Cargo, created by guppy
-
one_way_slot_map
An implementation of SlotMap with minimal restrictions on Keys and Values
-
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!
-
matrix-sdk-common
Collection of common types and imports used in the matrix-sdk
-
threshold
Threshold data structures
-
compt
A complete binary tree visitor library
-
python-objects
rust crate that implements the architecture of the CPython objects. with this crate you can crate a list with any data type from rust
-
cc-traits
Common collection traits
-
fast_paths
Fast shortest path calculations on directed graphs made possible by pre-processing the graph using Contraction Hierarchies
-
pdatastructs
Simple probabilistic data structures
-
dade
dade is data definition for Rust structures
-
fixed-map
A fixed map where storage layout is calculated by a procedural macro
-
sparsevec
Compress vectors using row displacement
-
id_collections
Index-oriented programming in Rust
-
rtdlib
TDLib for rust
-
vmm-sys-util
A system utility set
-
tagged-pointer
Platform-independent space-efficient tagged pointers
-
ic-types
Types related to the Internet Computer Public Specification
-
slice-ring-buffer
A double-ended queue that Deref’s into a slice
-
rudac
A crate for common data structures and algorithms
-
libnv
Safe and rustic wrapper around libnv-sys
-
im_ternary_tree
Structural sharing ternary tree, i.e. immutable data structure
-
fdec
A collection of macros for generating fixed-size fixed-point numeric types for Rust
-
text-document
Text document structure and management
-
intervals-rs
A Rust crate for intervals
-
bevy-ui-build-macros
A collection of macros to speed up the process of defining UIs in bevy
-
fingertrees
Immutable persisten finger trees
-
anymap2
A safe and convenient store for one value of each type
-
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.
-
simple_tables
An easy to use rust crate for creating table structures. Including macros for easily creating these table structures.
-
arraylist
A rust wrapper built on top of rust vector implementation. Taste like Java Arraylist, and intuitive to use like Python list and JavaScript array.
-
pinus
A prickly BTreeMap. You can insert through shared references and values are pin-projected.
-
jsonptr
Data structures and logic for resolving, assigning, and deleting by JSON Pointers (RFC 6901)
-
rle_vec
A vector like struct that stores data as runs of identical values. Useful for storing sparse data.
-
radix-heap
Fast monotone priority queues
-
dbs-device
Device model for Dragonball Sandbox
-
tinyset
Size-optimized sets
-
code_location
UNMAINTAINED! Use std::panic::Location instead!
-
contack
A simple and easy contact library
-
ulid-generator-rs
A Rust crate for generating ULIDs
-
fqdn
FQDN (Fully Qualified Domain Name)
-
misc_utils
A small collection of convenient and utility functions developed for personal use
-
array-init-cursor
Utility crate to help keep track of arrays of MaybeUninit
-
mset
A mset / multiset / bag implementation
-
path-value
Universal type and access property(s) by path
-
tar-no-std
Library to read Tar archives (by GNU Tar) in
no_stdcontexts with zero allocations. The crate is simple and only supports reading of “basic” archives, therefore no extensions, such… -
cuckoofilter
Cuckoo Filter: Practically Better Than Bloom
-
corresponding
Move corresponding fields between structs
-
starling
This tree structure is a binary merkle tree with branch compression via split indexes
-
oxrdf
A library providing basic data structures related to RDF
-
slack-blocks
Models + clientside validation for Slack’s JSON Block Kit
-
fixed-vectors
Library implementing fixed-length Vectors meant for representing dimensional values
-
tcgeneric
Generic data types used internally by TinyChain. Unstable.
-
gen_value
A library for indexes and values with generations for vectors
-
goya
Yet another morphological analyzer for Rust and WebAssembly
-
skiplist
Skiplist implementation in rust, providing fast insertion and removal. A normal skiplist is implemented, as well as an ordered skiplist and a skipmap.
-
simple_endian
A create for defining endianness within your data structures, to make handling portable data structures simpler
-
vsmtp-common
Next-gen MTA. Secured, Faster and Greener
-
exponential-decay-histogram
A histogram which exponentially weights in favor of recent values
-
convenient-skiplist
Convenient and Performant SkipList with serde support
-
hirpdag
Library and procedural macros for Hash Consed, Immutable, Reference Counted, Persistent, Directed Acyclic Graph data structures
-
graphlib
Graphlib is a simple and powerful rust library for the graph data-structure
-
sucds
Succinct data structures in Rust
-
suff_collections
Fast realization of suffix array and suffix tree
-
sgf-parse
A parser for the SGF file format for Go games
-
field_accessor
A procedural macro to get and set a struct field by String dynamically
-
tugger-windows
Collection of packaging primitives specific to Windows
-
ware
Immutable middleware chains
-
rc-writer
A tiny implement for writing data to a reference counted instance
-
quickscope
Multi-layer HashMap and HashSet implementations for performant representation of variable scopes
-
xsmt
Sparse merkle tree implement in rust
-
key-node-list
Doubly-linked list that stores key-node pairs
-
funcmap
Derivable functorial mappings for Rust
-
crash-context
Provides portable types containing target specific contextual information at the time of a crash
-
ldpc
A toolbox for classical and quantum LDPC codes
-
tongrams
Tons of N-grams
-
im
Immutable collection datatypes
-
big_unsigned_ints
A Crate For Big Unsigned Integers ranging from U256 to U2048 using u64 arrays all under a fixed-size of 32
-
tinyvec_string
tinyvec based string types
-
tst
Ternary search trie collection in rust with similar API to std::collections as it possible
-
adapton
programming abstractions for general-purpose incremental computations
-
xml-builder
Easy and highly-configurable XML builder/writer
-
dependency-graph
Library for building and resolving dependency graphs
-
number-general
A generic number type for Rust which supports basic math and (de)serialization
-
btree-range-map
B-tree range map implementation
-
lodtree
A simple crate to help create octrees and quadtrees for chunked level of detail
-
kd-tree
k-dimensional tree
-
fixed-queue
no_std, no_alloc, use [T; N]. support
Vec/VecDeque/History -
bitvector
BitVector implementation in Rust
-
todo_lib
Collection of utilities for todo.txt format
-
avl
A map and a set implemented with an AVL tree
-
ioc
An Inversion-of-Control library in Rust
-
better_peekable
Create a Peekable structure like Rust’s Peekable except allowing for peeking n items ahead
-
tinystr-raw
Raw string-to-integer conversions for tinystr
-
tracker-macros
Macros for the tracker crate
-
imbl-sized-chunks
Efficient sized chunk datatypes
-
atone
A VecDeque and Vec variant that spreads resize load across pushes
-
more_collections
Additional collections not found in std::collections
-
identity-diff
Difftrait to compute and merge data structure differences -
uid
A crate for the creation of unique IDs
-
banyan
Persistent indexable tree data structure
-
array_map
Map backed array for fixed size keys with O(1) performance
-
luka
Library for working with graphs
-
fix_float
Fixed floating types that allows useful trait implementations and datastructures on float numbers
-
swaybar-types
A library for building swaybar status commands in rust
-
array-macro
Array multiple elements constructor syntax
-
try-lazy-init
Fallible lazy initialization
-
rustupolis_server
A library for using space tuples in fog computing
-
data_reader
A data loading library for data scientist
-
bitf
This crate provides a procedural macro to easily create a bitfield out of a struct
-
gcollections
Generic traits over Rust collections library
-
entity_data
A container for entity component data
-
merkle
Merkle tree implementation with support for generation of inclusion proofs
-
dcc-lsystem
An implementation of a Lindenmayer system together with some rendering tools
-
tree-flat
TreeFlat is the simplest way to build & traverse a pre-order Tree for Rust
-
fenny
A library for working with Fenwick trees
-
cordyceps
Mycelium intrusive data structures
-
toodee
A lightweight 2D wrapper around a Vec
-
dendron
Generic tree data structure
-
lfchring
Concurrent, lock-free implementation of a consistent hashing ring data structure, supporting virtual nodes and keeping track of replication
-
pulz-arena
A generational arena allocator with compact generational indices
-
smallbitset
This crate provides a series of allocation free sets capable of holding small integer values
-
bigs
A bipartite graph sampler
-
statiki
Static friendly data structures
-
sliding_window_alt
A structure that holds the last N items pushed to it
-
docker-compose-types
Deserialization and Serialization of docker-compose.yml files in a relatively strongly typed fashion
-
safe_index
Type-safe indexes
-
tree-sitter-traversal
Traversal of tree-sitter Trees and any arbitrary tree with a TreeCursor-like interface
-
partial-array
Provides potentially partially-filled arrays
-
dicom-object
A high-level API for reading and manipulating DICOM objects
-
bloom_filter_plus
rust_bloom_filter
-
sharded
Safe, fast, and obvious concurrent collections
-
union-find-rs
Disjoint-set forest implementation to support the union-find algorithm in Rust
-
arbitrary-chunks
An iterator that allows specifying an input array of arbitrary chunk-sizes with which to split a vector or array
-
ena
Union-find, congruence closure, and other unification code. Based on code from rustc.
-
hierarchical_hash_wheel_timer
A low-level timer implementantion using a hierarchical four-level hash wheel with overflow
-
defaultmap
Provides a HashMap with an automatic default for missing keys
-
static_type_map
A type map that works over all types implementing
Any -
c_vec
Structures to wrap C arrays
-
sbf
Spatial Bloom Filter, a probabilistic data structure that maps elements of a space to indexed disjoint subsets of that space
-
range_union_find
A union-find data structure for ranges
-
strchunk
Data types for working with UTF-8 text in I/O
-
fastgraph
Graph abstraction providing a generic interface and powerful parallelized traversals
-
aversion
Versioned data structures with auto-upgrading
-
bst-rs
Recursive & Iterative Binary Search Tree Implementations within Rust
-
lattice-graph
Set of Lattice(Grid) based Graph Structures
-
jumprope
Simple, fast rope (fancy string) library built on top of Skiplists
-
either
The enum
Eitherwith variantsLeftandRightis a general purpose sum type with two cases -
mucell
A cell with the ability to mutate the value through an immutable reference when safe
-
roadmap
model a project roadmap as a directed acyclic graph
-
diffus-derive
Finds the difference between two instances of any data structure. Supports derive on structs and enums.
-
tri-mesh
A triangle mesh data structure including basic operations
-
grove
A segment tree library enabling generic user-defined queries and actions on segments of your data
-
crio
An easy to use persistent data storage library
-
timely_communication
Communication layer for timely dataflow
-
treez
A collection of useful data structures
-
wasmedge-types
The common data structures for WasmEdge Rust bindings
-
coordinates_outliers
A simple outlier detection in 2D paths taken
-
ctxmap
A collection that can store references of different types and lifetimes
-
disjoint-sets
Three union-find implementations
-
cow_vec_item
Copy-on-write Vec, available on stable rust
-
slab_tree
A vec-backed tree structure with tree-specific generational indexes
-
bv
Bit-vectors and bit-slices
-
bloom-filters
Rust port of https://github.com/tylertreat/BoomFilters
-
panoradix
A generic map and a set, both backed by a Radix tree
-
fwdlist
A simply linked (forward) list
-
elementtree
Parse an XML file into Python elementtree like structure
-
designal
Procedural macro for use with futures-signals
-
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…
-
hash_ring
Consistent Hashing library for Rust
-
mco-gen
Stackfull Generator Library in Rust
-
rexsgdata
Scatter-Gather Data Descriptors
-
persist-o-vec
A Vec type that aims to have stable indices and memory location
-
radix-tree
A radix tree implementation for router, path search
-
sparseset
A Sparse Set
-
slots
Fixed size data structure with constant-time operations
-
double-map
A HashMap with double key to single data/value
-
fixedvec
A heapless version of the Rust vector type
-
simplegraph
A simple graph implementation
-
dbs-interrupt
Traits and structs to manage interrupts for virtual devices
-
flo_rope
An attributed and streaming implementation of the rope data structure
-
random-access-storage
Abstract interface to implement random-access instances
-
arraystring
Fixed capacity stack based generic string
-
map-of-indexes
A compact key-value map for unique but not dense indexes
-
do-notation
Monadic do syntactic sugar
-
rsdict
Fast static rank and select data structure
-
spdx-rs
Parse and interact with SPDX Documents
-
bdaddr
Bluetooth Device Address
-
ord-by-set
A library providing a weakly ordered multi-set with compile-time configurable ordering scheme
-
hotel
Collection Data-structure to associate values with keys
-
bigraph
Different representations with implemented operations on bigraphs
-
iterable
An iterable library for Rust collection like types
-
xtree
A simple general purpose tree data structure
-
fm-index
FM index and its variant implementations for Rust
-
segment-tree
Quickly perform interval queries or modifications
-
vk_api
The Vulkan API XML exposed as a byte string constant
-
beap
Bi-parental heap data structure implementation in Rust
-
cursorvec
Cursored vector container
-
retworkx
A python graph library implemented in Rust
-
typed_index_collection
Manage collection of objects
-
multipeek
An adapter to peek at future elements in an iterator without advancing the iterator cursor
-
pareto_front
Builds a Pareto front incrementaly
-
flag_set
FlagSet can process operations of the infinite complementary sets and the origin sets
-
chronologic
Utilities for time constraint reasoning
-
system-config
A library for storing application properties on disk
-
gaoya
Locality Sensitive Hashing Data Structures
-
boa_interner
String interner used in Boa
-
rt_ref
Internal
Reftypes forrt_refandrt_vec -
bitstring
Bitstring traits and implementations
-
pin-list
A safe
Pin-based intrusive doubly linked list -
prefix_tree_map
A Rust implementation of generic prefix tree (trie) map with wildcard capture support
-
slice-dst
Slice-based custom DSTs
-
recursive_reference
This crate provides a way to walk on recursive structures easily and safely
-
Xorfilter
No alloc membership approximation
-
succinct_rs
Succinct Data Structures library for Rust
-
beach_map
Implementation of a slotmap
-
slice_ring_buf
A fast ring buffer implementation optimized for working with slices
-
floating_bar
Representing rational numbers using the floating-bar number type
-
incremental-topo
Data structure to maintain an incremental topological ordering over a collection of values
-
simple-observable
Simple observable pointer for mutable and immutable data
-
hashtree
A Merkle Tree implementation in Rust
-
utote
Stack allocated uint multiset, with optional SIMD implementations
-
swap-queue
A lock-free thread-owned queue whereby tasks are taken by stealers in entirety via buffer swapping
-
grid
Dynamic generic 2D data structure
-
index-ext
Index slices with arbitrary ints and as arrays
-
kvstructs
General basic key-value structs for Key-Value based storages
-
rb_tree
A Red Black Tree implementation in Rust
-
pasture-core
A framework for working with point cloud data
-
cactus
Immutable parent pointer tree
-
weight-cache
A cache that holds a limited number of key-value-pairs according to a user defined criterion
-
sparesults
SPARQL query results formats parsers and serializers
-
canutils
A can-utils implementation in pure Rust
-
aliasable
Basic aliasable (non unique pointer) types
-
sequence_trie
Trie-like data-structure for storing sequences of values
-
screech
A collection of helpers for handling audio data in real time
-
dyn_size_of
The library to report approximate amount of memory consumed by variables, including the memory allocated on heap
-
fixed-macro
Macros for creating fixed-point constants for types in the
fixedcrate -
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
-
array-concat
Macros for concatenating const arrays
-
lambda-apigateway-response
Response object for AWS Lambda with API Gateway
-
chtholly_tree
Rust bindings for Chtholly Tree
-
k2_tree
A space-efficient representation of sparsely populated bit-matrices
-
kalgan_config
Collection of functions to retrieve data and settings parameters defined in yaml files used by Kalgan Framework
-
bitfield-struct
Procedural macro for bitfields
-
set_genome
A genetic data structure for neuroevolution algorithms
-
wg-toolkit
Toolkit for various binary and text formats distributed by Wargaming.net (BigWorld, Core engine)
-
ds-bst
Binary search tree implementation
-
entity
Library that provides entity-like constructs
-
arc-bytes
A reference-counted byte buffer
-
osm-xml
OSM xml parser for Rust
-
modular-bitfield-msb
Allows to easily define bitfield types with modular building blocks. MSB-first version.
-
lignin
A virtual DOM structure, primarily for web use
-
large_int
An ease-of-use unbounded signed integer
-
activation_functions
This is a collection of activation functions
-
spnr-lib
Rust library for building smart contracts on the Internet Computer, by the Spinner.Cash team
-
pokeapi-model
Data structures for PokéAPI v2
-
mergle
A data structure with fast merging and comparison
-
lim-bit-vec
Limited bit vectors
-
tinyid
A tiny ID type that’s like UUID except shorter and easier for a user to type in
-
galemu
Provides a workaround for generic associated types (GAT) limited to lifetimes (GAL)
-
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.
-
libflow
library grouping network flow data
-
tugger-file-manifest
Interact with lists of files through a storage-agnostic interface
-
pq-tree
PQ-tree implementation for consecutive ones property (C1P) and graph planarity testing
-
rosary
A Library About Rose Trees
-
python-packed-resources
Manage data structures containing Python resources
-
moretypes
Named tuples, records, and more!
-
ego-tree
Vec-backed ID-tree
-
manhattan-tree
A spatial tree which can effiently find closest key to a point, by manhattan distance
-
ternary-tree
A Rust implementation of Ternary Search Trees, with no unsafe blocks
-
clarion
A library to simplify working with Clarion software data formats
-
granite
Generic backing storage framework for building data structures
-
numeric-array
Wrapper around generic-array that adds efficient numeric trait implementations
-
hvec
A Vec-like structure that can store different types of different sizes contiguous with each other in memory
-
dbs-address-space
address space manager for virtual machines
-
gapbuf
Generic gap buffer
-
modular-bitfield-impl
Bitfields for structs that allow for modular use of enums
-
epsg
EPSG Coordinate Reference System tools & data
-
sharedvec
A fast but limited collection for storing values of a single type
-
data_structure_traits
data structure collection traits
-
bloom
Fast Bloom Filter and Counting Bloom Filter implementation
-
cursed-collections
Collections that (seem to) break Rust safety
-
ohsl
A collection of numerical routines and mathematical types for use in scientific computing
-
bengbenge
Simple inifity array for round-robin dns, beng, beng
-
algae
Algae is a collection of algorithms and data structures optimized for building decentralize systems
-
moniker
Automatically derive variable binding and alpha equivalence for abstract syntax trees
-
dfb
Dynamic-Fifo-Buffer, like AnyMap but uses a VecDeque to store values and treats access as a Fifo
-
simd_aligned
Safe and fast SIMD-aligned data structures with easy and transparent ‘flat’ access
-
netplan-types
Netplan configuration types as Rust structs and enums
-
ux-dx
3D Graphics Primitives for Angular Rust
-
collectable
Fallible, no_std-friendly collection traits
-
u64_array_bigints
Simple biginteger library based on u64 arrays
-
flow_arena
A HashMap managed Graph Model with the concept of ownership
-
numas
numas library is implementation of multidimensional array for efficient computing
-
largeint
A library that supports large integer arithmetic
-
rolling_norm
Computes the rolling mean, variance, standard derivation and norm
-
unstructured
Generic types for unstructured data
-
rep
A small tool for representation/class invariants
-
siraph
A node-based digital signal processing crate
-
mori
An orientation library built around commonly used orientation representations used in crystallography and engineering applications. It contains conversion, rotation, and data analysis…
-
subject-classifier
Library for classifying a commit by it’s subject
-
sum
General-purpose sum types
-
stack-array
A data structure for storing and manipulating fixed number of elements of a specific type
-
outils
Graph and tree data structure library. Providing utilities which aren’t easily available in Rust.
-
attr
attris a library to provide external access to a datastructure through a typed path object, using all type information known about the data structure at hand -
debt64
An implementation of Base64 - https://en.wikipedia.org/wiki/Base64
-
rdf-types
Common RDF types definitions
-
keylist
Elixir keyword list in Rust
-
upair
Unordered pair data structure
-
forest-ds
Implementation of a secure tree structure
-
acme-types
Types for implementing ACME (RFC 8555) providers and clients
-
win-variant
This is a rust crate that aims to provide a more ergonomic way of working with variants in winapi based projects
-
scalable_cuckoo_filter
A variant of Cuckoo Filter whose size automatically scales as necessary
-
tiny-test
tiny-testis collection of functions simplifying test assertions in rust -
libarena
Arena allocated graph implementation
-
dd_statechart
A Data-Driven implementation of Harel Statecharts designed for high-reliability systems
-
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”
-
setting
The styles of all graphics elements
-
loaf
Why have a slice when you can have a loaf?
-
bitaccess
Macro for efficient and type-checked access to individual bits of a variable
-
traitsequence
Traits to abstract over sequences
-
wavelet-matrix
A wavelet matrix implementation. Supports various near-O(1) queries on large number of symbols or integers.
-
minsize
Collections with a statically known minimum size (using const generics)
-
lz_diet
An AVL balanced Discrete Interval Encoding Tree
-
osm-tags
OSM Tags Datatype
-
bonzai
An abstraction for optimizing the memory layout and pointer aliasing of trees
-
fux_kdtree
K-dimensional tree implemented in Rust for fast NN querying
-
vicardi
JSON VCardArray Generator that uses Serde
-
parallel_vec
A generic contiguous collection of heterogenous values
-
simple_event_bus
A basic, simple event bus in Rust
-
disjoint-hash-set
A disjoint set / union-find data structure suitable for incremental tracking of connected component identified by their hash
-
splay_tree
Splay Tree based Data Structures (map, set, heap)
-
fxd
Fixed-point decimal implementation
-
avm1-types
Types for the Flash ActionScript Virtual Machine (AVM1)
-
art-tree
The Adaptive Radix Tree
-
packed_array
Packed Array aka sparse set structure with compile-time known size
-
simple_bitfield
Create bitfields with the same memory structure as integers using a simple macro
-
mine_sweeperr
Minimalist interface to manage the backed of a mine sweeper game
-
lending-library
A key-value store that loans full ownership of items
-
building_blocks_partition
Acceleration structures for spatial queries on voxel data
-
clippet
Provides a teeny way to have some nice byte structures that’s easy to use
-
watermark
A simple watermarking set for in-order insertions
-
json-syntax
Strict JSON parsing and mapping library
-
dograph
Directed Acyclic Graphs with integer vertices represented as a Strictly Upper Triangular Matrix stored in a bit set
-
elastic-array-plus
Elastic vector backed by fixed size array
-
dims_macro
Macros for Generating Systems of Units
-
rustz
A library for functional programming in Rust
-
vast
Verilog AST library
-
nopetgraph
Graph data structure library. Provides graph types and graph algorithms.
-
kravltree
AVL Tree implementation based on fastutil AVLTreeMap
-
simple-matrix
A simple generic matrix library
-
crash-handler
Allows running of user code during crash events
-
wccg-models
WCCG Data
-
jirachi
A collision resistant runtime agnostic key-generator
-
graph_solver
An undirected graph constraint solver for node and edge colors
-
twmap
Parse, edit and save Teeworlds and DDNet maps
-
liblet
Library for learning about formal languages and grammars
-
staticsort
Implements a macro providing a compile-time quicksort function for arrays of any length, containing any primitive Copy type with a PartialOrd implementation
-
symbol_table
A symbol table that’s fast, concurrent, and gives stable references
-
word-dictionary
This crate provides a data structure for word mapping. It can be used for language translation.
-
bip_metainfo
Parsing and building of bittorrent metainfo files
-
gridly
A library for managing fixed-size 2D spaces
-
field-ref
Field reference (like a member pointer to non-static data field in C++) for Rust
-
rusty-perm
Rusty permutation with no-std
-
pair_macro
Create types consisting of the same type values such that Pair, Triplet, and so on
-
sortbuf
Data structure for sorting large numbers of items
-
minecraft_end_generation
The minecraft end generation implemented in rust
-
patricia_router
Radix Tree implementation for Rust
-
bailamos
Simple notification manager
-
guzzle
A derivable trait for consuming key value pairs into structs
-
rose_tree
An indexable tree data structure with a variable and unbounded number of branches per node. It is Implemented on top of petgraph’s Graph data structure and attempts to follow similar conventions where suitable.
-
isomorphism
2 directional hashmaps
-
identifier
Generate 128 bits id structs easily
-
velcro
Convenience macros for initializing vectors, hash maps and other Rust collections
-
manyvecs
Vector structs inspired by GLSL
-
pinned_vec
Vec-like data structure whose elements never move
-
certified-vars
Certified variable friendly data structures for the Internet Computer
-
nested_intervals
nested & overlapping interval set functions, overlap, union, etc
-
spdx-expression
SPDX Expression
-
kserd
Kurt’s Self-Explanatory Rust Data
-
probabilistic-collections
Various implementations of collections that use approximations to improve on running time or memory, but introduce a certain amount of error
-
object-chain
Ad-hoc structure builder
-
stride
A strided slice type
-
bitset-core
Straightforward, no-std compatible, simd optimized, BitSet API
-
iowrap
Small helpers for using io::Read/io::Write
-
radixtree
A radix trie implementation for router, and provides CRUD operations
-
comp_input
Input library for competitive programming
-
ndarray-ndimage
Multidimensional image processing for ArrayBase, the n-dimensional array data structure provided by ndarray
-
once_map
Single assignment maps
-
parsable
A trait to easily parse data structures
-
awint_macros
Accompanying procedural macros to
awint -
exprz
An Expression Library
-
succinct
Succinct data structures for Rust
-
index-map
A map with automatically generated usizes as keys
-
yyid
Yyid generator (random tokens like UUIDv4, but using all the bits)
-
index_list
A doubly linked list implemented in safe Rust using vector indexes
-
valet
Stores your objects and gives you a tag to retrieve them later
-
derangement
A Rust implementation of a permutation with no fixed points, a derangement
-
soa-vec
A simple Vec-like API over a struct of arrays layout
-
lockfree-cuckoohash
A rust implementation of lockfree cuckoo hashmap
-
verify
A validation library
-
modql
Rust implementation for Model Query Language support
-
usage
A convenient alternative to the newtype pattern
-
dynamic-matrix
A simple crate to work with matrices
-
edit_tree
Edit trees in rust
-
treers
Simple implementation of Sedgewick’s tree maps
-
llml
Implementation of basic math data types with high level frontend and low level backend
-
ux-dataflow
Data Processing Library
-
tournament-kway
Implementation of a k-way merge using a tournament tree
-
xmltree-parse_with_config
Parse an XML file into a simple tree-like structure
-
static_merkle_tree
Static Merkle Tree is dedicated for generating Merkle Root and Merkle Proof for a static list of items
-
cast-rs
A collection of types cast for Rust
-
nfe
NF-e - Manipulação da nota fiscal eletrônica
-
froggy
Froggy is a prototype for the Component Graph System programming model. It aims to combine the convenience of composition-style Object-Oriented Programming with the performance close to Entity-Component Systems
-
vector-map
VecMap<K, V>: a Linear Search with Map API
-
hibitset
Hierarchical bit set structure
-
backtracking_iterator
A simple implementation of a generic iterator with an item history, capable of backtracking and forgetting
-
hayami
A simple, general use symbol table
-
fenwick
Fenwick tree: data structure that efficiently calculates prefix sums in a changing array of numbers
-
marked-yaml
A simplified YAML structure with provenance spans
-
charcoal
Implements tree data structures and interfaces to work with them
-
ball-tree
Ball-tree implementation for K-nearest neighbors
-
jagged_array
Owned
[[T]]-like 2D array where each row can differ in length -
mush
Visual graph/dialogue editor
-
entity_table
Data structure for associating data with entities in an Entity Component System
-
range-collections
Sets and maps of ranges, backed by smallvec
-
cds
Collection of Optimized Data Structures
-
filament-bindings
This package provides build scripts and prebuilt binaries for filament on Windows, macOS, Linux, and the unsafe binding interface automatically generated by rust-bindgen
-
ordsearch
A data structure for efficient lower-bound lookups
-
implhm
Simplified library of collision-handling HashMaps
-
dbs-arch
A collection of CPU architecture specific constants and utilities
-
tiny_ecs
A tiny ECS that tries to avoid unnecessary copy/clones
-
email-format
Email message format (parser and data structure)
-
vec-dimension-shift
N-Dimension shift features for Vec
-
asyncapi
This crate aims to provide data structures that represent the AsyncAPI specification easily deserializable with serde
-
doson
Dorea Data Struct Parser
-
win-idispatch
This is a rust crate that aims to provide a more ergonomic way of working with idispatch in winapi based projects
-
tilecoding
Rust implementation of Dr. Richard S. Sutton’s tile coding software.
-
any-range
AnyRange enum can hold any Range* type
-
ahtable
Array Hash Table implementation
-
simple-undo
Easy to use undo-redo library
-
uvector
access two slices as a single continuous vector
-
tsil_cev
LinkedList on Vec
-
array-const-fn-init
Initializes an array with constant values calculated by a
const fn -
ensure
Ensure target state of an object
-
froop
A functional reactive stream library for rust
-
seqbytes
Provides traits for reading bytes sequentially
-
dynprops
Creating and extending objects with typed dynamic properties
-
bravery_router
Radix Tree implementation
-
json-trait-rs
Rust interface (aka trait) to deal with objects as they are JSON objects
-
tinybox
Like
Box, but with an optimization that avoids allocations for small data-structures -
mwmatching
Maximum-Weight Matching: Compute a maximum-weighted matching in the general undirected weighted graph given by ‘edges’
-
validbr
Provides data structure and validation for Brazilian Registries, such as CPF, CNPJ and CNH (currently only CPF and CNPJ is supported)
-
bitsetium
One stop shop for all bitset needs
-
pl-hlist
Provides support for heterogeneous lists (known as
HLists), which are functional, tuple-like, strongly-typed data structures that can contain elements of differing types -
giftbox
A fun Rust crate called
giftboxto help Rustlings learn and explore generics -
slabmap
HashMap-like collection that automatically determines the key
-
base_custom
Use any characters as your own numeric base and convert to and from decimal
-
type-rules-derive
type-rules derive macro
-
varuint
Variable length signed and unsigned integer types
-
lumberjack
Read and modify constituency trees
-
cycle_map
Implementations of bi-directionally accessible hashmaps
-
cmp_wrap
Let you compare structes by context
-
gtfs-geojson
A simple converter for GTFS to GeoJSON formats
-
bittle
A library for working with small and cheap bit sets and masks
-
art
adaptive radix trie
-
nested
A memory efficient container for nested collections (like
Vec<String>orVec<Vec<T>>) -
multiset
Multisets/bags
-
half_edge_mesh
A basic implementation of the half-edge mesh data structure. It has a bunch of the functions you probably want in a half-edge mesh, but probably not all of them. I’m intending to add more methods and mutation techniques…
-
graphrepresentations
A crate providing efficient abstract implementations of different graph representations
-
subgraph-matching
A library for subgraph matching
-
atree
An arena based tree structure with removal support
-
inspector
General purpose inspection for popular data structures
-
influxdb-dispatcher
Batch metrics collection using influxdb
-
pfds
Purely Functional Data Structures
-
ketsugou
merges two arrays
-
quork
A collection of small things that make interacting with the system easier
-
actions
Software without side-effects. Redo and Undo. Macro’s.
-
extended-rational
Provides implementations of high-accuracy projectively-extended rational numbers and macros for creating them
-
leak
Safely leak data from owned data structures
-
partial
Optional monad with fake variant
-
pointer-value-pair
A pair of a pointer and a small integer packed into a pointer-sized object
-
trait-stack
Fast heterogeneous stack
-
microcrates-bytes
Types and traits for working with bytes (with no_std support by default)
-
fixed-vec-deque
A fixed-size, zero-allocation circular buffer for Rust
-
local_vec
fixed-capacity vector allocated on the stack
-
truncate-integer
Truncate integers
-
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).
-
graphity
Model signal flow between nodes within a directed graph
-
narrow-derive
Derive macros for Narrow: A Rust implementation of Apache Arrow
-
rbitset
A bit set, being able to hold a fixed amount of booleans in an array of integers
-
value-trait
Traits to deal with JSONesque values
-
qt-json-rs
JSON library for QT
-
woodland
Easy to use implementations of popular tree data structures such as Binary, Binary Search, AVL, Red-Black, and more
-
fuzzy_trie
Key-value collection to make fuzzy searches
-
mediumvec
Vector types optimized for space, including a 32-bit Vec
-
restorable
An iterator adapter for saving and restoring iterator state
-
bucket_queue
A Bucket Queue data structure that can be used as a Priority Queue
-
statemachine-rs
A statemachine crate which have zero dependencies
-
id-map
Data structure of values indexed by IDs
-
bk-tree
A Rust BK-tree implementation
-
geomprim2d
2D geometric primitive types
-
converge_test
Tests for the
converge::Convergetrait and theconverge_deriveproc-macro -
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
-
lhlist
Labeled heterogeneous lists
-
passive
A trio of marker traits to classify passive data structures
-
kodama
Agglomerative hierarchical clustering
-
ndstruct
Structures for N-dimensions
-
lru-mem
An LRU cache implementation bounded by memory
-
extindex
Persisted immutable index
-
boolvec
A vector of boolean stored contiguously in memory
-
reso_dd
Structures and Enumerations that implement the Real Estate Standards Organization (RESO) Data Dictionary
-
hex_color
A Rust library for parsing, serializing, and operating on hex colors
-
nullvec
Rust nullable vector, which can contain null(missing) values as element
-
tobz1000-petgraph
Pseudo-namespaced fork of
petgraph: Graph data structure library. Provides graph types and graph algorithms. -
seg-tree
A simple segment tree library
-
rand_map
A map that creates a random handle on insertion to use when retrieving
-
bounded-spsc-queue
A bounded SPSC queue
-
dispatchtable
Small library used to specify function dispatch tables HashMap<K, Box<Fn(..)>>
-
safe-graph
Graph implementation (refactored version of GraphMap from popular crate petgraph)
-
pod
Plain Old Data (POD) encoding and I/O
-
lightingrust
Lightweight collection of RUST libraries, out of the box, refusing over encapsulation
-
string-wrapper
A possibly-stack-allocated string with generic bytes storage
-
sweeper
A foundation for Minesweeper implementations in Rust
-
btree_graph
A generic graph data structure
-
partial_const
This library provides a way to handle constant and non-constant values in a unified way
-
mop-structs
Low-level structures for MOP
-
rattish
Cast between trait objects
-
ladata
A simple & modular data model
-
fungi-lang
Fungi: A typed, functional language for programs that name their cached dependency graphs
-
dia-i18n
ISO 3166-1 and ISO 639 codes
-
retrace
Safe, generic rollback log with predictable latency
-
multipath
A library to split file path, like
/home/{user,admin}/file.txt -
stable_bst
An ordered map and set based on a binary search tree. Works with stable Rust 1.9.0.
-
changed
Simple change detection
-
relational_types
Manage relations between objects
-
watchface
A smartwatch watchface implementation
-
fenwick-tree
An implementation of a binary indexed tree (Fenwick tree) data structure in Rust
-
dot-structures
The library provides macroses to generate dot structures
-
pi_weight
Weight tree, Used to store content with weight values
-
blender-armature
Serialize / deserialize Blender armatures
-
btreelist
A list data structure that has efficient insertion and removal in the middle
-
adivon
Data Structures of daily use: Graph, HashTable, PriorityQueue, Trie, SuffixTree, Rope, SplayTree, SkipList, RedBlackTree
-
btree-vec
A growable array (vector) implemented using a B-tree
-
pgs
A library for structuring save files from the Birdiesoft classic game Pokémon Simulator
-
buffer-trigger
A data collection trigger based on the maximum number and refresh time
-
free-ranges
An efficient data structure for keeping track of indices which are either free or not
-
shortlist
An efficient data structure to track the largest items pushed to it
-
syntastic
Generic abstract syntax representation
-
rust_decimal_macro_impls
Shorthand macros to assist creating Decimal types. Do not depend on this directly; use rust_decimal_macros
-
flat-tree
Rust module for encoding/decoding varints that doesn’t do any IO. Inspired by the Node.js varint module
-
raphy
A graph data structure library
-
basiccountminsketch
A basic count min sketch implementation
-
timesource-core
Core library for timesource
-
version-rs
A struct for Versions, with the methods you expect
-
applejack
Simple implementation of Radix 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.
-
atomic_swapping
An arbitrary type atomic storage with swap operations
-
bitstring-trees
Trees based on bitstrings
-
periodic-rs
Bounded datastructures
-
grammers-tl-types
Rust definitions for Telegram’s API types and functions
-
globalmaptile
Convert a raster into TMS tiles, create KML SuperOverlay EPSG:4326, generate a simple HTML viewers based on Google Maps and OpenLayers. Ported from globalmaptiles.py
-
toboggan-kv
Toboggan-kv is an abstraction layer over multiple KV stores
-
Project2
Implementations of red black tree and AVL tree
-
dst
Data structures for DSTs
-
clampf
Clamped floating-point types
-
vf-rs
A set of classes generated from the ValueFlows RDF schema
-
rasn-smi
Data types for handling Structure for Management Information
-
pciids
A library to parse the pci.ids data file
-
gentrix
A library that adds the Matrix typed using generics that is basically a wrapper around a 2D Vector
-
orange-trees
Tree data structure with several methods to query and manipulate nodes
-
try-push
A trait for attempting potentially expensive actions
-
ethercat-types
Common EtherCAT data structures
-
serde_single_or_vec
Type which can be deserialized from either a sequence or a single value
-
congruence
A simple implementation of congruence closure
-
zot
Provides Option-like enums for working with ordered collections of zero, one, or two items (
Zot), or ordered collections of one or two items (Ot) -
apint
Arbitrary precision integers library
-
wordsworth
A collection of natural language analysis functions
-
om2
A set of classes generated from the OM2 RDF schema (mainly Unit)
-
petitset
An ordered set data structure, optimized for stack-allocated storage of a tiny number of elements with a fixed cap
-
splay
A 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)…
-
hit-data
Hierarchical Indexed Typed data structure
-
automerge
Rust implementation of the Automerge replicated JSON datatype
-
zerofrom
ZeroFrom trait for constructing
-
nave
Thinking about the construction of distributed systems starting from the consistent hash algorithm
-
enum-map-derive
Macros 1.1 implementation of #[derive(Enum)]
-
hashcons
Hash cons’ing for compact representations of shared, immutable data structures
-
lsph
Learned Spatial HashMap
-
bitrush-index
A serializable bitmap index library able to index millions values/sec on a single thread
-
vega-lite
Generated code for using the Vega-Lite schema from Rust
-
checked
Implements a wrapper over the primitive Rust types that better indicates overflow during arithmetic
-
linux-stats
typesafe procfs info
-
version-lp
a version struct library for use with version comparing, and wildcard resolving
-
tf_playlist
The playlist feature used in Tubefeeder
-
enum_meta
Add metadata to Enum Variants
-
gardiz
A library for integer geometry on 2D planes, focused on games
-
afi
Audio & video structures, plus encoder & decoder traits
-
pulz-schedule
For scheduling systems and managing their resources
-
hedge
An index based half-edge mesh implementation
-
zifu_core
Core library for zifu (command line tool to fix Windows-dependent encoded filenames of ZIP files)
-
simple_ringbuf
Simple Ringbuf is a speedy lightweight fixed-size infinite-use collection optimized for straightforward single threaded use
-
tpntree
A N-dimensional generalization of region quad/oc-trees
-
hash-rings
Implementations of various hash rings
-
dynamization
Fast insertion for static containers
-
pl-lens
Provides support for lenses, which are a mechanism in functional programming for focusing on a part of a complex data structure
-
offset-views
Create and index offset views of arrays, slices, strings, etc
-
epoch-timestamp
Boilerplate collection for epoch timestamping
-
exclusion-merkle-cbt
Complete Binary Merkle Tree for verify exclusion
-
records
Proc macro for defining data storage structs
-
replicante_logging
Replicante common logging logic
-
aterm
Implementation of the Annotated Terms data structure
-
moka-cht
Lock-free resizeable concurrent hash table
-
priq
Array implementation of the min/max heap
-
dbs-boot
Traits and structs for booting sandbox
-
empty-box
Allows for
Boxs to have their values moved out and replaced with new values, while reusing the same allocation -
kekbit-core
Defines the main abstractions and provides the core components required to work with kekbit channels
-
arc-string-interner
An efficient cuncurrent string interning data structure with minimal memory-footprint and fast access to the underlying contents
-
immutable-map
An immutable ordered map and set based on weight-balanced tree
-
clnooms
Assembly-level implementation of interesting data types
-
rust_fixed_width
library that allows for easier manipulation of fixed width files allowing for the ability to name fields and such using specs
-
graphific
Graphific is a graph data structure library
-
elaru
Memory safe implementation of LRU cache
-
gridd-euclid
euclid-compatible grid data structure (forked from Frosh_VII’s gridd)
-
domain-lookup-tree
A tree structure in Rust optimized for looking up domain names, with wildcard support
-
tracker
A macro to track changes to your structs
-
named_tuple
A macro for declaring a
structthat manages a set of fields in atuple -
tree-cursor
A simple, non-intrusive tree cursor that supports node mutation without Cell/RefCell
-
sbf-blake3
Spatial Bloom Filter, a probabilistic data structure that maps elements of a space to indexed disjoint subsets of that space
-
kurobako_solvers
A collection of black-box optimization solvers
-
simple-rate-limit
Rate limit enforcement as simple data structures, no atomics
-
rustc-ap-rustc_data_structures
Automatically published version of the package
rustc_data_structuresin the rust-lang/rust repository from commit 9a27044f42ace9eb652781b53f598e25d4e7e918 The publishing script for this crate lives at: https://github… -
restor
A dynamic resource storage system in rust
-
gsrs
Generic Self Referencing Struct
-
histogram-sampler
Sampling from a distribution given by a histogram
-
sesstype
An implementation of Multiparty Session Types
-
bip_handshake
Common handshaking interface as well as a default handshake implementation
-
another-option
Another option data type; useful when allocations are expensive
-
eztd-core
Quick start Rust
-
unrolled-linked-list
The implementation of the unrolled linked list in rust
-
calcit_fingertrees
(Calcit fork of )Immutable persisten
fingertrees -
pure-hfsm
A finite state machine library with a clear separation between the machine definition and its changing state
-
puruda
Pure Rust DataFrame
-
prometheus-32bitfix
Prometheus instrumentation library for Rust applications
-
break_array
For breaking array indexing
-
torrent-common
A set of data structures used for bittorrent implementations
-
aabb-quadtree
A quadtree that maps bounding-boxes to elements
-
string-err
String error type
-
cliquers
Manage filesequences with a common numeric component
-
pages
A dynamically-sized heap-backed data page. Comprises a user-chosen header and data array packed into a single allocation.
-
thermostat
Finite state machine for a thermostat controlling a centralized HVAC system or other heating and/or cooling apparatus
-
indexvec
Simplified copy of rustc’s index crate
-
weak-self
WeakSelf is simple way to have a Weak pointer to yourself
-
specs-hierarchy
Scene graph type hierarchy abstraction for use with specs
-
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 -
abin
A library for working with binaries and strings. The library tries to avoid heap-allocations / memory-copy whenever possible by automatically choosing a reasonable strategy: stack for…
-
sortedcontainers
An experimental sorted data structure
-
content-tree
An efficient data structure for compacted RLE data
-
text-style
Types and conversions for styled text
-
twilio-data
Twilio API data structures
-
protocoll
clojure inspired protocols for rust collections
-
armon
A collection of algorithms and data structures
-
swimmer
Thread-safe object pool type
-
polystore
Polymorphic data store
-
cervine
A slightly more flexible Cow; roughly to T: Borrow as alloc::borrow::Cow is to B: ToOwned
-
sequencetree
a new type of collection to store keys and their corresponding values
-
ppar
Persistent immutable array
-
folketinget-api-models
Autogenerated Rust structures based on the Danish Parliament’s OData metadatafile
-
htmldom_read
HTML reader that parses the code into easy-use tree
-
derive_wrapper
Rust custom derive macro for wrapping types
-
minecraft_nether_generation
The minecraft nether generation implemented in rust
-
slabigator
A linked list that doesn’t do dynamic memory allocations
-
xsparseset
A rust sparse set
-
hgg
Approximate nearest neighbor search collection
-
dlist
List data structure based on AVL tree. It can store elements which have dimension and quickly search for elements by distance from 0.
-
serde_either
Simple set to enums to deserialize and serialize data that can either be string, struct or vec
-
slist
Algebraic lists with statically determined size that live on stack
-
binn-ir
An implementation of Binn - https://github.com/liteserver/binn
-
shared_bytes
Owned string and byte slices
-
anti-r
A spatial data structure outperforming r-trees for low numbers of elements
-
theban_interval_tree
A simple Interval Tree implementation
-
tiled-json-rs
A crate to parse and interact with Tiled editor JSON files
-
plum
Probabilistic data structures for rust
-
subset-map
A map where the keys are subsets of an initial set of elements
-
bookfile
A container file format with chapters and an index
-
shared-string
Split a string without another allocation
-
advancedresearch-higher_order_point
An experimental higher order data structure for 3D points
-
dirty_static
A container for an immutable value that allows sneaky reloading in debug mode (via UnsafeCell) while keeping the data safe and constant in release mode. This allows you to tweak data while testing an application…
-
ldap-types
Implements the basic LDAP types so they can be used in other crates
-
yeast-rs
Tiny but linear growing unique id generator
-
deltastruct
Allows defining deltas for tagged structs for later application
-
dotreds-binary-heap-plus
Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps. Makes some previously internal function public
-
fcsd
Front-coding string dictionary
-
graphsearch
A simple graph search and representation library
-
truetree
Trees in Rust
-
fusefilter
No alloc membership approximation
-
btree-slab
A memory compact Slab-based B-tree implementation
-
priority-set
A no_std Priority Set
-
stomp
A full STOMP 1.2 client implementation. Allows programs to interact with message queueing services like ActiveMQ and RabbitMQ.
-
nats-types
Enumerations and types for representing NATS protocol messages
-
narrow
A Rust implementation of Apache Arrow
-
weakheap
Weak Heap data structure implementation in Rust
-
nanoset-py
A memory-optimized wrapper for Python sets likely to be empty
-
stackvector
StackVec: vector-like facade for stack-allocated arrays
-
qptrie
A QP-Trie implementation for Rust
-
hash_histogram
HashHistogram creates histograms with keys of any hashable data type. Features include rank ordering and mode.
-
pui-arena
Generalized Arenas that can be used on
no_std -
quantized-density-fields
Rust implementation of Quantized Density Fields data structure
-
bicoro
Bidirectional co-routine data structures
-
no_vec
A library for modifying sized arrays
-
arbtree
A small library for general purpose tree data structures
-
medianheap
A median heap for keeping track of a running median
-
u64_array_bigints_core
Core library for
u64_array_bigints -
push-while-ref
push while having a reference
-
optempty
Tools for working types that may be empty. E.g., an empty
String,Vec,HashMap, etc. -
onigiri
This crate is a tool of handling chars
-
banyan-utils
Utilities to work with banyan trees
-
flats
flattens nested structures into a flat single dimension map
-
langtag
Language tags implementation following RFC 5646
-
dims_core
Core Utils for Generating Units and Systems
-
id-vec
Simplify Graphs in Rust. Introduces IdVec, which automatically creates Ids for each new object, reusing deleted Ids.
-
bitm
The library for bit and bitmap (bit vector) manipulation
-
hashbrown_tstd
A Rust port of Google’s SwissTable hash map
-
vk_generator
Generate Rust bindings to the Vulkan API
-
nibble_vec
Vector data-structure for half-byte values
-
final
Wrap a value in a type that does not give out mutable references
-
depot
A (disk) persistent queue library
-
collect-mac
This crate provides the
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… -
dusk-kelvin-map
BST Map implementation with Microkelvin backend
-
advanced_collections
Library with advanced data structures (collections). Includes counter (hash-bag, multiset), disjoint set (union-find, merge-find), circular buffer (cyclic buffer) and interval (range)
-
pasture-derive
Macro implementations for #[derive(PointType)]
-
bpht
A bit-packed hash table implementation using hopscotch hashing for 32-bit keys and values
-
rangetools
Extending the Rust Range structs found in std::ops
-
stack-buf
Vector-like facade for arrays allocated entirely on the stack
-
bitsvec
A bit vector with the Rust standard library’s portable SIMD API
-
grapes
Persistent graph data structures: Tree, Graph, Arena & more
-
sliding_window
A fixed size, heapless sliding window
-
coitrees
A very fast data structure for overlap queries on sets of intervals
-
trie
An ordered map and set based on a trie
-
diskmap
disk based HashMap-like for shared concurrent memory usage
-
more_ranges
Range types not provided in the standard library
-
ternary-tree-wasm
A simplified Wasm binding to ternary-tree crate
-
funnel
A simple data structure that makes it easy to read from multiple channels from a single source
-
pvec
RRB-Tree based persistent vector implementation
-
quetta
Immutable, reference-counted strings for rust
-
prehash
A crate for storing values with precomputed hashes
-
dgrambuf
A fixed capacity ring buffer for datagrams (byte slices)
-
spdx-toolkit
Toolkit for interacting with SPDX Documents
-
vec-strings
Store any string efficiently in an immutable way
-
fill_canvas
FillCanvas is a wrapper around a matrix with special methods to fill the cells
-
sealingslice
A mutable slice that can seal its initial part off from mutability, and hand out the sealed parts as immutable references
-
eventree
A library for creating lossless syntax trees
-
tapa-trait-serde
A collection of Tapalogi’s reusable crates
-
data-query
Query library that allows for Querying Serializable data using string queries
-
hoop
Fixed ring buffer that allows non-consuming iteration both ways
-
map_vec
The Map and Set APIs backed by Vec
-
perpendicular
Perpendicular is a simple general purpose n-dimensional vector library
-
jsonnlp
an implementation of the JSON-NLP data structure
-
take-some
A simple library that provides a way to obtain some value from various collections
-
alphabet-macro
Provides a macro that can be used to easily create const alphabets
-
lazy_concat
Lazy concatenation for Strings and Vecs
-
dlv-list
Semi-doubly linked list implemented using a vector
-
appendlist
An append-only list that preserves references to its elements
-
easy_collections
Wrappers around standard collections for ease of use and quick prototyping
-
ttmap
Trivial implementation of type map
-
ro
Helps make stuff read-only
-
tagged-tree
A tree-like data structure where the values are tagged
-
xsd-types
Built-in XSD data types
-
arrsingh
A top level crate in the workspace
-
chunked-bytes
A rope-like non-contiguous buffer for efficient data structure serialization and vectored output
-
gtrie
Generic trie implementation with a support of different key and value types
-
kalgan_string
A collection of functions for string manipulation used by Kalgan Framework
-
inplace-vec-builder
Build a vec from a vec, in place
-
shelves
Storing values referenced by a unique typed index
-
takeable
Container type that allows for temporarily moving out of the container
-
tugger-binary-analysis
Inspect platform binaries
-
btree_network
A generic network (undirected graph) data structure
-
smallbigint
Big integer types that have a small on-stack representation for small values. Uses num-bigint internally.
-
bit_mask_ring_buf
A fast ring buffer implementation with cheap and safe indexing
-
higher-cat
Functors, Applicatives, Monads and other bad ideas
-
growable-bitmap
A growable (and shrinkable) compact boolean array
-
set-trie
A trie for fast subset and superset queries
-
packed-integers
A growable array for integer types in the range
u1tou31 -
im-lists
Persistent unrolled linked lists
-
handlebox
A map-like collection that reuses unused keys
-
sized-vec
Type level sized vectors
-
leonardo-heap
Heap structure supporting fast in-place partial sorting
-
snake_case
SnakeCase is a String-like type that can only contain valid non-empty snake_case
-
json-number
JSON number parsing and storage
-
simple-bitrange
A simple crate for manipulating bit ranges which is common when working with IC registers
-
traitgraph-algo
Graph algorithms based on the traitgraph crate
-
wrapping
Wrapping slices and arrays
-
deepmesa-lists
A collection of list data structures and algorithms designed for performance
-
hat_trie
A hat-trie implementation that support prefix match iteration
-
flit
Bloom filter backed by xxHash
-
dot_json
Tools for dot map representations of serde_json Maps
-
bucket_vec
A vector-like data structure that guarantees to never move its contained elements
-
binary-tree
Collection of Binary Tree data structures and algorithms
-
shifted_vec
A growable datastructure with positive and negative indexing built on top of
std::vec::Veccalculating the offset automatically -
binary-data-schema
Meta language for raw binary serialization
-
street_index
street_index is a small utility crate for working with road name / street indexing for cartographic purposes
-
fricgan
A simple crate for performing basic input and output on bytes
-
hashable_rc
Hashable wrappers for reference countings
-
type-map
Provides a typemap container with FxHashMap
-
unrecurse
Helper crate for rewriting your recursive code in iterative way
-
guzzle-derive
The derive macro for guzzle, please use that crate not this one
-
eztd
Quick start Rust
-
heatmap
time-series of histograms with precision guarantees
-
collections-more
Common data structure and algorithms for rust-lang to complete the already excellent std::collections
-
bipbuffer
A Rust implementation of Simon Cooke’s Bip-Buffer
-
hitree
Indexable containers for Rust: HiSet and HiMap
-
const-buffer
A fixed-capacity memory buffer allocated on the stack using const generics
-
generic-bloom
A generic implementation of Bloom filters using traits
-
dbs-utils
helpers and utilities used by dragonball-sandbox components
-
bloom_filter_simple
A simple and generic bloom filter implementation
-
ndata
A self-owned data structure with an internal heap and garbage collection
-
divbuf
Buffer object that can be recursively divided into smaller buffers
-
chainmap
A ChainMap with mutability of intermediate maps
-
ensured_bufreader
A Bufreader ensures N bytes in buffer
-
entity_macros
Macro library that provides ability to generate ent logic at compile-time
-
sp-im
Immutable datatypes for no_std use within Substrate
-
static-box
A stack-allocated box that stores trait objects
-
simple_tables-core
The core functionality of the simple_tables crate
-
discrimination-tree
discrimination tree term indexing
-
enumoid
Enum Indexed Containers
-
dimension_shiftable_buffer
A dimension shiftable buffer
-
cbloom
Concurrent implementation of Bloom filters
-
deepmesa
This crate provides fast Data Structures and Algorithms in Rust. Every data structure is hand crafted for performance, well tested and has an extensive API.
-
nslice
Structures for interpreting slices of variable length as arrays
-
mown
Maybe owned values. Wrappers for values that can be either owned or borrowed.
-
bitmaptrie
Bitmapped vector trie (mutable, not persistent). Word-size path-cached indexing into essentially a sparse vector. Requires rust-nightly.
-
bounded-vec-deque
A double-ended queue|ringbuffer with an upper bound on its length
-
last-git-commit
Simple wrapper arround git2-rs to get info about the last commit. Useful for when you want to show the git hash in a program.
-
minivec
A version of Vec that’s only the size of a single pointer
-
tibitset
TiBitSet is a simple bitset replacement for HashSet
-
vhr_serde
A serde (de)serializer crate for the simplist possible binary format
-
go-heap-rs
Golang’s heap written in Rust
-
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)
-
init_trait
A small helper trait to simplify the initialisation of ‘indexable’ data structures
-
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. -
type-freak
Collection of typed data structures, trait operators and aliases
-
bloom2
Fast, compressed 2-level bloom filter and bitmap
-
modular-bitfield-msb-impl
Bitfields for structs that allow for modular use of enums. MSB-first version.
-
indexmap-amortized
A hash table with consistent order and fast iteration. The indexmap is a hash table where the iteration order of the key-value pairs is independent of the hash values of the keys. It has the usual…
-
fallacy-hash
A library for fallible hash collections
-
divsufsort
Rust port of Yuta Mori’s divsufsort
-
flexible-string
A stack heap flexible string designed to improve performance
-
offset
Glorified offsets for arbitrary structures
-
aatree
AATree implementation in Rust
-
const-arrayvec
A vec-like type backed by an array on the stack
-
qt-json
JSON library for QT
-
iostream
the project is rust io stream.you can easily use it to manipulate files stream and memory stream
-
tapestry
Generic 2D grid data structure and utilities
-
safer-bytes
safe, non-panicking wrappers around the ‘bytes’ crate
-
int-vec-2d
Vectors, points, rectangles, etc. with
i16coordinates. -
holyhashmap
A hash map with stable indices
-
llml_derive_crate
Derive macros for llml
-
sparsemat
A simple sparse matrix library
-
ordered-vecmap
Ordered map and set based on vectors and binary search
-
u64_array_bigints_macros
Macro library for
u64_array_bigints -
lighter
Macro for rewriting string matches as tries
-
compacts
compact data structures
-
btree_dag
A generic DAG (undirected graph) data structure
-
vecdeque-stableix
Deque with stable index values
-
eclectic
Experimental collection traits
-
fr-trie
Fuzzy Radix Trie
-
discord-indexmap
A fork of the popular
indexmaplibrary that adds a few extra APIs that are yet to be upstreamed -
bisetmap
BisetMap is a fast and thread-safe two-way hash map of sets. It is best suited where you need to associate two collumns uniquely. Each key is associated to one or more other unique values…
-
rbtset
A set based on a RB-Tree for efficient operations
-
automap
Simple pattern to implement key-value maps where the value type contains the key type
-
history-buffer
A fixed capacity, write-only, ring buffer
-
ring_queue
A double-ended queue implemented using a vector that reuses space after elements are removed
-
erased_set
A set of erased types
-
decoded-char
Simple wrapper to keep track of the original byte length of a decoded character in the encoded source file
-
bmap
A bitmap with an internal counter
-
comparator
A Java-like Comparator type
-
densevec
Map like collection with usize indices that stores values contiguosly
-
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
-
rc-dlist-deque
Doubly-linked list based on std::Rc
-
hash-chain
A tiered hashmap and hashset implementation that allows for easily representing lexically scoped variables
-
big_enum_set
A library for creating sets of enums with a large number of variants
-
prima
Generic 2D library used to handle graph structures and basic geometry
-
expanding_slice_rb
A self-expanding ring buffer similar to VecDeque optimized for working with slices of data
-
dynvec
This crate provides the
DynVectype that acts like a vector to store any datatype -
embedrs-bytes
Types and traits for working with bytes
-
std_collection_traits
Abstraction of operations in std collection types
-
pulz-bitset
A simple bitset implementation
-
cbor-tag-index
Tag index
-
semver-store
An HashMap structure that uses semver strings as keys
-
immutable-seq
Immutable sequence data structure
-
im_interval_tree
An immutable data structure for storing and querying a collection of intervals
-
tapa-trait-serde-derive
Tapalogi’s derive macro for tapa-trait-serde
-
fplist
An immutable, persistent, singly-linked list
-
small-ord-set
A set data-structure represented by a sorted
SmallVec -
indexmap-rmw
A hash table with consistent order and fast iteration. The indexmap is a hash table where the iteration order of the key-value pairs is independent of the hash values of the keys. It has the usual…
-
gen-vec
Vector indexed with generational indices
-
prefix-tree
A map and set interfaces using trie data structure
-
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.
-
gvec
Very simple implementation of generational indexing for vectors written in Rust
-
range-traits
Ranges related traits
-
holodeque
Array- and slice-backed double-ended queues in 100% safe Rust
-
byte_set
Efficient sets of bytes
-
fixed-map-derive
A fixed map where storage layout is calculated by a procedural macro. This crate contains the procedural macros
-
non-empty-collections
Non-empty hash-map and hash-set implementations
-
tinystr-macros
Proc macros for TinyStr
-
fral
Functional random-access lists
-
bytebufrs
A ring buffer for bytes implementing io::Read and io::Write
-
traitgraph-tsplib-io
Functions to read and write graphs in TSPLIB format
-
sparse_set
Implementation of the sparse set data structure
-
bset
Fast and compact sets of bytes or ASCII characters
-
deepmesa-collections
A collection of data structures and algorithms designed for performance
-
projected-hash-map
Implementation of a projected HashMap over HashSet
-
byte_trie
A compressed trie based on bytes with some weird child node bucket sizes
-
arrsingh-lists
A test crate to test publishing
-
appendix
Append-only, on-disk key-value index
-
tree-automata
Term Rewriting Systems
-
rahashmap
Fork of standard library HashMap with additional functionality
-
artsy
ART Tree data structure library
-
lightning-containers
A set of lock-free data structures