-
bitvec
A crate for manipulating memory, bit by bit
-
hdrhistogram
A port of HdrHistogram to Rust
-
smallvec
‘Small vector’ optimization: store up to a small number of items on the stack
-
generic-array
Generic types implementing functionality of arrays
-
bytes
Types and traits for working with bytes
-
arrayvec
A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.
-
hashbrown
A Rust port of Google’s SwissTable hash map
-
predicates
An implementation of boolean-valued predicate functions
-
num
A collection of numeric types and traits for Rust, including bigint, complex, rational, range iterators, generic integers, and more!
-
bit-vec
A vector of bits
-
arc-swap
Atomically swappable Arc
-
crdts
Practical serializable thoroughly tested CRDTs (ORSWOT, counters, LWW) ported from riak_dt
-
priority-queue
A Priority Queue implemented as a heap with a function to efficiently change the priority of an item
-
ndarray
An n-dimensional array for general elements and for numerics. Lightweight array views and slicing; views support chunking and splitting.
-
scroll
A suite of powerful, extensible, generic, endian-aware Read/Write traits for byte buffers
-
bimap
Bijective maps
-
staticvec
Implements a fixed-capacity stack-allocated Vec alternative backed by an array, using const generics
-
linked-hash-map
A HashMap wrapper that holds key-value pairs in insertion order
-
im
Immutable collection datatypes
-
radix_trie
Generic radix trie data-structure
-
tinystr
A small ASCII-only bounded length string representation
-
enumset
A library for creating compact sets of enums
-
enum-ordinalize
This crates provides a procedural macro to let enums not only get its variants’ ordinal but also be constructed from an ordinal
-
merkle-cbt
A library for generating efficient Merkle tree and combined Merkle proof based on complete binary tree
-
either
The enum
Eitherwith variantsLeftandRightis a general purpose sum type with two cases -
indextree
Arena based tree structure by using indices instead of reference counted pointers
-
spade
Spatial datastructures like r-trees and delaunay triangulations for rust
-
indexmap
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…
-
heapless
staticfriendly data structures that don’t require dynamic memory allocation -
starling
This tree structure is a binary merkle tree with branch compression via split indexes
-
generator
Stackfull Generator Library in Rust
-
linked_hash_set
HashSet with insertion ordering
-
sized-chunks
Efficient sized chunk datatypes
-
array-init
Safe wrapper for initializing fixed-size arrays
-
rust_decimal_macros
Shorthand macros to assist creating Decimal types
-
tinyvec
tinyvecprovides 100% safe vec-like data structures -
sharded-slab
A lock-free concurrent slab
-
rpds
Persistent data structures with structural sharing
-
vec_map
A simple map based on a vector for small integer keys
-
bv
Bit-vectors and bit-slices
-
qp-trie
An idiomatic and fast QP-trie implementation in pure Rust, written with an emphasis on safety
-
anymap
A safe and convenient store for one value of each type
-
ansi_term
Library for ANSI terminal colours and styles (bold, underline)
-
cidr-utils
This crate provides data structures and functions to deal with IPv4 CIDRs and IPv6 CIDRs
-
hdf5
Thread-safe Rust bindings for the HDF5 library
-
convenient-skiplist
Convenient and Performant SkipList with serde support
-
rusty_ulid
Rust ULID (Universally Unique Lexicographically Sortable Identifier) generation and processing
-
rstar
R*-tree library for the rust ecosystem
-
molecule
Rust bindings for molecule
-
llvm-ir
LLVM IR in natural Rust data structures
-
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…
-
fraction
Lossless fractions and decimals; drop-in float replacement
-
string-interner
Efficient string interner with minimal memory footprint and fast access to the underlying strings
-
vec1
a std Vec wrapper assuring that it has at least 1 element
-
array-macro
Array multiple elements constructor syntax
-
petgraph
Graph data structure library. Provides graph types and graph algorithms.
-
landon
A collection of tools, data structures and methods for exporting Blender data (such as meshes and armatures) and preparing it for your rendering pipeline
-
binary-heap-plus
Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps
-
guppy
Track and query Cargo dependency graphs
-
patricia_tree
Memory-efficient data structures based on patricia tree
-
intrusive-collections
Intrusive collections for Rust (linked list and red-black tree)
-
ucd-trie
A trie for storing Unicode codepoint sets and maps
-
kdtree
K-dimensional tree in Rust for fast geospatial indexing and nearest neighbors lookup
-
string
A UTF-8 encoded string with configurable byte storage
-
roaring
http://roaringbitmap.org : A better compressed bitset - pure Rust implementation
-
typescript-definitions-ufo-patch
serde support for exporting Typescript definitions
-
smallbitvec
A bit vector optimized for size and inline storage
-
bit-set
A set of bits
-
id_tree
A library for creating and modifying Tree structures
-
hibitset
Hierarchical bit set structure
-
trees
General purpose tree data structures
-
slice-dst
Slice-based custom DSTs
-
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.
-
arr_macro
Initialize arrays with ease!
-
circular-queue
A circular buffer-like queue
-
vob
Vector of Bits with Vec-like API and usize backing storage
-
sorted-iter
Typesafe extensions for sorted iterators, including set and relational operations
-
rc-u8-reader
A tiny implement for reading
u8data from a reference counted instance -
index_vec
Newtype-style helpers for
Vecandusize -
defaultmap
Provides a HashMap with an automatic default for missing keys
-
bloomfilter
Bloom filter implementation
-
concread
Concurrently Readable Data-Structures for Rust
-
im-rc
Immutable collection datatypes (the fast but not thread safe version)
-
arccstr
Thread-safe, reference-counted null-terminated immutable strings
-
hash_hasher
A hasher which is designed to work with already-hashed or hash-like data
-
dinotree_alg
Dinotree algorithms
-
uluru
A simple, fast, LRU cache implementation
-
flat-tree
Rust module for encoding/decoding varints that doesn’t do any IO. Inspired by the Node.js varint module
-
min-max-heap
An efficient, double-ended priority queue
-
flatk
Flat layout abstraction toolkit
-
typed-index-collections
Typed index version of Rust slice and Vec containers
-
bitlab
Extracting a range of bits from a binary data source
-
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.
-
ena
Union-find, congruence closure, and other unification code. Based on code from rustc.
-
wide
A crate to help you go wide
-
kelvin-radix
Radix Tree data structure
-
redo
Provides advanced undo-redo functionality with static dispatch
-
adapton
programming abstractions for general-purpose incremental computations
-
threshold
Threshold data structures
-
graphlib
Graphlib is a simple and powerful rust library for the graph data-structure
-
cmdtree
(Rust) commands tree
-
treeflection
A library that provides reflection for tree structures
-
typescript-definitions
serde support for exporting Typescript definitions
-
kstring
Key String: optimized for map keys
-
trie-root
In-memory patricia trie operations
-
json_dotpath
Dotted path access to nested JSON objects (serde_json::Value)
-
fid
FID (Fully Indexable Dictionary) implementation for Rust
-
probabilistic-collections
Various implementations of collections that use approximations to improve on running time or memory, but introduce a certain amount of error
-
tiled
A rust crate for loading in maps created by the Tiled editor
-
stackvector
StackVec: vector-like facade for stack-allocated arrays
-
macaddr
MAC address types
-
contest-algorithms
Common algorithms and data structures for programming contests
-
rustfst
Library for constructing, combining, optimizing, and searching weighted finite-state transducers (FSTs)
-
egg
An implementation of egraphs
-
timely_communication
Communication layer for timely dataflow
-
optional
This crate supplies a number of Option-like primitive types
-
keyvi
Keyvi - the key value index. It is an in-memory FST-based data structure highly optimized for size and lookup performance.
-
griddle
A HashMap variant that spreads resize load across inserts
-
pagetable
simple wait-free two-level pagetable with 2mb pages
-
option_set
Bitflags on steroids
-
bitvector
BitVector implementation in Rust
-
c_vec
Structures to wrap C arrays
-
enum-map
A map with C-like enum keys represented internally as an array
-
cactus
Immutable parent pointer tree
-
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. -
zbus_macros
proc-macros for zbus
-
ternary-tree
A Rust implementation of Ternary Search Trees, with no unsafe blocks
-
daab
DAG aware artifact builder
-
histogram
histogram storage and percentile metrics with precision guarentees
-
ordered-multimap
Insertion ordered multimap
-
ibuilder
Interactive builder for Rust types
-
slab_tree
A vec-backed tree structure with tree-specific generational indexes
-
sparse-bitfield
Bitfield that allocates a series of small buffers
-
simple_endian
A create for defining endianness within your data structures, to make handling portable data structures simpler
-
ndsparse
Sparse structures for N-dimensions
-
intervaltree
A simple and generic implementation of an immutable interval tree
-
kserd
Kurt’s Self-Explanatory Rust Data
-
intrusive_splay_tree
An intrusive splay tree implementation that is no-std compatible and free from allocation and moves
-
persist-o-vec
A Vec type that aims to have stable indices and memory location
-
nanoset-py
A memory-optimized wrapper for Python sets likely to be empty
-
panoradix
A generic map and a set, both backed by a Radix tree
-
yyid
Yyid generator (random tokens like UUIDv4, but using all the bits)
-
rangemap
Map data structure whose keys are stored as ranges. Contiguous and overlapping ranges that map to the same value are coalesced into a single range
-
treez
A collection of useful data structures
-
tri-mesh
A triangle mesh data structure including basic operations
-
voluntary-servitude
Thread-safe appendable list with lock-free iterator
-
ndarray-stats
Statistical routines for ArrayBase, the n-dimensional array data structure provided by ndarray
-
nibble_vec
Vector data-structure for half-byte values
-
exonum-merkledb
Persistent storage implementation based on RocksDB which provides APIs to work with Merkelized data structures
-
cedarwood
efficiently-updatable double-array trie in Rust (ported from cedar)
-
byte_set
Efficient sets of bytes
-
trk-io
TrackVis (*.trk) reader and writer
-
smartstring
Compact inlined strings
-
rust-fsm
A framework for building finite state machines in Rust
-
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…
-
toodee
A lightweight 2D wrapper around a Vec
-
flatgeobuf
FlatGeobuf for Rust
-
retworkx
A python graph library implemented in Rust
-
usher
Parameterized routing for generic resources in Rust
-
slice-deque
A double-ended queue that Deref’s into a slice
-
numeric-array
Wrapper around generic-array that adds efficient numeric trait implementations
-
cervine
A slightly more flexible Cow; roughly to T: Borrow as alloc::borrow::Cow is to B: ToOwned
-
abi_stable_shared
Implementation detail of abi_stable
-
subset-map
A map where the keys are subsets of an initial set of elements
-
dlv-list
Semi-doubly linked list implemented using a vector
-
cid
CID in rust
-
ego-tree
Vec-backed ID-tree
-
blender-armature
Serialize / deserialize Blender armatures
-
fixedbitset
FixedBitSet is a simple bitset collection
-
vec-dimension-shift
N-Dimension shift features for Vec
-
ahtable
Array Hash Table implementation
-
plain
A small Rust library that allows users to reinterpret data of certain types safely
-
vec-collections
Rust collections that are newtype wrappers around smallvec
-
fenwick
Fenwick tree: data structure that efficiently calculates prefix sums in a changing array of numbers
-
hopscotch
A FIFO queue for efficiently hopping and skipping between tagged items
-
fixed-map
A fixed map where storage layout is calculated by a procedural macro
-
beach_map
Implementation of a slotmap
-
merkle
Merkle tree implementation with support for generation of inclusion proofs
-
intmap
Specialized HashMap for u64 keys
-
queues
Efficient FIFO Queue data structures
-
sum
General-purpose sum types
-
bit_mask_ring_buf
A fast ring buffer implementation with cheap and safe indexing
-
generational-indextree
Arena based tree structure by using indices instead of reference counted pointers
-
space
A library providing abstractions for spatial datastructures and search
-
rle_vec
A vector like struct that stores data as runs of identical values. Useful for storing sparse data.
-
immutable-chunkmap
A cache efficient immutable map and set with lookup performance equivalent to BTreeMap and BTreeSet, fast batch insert and update methods, and efficient implementations of all set operations
-
large_int
An ease-of-use unbounded signed integer
-
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 -
sortedvec
a sorted vector that enables quick lookups
-
nested
A memory efficient container for nested collections (like
Vec<String>orVec<Vec<T>>) -
fwdlist
A simply linked (forward) list
-
bitmaps
Fixed size boolean arrays
-
alloc-wg
Attempt of collection several proposals of the allocators-wg
-
binn-ir
An implementation of Binn - https://github.com/liteserver/binn
-
patricia_router
Radix Tree implementation for Rust
-
bucket_vec
A vector-like data structure that guarantees to never move its contained elements
-
fm-index
FM index and its variant implementations for Rust
-
bitwrap
pack/unpack data into byte array
-
verify
A validation library
-
cast-rs
A collection of types cast for Rust
-
rsdict
Fast static rank and select data structure
-
rust_decimal_macro_impls
Shorthand macros to assist creating Decimal types. Do not depend on this directly; use rust_decimal_macros
-
vmm-sys-util
A system utility set
-
base_custom
Use any characters as your own numeric base and convert to and from decimal
-
misc_utils
A small collection of convenient and utility functions developed for personal use
-
disjoint-sets
Three union-find implementations
-
extindex
Persisted immutable index
-
big_unsigned_ints
A Crate For Big Unsigned Integers ranging from U256 to U2048 using u64 arrays all under a fixed-size of 32
-
orderbook
Orderbook for Rust
-
floating_bar
Representing rational numbers using the floating-bar number type
-
smallstr
String-like container based on smallvec
-
watermark
A simple watermarking set for in-order insertions
-
stash
An amortized
O(1)table for cases where you don’t need to choose the keys and want something faster than a HashTable -
skiplist
Skiplist implementation in rust, providing fast insertion and removal. A normal skiplist is implemented, as well as an ordered skiplist and a skipmap.
-
keyed_priority_queue
Priority queue that support changing priority or early remove by key
-
rc-borrow
Borrowed forms of Rc and Arc
-
tree-automata
Term Rewriting Systems
-
signrel
Trait expressing relationship between integers of different signedness
-
rustc-ap-rustc_data_structures
Automatically published version of the package
rustc_data_structuresin the rust-lang/rust repository from commit 44ae0b8b2def2a26b82e0a93f8c8c2c523cc3643 The publishing script for this crate lives at: https://github… -
undo
Provides simple undo-redo functionality with dynamic dispatch
-
hashlink
HashMap-like containers that hold their key-value pairs in a user controllable order
-
designal
Procedural macro for use with futures-signals
-
vector-map
VecMap<K, V>: a Linear Search with Map API
-
tst
Ternary search trie collection in rust with similar API to std::collections as it possible
-
splay_tree
Splay Tree based Data Structures (map, set, heap)
-
petal-clustering
A collection of clustering algorithms
-
rc-writer
A tiny implement for writing data to a reference counted instance
-
slabmap
HashMap-like collection that automatically determines the key
-
kvdb-rocksdb
kvdb implementation backed by RocksDB
-
bounded-spsc-queue
A bounded SPSC queue
-
simd_aligned
Safe and fast SIMD-aligned data structures with easy and transparent ‘flat’ access
-
one_way_slot_map
An implementation of SlotMap with minimal restrictions on Keys and Values
-
scapegoat
Ordered set and map data structures via an arena-based scapegoat tree
-
queue-file
queue-file is a lightning-fast, transactional, file-based FIFO
-
sparsevec
Compress vectors using row displacement
-
flit
Bloom filter backed by xxHash
-
keylist
Elixir keyword list in Rust
-
imag-id-in-collection
Part of the imag core distribution: imag-ids command
-
idcontain
Generational (or tagged) ID-based containers
-
chainkov
HashMap / Tuple-backed Markov Chains
-
mori
An orientation library built around commonly used orientation representations used in crystallography and engineering applications. It contains conversion, rotation, and data analysis…
-
nested_intervals
nested & overlapping interval set functions, overlap, union, etc
-
onigiri
This crate is a tool of handling chars
-
unstructured
Generic types for unstructured data
-
buffer-trigger
A data collection trigger based on the maximum number and refresh time
-
csv2json
Converts CSVs into JSON documents
-
galemu
Provides a workaround for generic associated types (GAT) limited to lifetimes (GAL)
-
xml-schema
Structure generator from XSD source file
-
pvec
RRB-Tree based persistent vector implementation
-
numas
numas library is implementation of multidimensional array for efficient computing
-
fingertrees
Immutable persisten finger trees
-
plum
Probabilistic data structures for rust
-
succinct_rs
Succinct Data Structures library for Rust
-
k2_tree
A space-efficient representation of sparsely populated bit-matrices
-
cmp_wrap
Let you compare structes by context
-
typed_index_collection
Manage collection of objects
-
higher_order_functions
A small collection of traits for implementing higher order functions
-
smart_access
A minimalistic “lazy bidirectional pointer” framework
-
todo_lib
Collection of utilities for todo.txt format
-
sea-canal
Identifies patterns in sequences of integers
-
osproto
Protocol structures for OpenStack API
-
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.
-
rb_tree
A Red Black Tree implementation in Rust
-
grid
Dynamic generic 2D data structure
-
midas_cli
Rust port of MIDAS (Microcluster-Based Detector of Anomalies in Edge Streams)
-
grammers-tl-types
Rust definitions for Telegram’s API types and functions
-
slist
Algebraic lists with statically determined size that live on stack
-
liblet
Library for learning about formal languages and grammars
-
bloom
Fast Bloom Filter and Counting Bloom Filter implementation
-
chainmap
A ChainMap with mutability of intermediate maps
-
libnv
Safe and rustic wrapper around libnv-sys
-
succinct
Succinct data structures for Rust
-
idlset
Fast u64 set operations library
-
ulid
a Universally Unique Lexicographically Sortable Identifier implementation
-
webe_id
Unique ID generator based on Snowflake, but for us wizards
-
dync
An efficient alternative to
dyn Traitfor containerized types -
rexsgdata
Scatter-Gather Data Descriptors
-
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. -
radix-tree
A radix tree implementation for router, path search
-
alg_ds
Algorithms & data structures
-
stack
DSTs and arrays on the stack!
-
code_location
A library to automatically acquire a code location in a rust source code file
-
strict
NonEmptyVec, a vec guaranteed to hold at least one element
-
slack-blocks
Models + clientside validation for Slack’s JSON Block Kit
-
exponential-decay-histogram
A histogram which exponentially weights in favor of recent values
-
resources
Safe store for one value of each type, with interior mutability
-
avl
A map and a set implemented with an AVL tree
-
jirachi
A collision resistant runtime agnostic key-generator
-
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.
-
sbf
Spatial Bloom Filter, a probabilistic data structure that maps elements of a space to indexed disjoint subsets of that space
-
gen-vec
Vector indexed with generational indices
-
radix-heap
Fast monotone priority queues
-
treers
Simple implementation of Sedgewick’s tree maps
-
guppy-summaries
Build summaries for Cargo, created by guppy
-
erasable
Type-erased thin pointers
-
elsa
Append-only collections for Rust where borrows to entries can outlive insertions
-
predicates-tree
Render boolean-valued predicate functions results as a tree
-
simple-matrix
A simple generic matrix library
-
string-wrapper
A possibly-stack-allocated string with generic bytes storage
-
atree
An arena based tree structure with removal support
-
boolvec
A vector of boolean stored contiguously in memory
-
uuid-rs
A Simple Universally Unique IDentifier (UUID)
-
rudac
A crate for common data structures and algorithms
-
outils
Graph and tree data structure library. Providing utilities which aren’t easily available in Rust.
-
hash-rings
Implementations of various hash rings
-
passive
A trio of marker traits to classify passive data structures
-
fallible_collections
a crate which adds fallible allocation api to std collections
-
ensure
Ensure target state of an object
-
bucket_queue
A Bucket Queue data structure that can be used as a Priority Queue
-
iset
This crates implements map and set with interval keys
-
tiny_ecs
A tiny ECS that tries to avoid unnecessary copy/clones
-
mset
A mset / multiset / bag implementation
-
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 -
theban_interval_tree
A simple Interval Tree implementation
-
swaybar-types
A library for building swaybar status commands in rust
-
multiformats
Implementation of the Multiformats for libp2p
-
chainbuf
Fast chained buffers
-
moniker
Automatically derive variable binding and alpha equivalence for abstract syntax trees
-
index-ext
Index slices with arbitrary ints and as arrays
-
cow_vec_item
Copy-on-write Vec, available on stable rust
-
segment-map
A self-balancing binary search tree for mapping discrete, disjoint segments to values
-
guzzle
A derivable trait for consuming key value pairs into structs
-
poisson
Poisson-disk distribution generator
-
polytype
A Hindley-Milner polymorphic typing system
-
backtracking_iterator
A simple implementation of a generic iterator with an item history, capable of backtracking and forgetting
-
static_merkle_tree
Static Merkle Tree is dedicated for generating Merkle Root and Merkle Proof for a static list of items
-
vec-tree
A safe tree using an arena allocator that allows deletion without suffering from the ABA problem by using generational indices
-
array_ext
Extra functionality for Rust arrays
-
hashbrown_tstd
A Rust port of Google’s SwissTable hash map
-
advancedresearch-max_tree
A utility maximizer library based on a maximum tree structure
-
collectable
Fallible, no_std-friendly collection traits
-
ic-types
Types related to the Internet Computer Public Specification
-
nave
Thinking about the construction of distributed systems starting from the consistent hash algorithm
-
mmap_json_file
A library to parse, count, filter JSON files using memory mapped io library
-
text-style
Types and conversions for styled text
-
edit_tree
Edit trees in rust
-
wavelet-matrix
A wavelet matrix implementation. Supports various near-O(1) queries on large number of symbols or integers.
-
version-rs
A struct for Versions, with the methods you expect
-
fixed-vec-deque
A fixed-size, zero-allocation circular buffer for Rust
-
packedvec
Store vectors of integers efficiently
-
slice-of-array
Extension traits for casting between slices and slices of arrays. (&[T] <-> &[[T; n]])
-
manhattan-tree
A spatial tree which can effiently find closest key to a point, by manhattan distance
-
bitrush-index
A serializable bitmap index library able to index millions values/sec on a single thread
-
arraystring
Fixed capacity stack based generic string
-
smallbigint
Big integer types that have a small on-stack representation for small values. Uses num-bigint internally.
-
dcc-lsystem
An implementation of a Lindenmayer system together with some rendering tools
-
mown
Maybe owned values. Wrappers for values that can be either owned or borrowed.
-
derive_wrapper
Rust custom derive macro for wrapping types
-
sgf-parse
A parser for the SGF file format for Go games
-
bip_metainfo
Parsing and building of bittorrent metainfo files
-
gridly
A library for managing fixed-size 2D spaces
-
bex
A rust library for working with boolean expressions (syntax trees, decision diagrams, algebraic normal form, etc.)
-
hodgepodge
A hodgepodge of enums
-
simple-rate-limit
Rate limit enforcement as simple data structures, no atomics
-
isolanguage-1
ISO 639-1 library with optional Serde support
-
trie-bench
Standard benchmarking suite for tries
-
intervallum
Generic interval and interval set library
-
rbl_circular_buffer
A zero-allocation, fast, circular buffer implementation in Rust
-
Project2
Implementations of red black tree and AVL tree
-
growable-bloom-filter
Scalable Bloom Filters with serde support
-
multiset
Multisets/bags
-
relational_types
Manage relations between objects
-
handy
A library providing handles and handlemaps
-
st-map
Runtime for a stack-alocated map
-
minimal-id
A library that implements generating short, unique ids with minimal collisions and good locality
-
quickscope
Multi-layer HashMap and HashSet implementations for performant representation of variable scopes
-
modular-bitfield
Bitfields for structs that allow for modular use of enums
-
const-buffer
A fixed-capacity memory buffer allocated on the stack using const generics
-
sequencetree
a new type of collection to store keys and their corresponding values
-
hashable_rc
Hashable wrappers for reference countings
-
hierarchical_hash_wheel_timer
A low-level timer implementantion using a hierarchical four-level hash wheel with overflow
-
finite-automata
A collection of extendable finite automata with immutable state and transition data
-
iterable
An iterable library for Rust collection like types
-
terms
Tree terms and patterns data structures
-
pl-lens
Provides support for lenses, which are a mechanism in functional programming for focusing on a part of a complex data structure
-
hash-chain
A tiered hashmap and hashset implementation that allows for easily representing lexically scoped variables
-
timely
A low-latency data-parallel dataflow system in Rust
-
fst_stringstring
String-to-String Map built from fst
-
bet
Helps parsing and evaluating binary expression trees
-
pciids
A library to parse the pci.ids data file
-
kvdb
Generic key-value trait
-
cvrdt-exposition
Understanding Convergent Replicated Data Types
-
string_map
Create a record to store any type of value
-
iowrap
Small helpers for using io::Read/io::Write
-
mop-structs
Low-level structures for MOP
-
lending-library
A key-value store that loans full ownership of items
-
chunked-bytes
A rope-like non-contiguous buffer for efficient data structure serialization and vectored output
-
cliquers
Manage filesequences with a common numeric component
-
rustz
A library for functional programming in Rust
-
gsrs
Generic Self Referencing Struct
-
spool
Simple object pool for upfront allocation!
-
dispatchtable
Small library used to specify function dispatch tables HashMap<K, Box<Fn(..)>>
-
path-value
Universal type and access property(s) by path
-
sqa-bounded-spsc-queue
A bounded SPSC queue (temporary version so I can publish sqa-engine)
-
containers
Containers
-
generic-tree
A very simple, intuitive API for storing data in a tree-like structure
-
multiref
Multireferences: a safe way to do [&T] -> &[T]
-
zerobuf
A growable chunk of zeroed memory
-
ffi-convert
A collection of utilities to ease conversion between Rust and C-compatible data structures
-
non-empty-collections
Non-empty hash-map and hash-set implementations
-
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.
-
heaparray
Flexible support for dynamically-sized types, using heap-allocated array of structs
-
avm1-tree
Abstract Syntax Tree (AST) for AVM1
-
checked
Implements a wrapper over the primitive Rust types that better indicates overflow during arithmetic
-
om2
A set of classes generated from the OM2 RDF schema (mainly Unit)
-
hash_ring
Consistent Hashing library for Rust
-
identitycard
中国身份证随机生成工具
-
inspector
General purpose inspection for popular data structures
-
leak
Safely leak data from owned data structures
-
bonzai
An abstraction for optimizing the memory layout and pointer aliasing of trees
-
jagged_array
Owned
[[T]]-like 2D array where each row can differ in 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.
-
range
A library for range addressing
-
hedge
An index based half-edge mesh implementation
-
rustupolis
An implementation of the tuple space data structure in Rust
-
json-trait-rs
Rust interface (aka trait) to deal with objects as they are JSON objects
-
data_reader
A data loading library for data scientist
-
xi-rope
A generic rope data structure built on top of B-Trees
-
hat_trie
A hat-trie implementation that support prefix match iteration
-
stable_bst
An ordered map and set based on a binary search tree. Works with stable Rust 1.9.0.
-
aci_ppm
Encode and decode PNM image files (TODO: so far only PPM)
-
indexed_vec
IndexVecfromlibrustc_data_structures -
hex2d
Helper library for working with 2d hex-grid maps
-
grafana-dashboard
grafana import/export data serializable structures
-
watchface
A smartwatch watchface implementation
-
puruda-macro
proc macro for puruda
-
lz_diet
An AVL balanced Discrete Interval Encoding Tree
-
symbolmap-trait
A trait for generic implementation of symbol tables
-
debt64
An implementation of Base64 - https://en.wikipedia.org/wiki/Base64
-
isomorphism
2 directional hashmaps
-
compt
A complete binary tree visitor library
-
fast_paths
Fast shortest path calculations on directed graphs made possible by pre-processing the graph using Contraction Hierarchies
-
fuzzy_trie
Key-value collection to make fuzzy searches
-
sequence_trie
Trie-like data-structure for storing sequences of values
-
reso_dd
Structures and Enumerations that implement the Real Estate Standards Organization (RESO) Data Dictionary
-
tag-vec
A vector used for storing tags
-
be-tree
B𝛆 Tree library in Rust
-
soa-vec
A simple Vec-like API over a struct of arrays layout
-
alphabet-macro
Provides a macro that can be used to easily create const alphabets
-
vf-rs
A set of classes generated from the ValueFlows RDF schema
-
atomic-take
Atomically take a value out of a container once
-
wrapping
Wrapping slices and arrays
-
indexed
Convenient allocator for index-linked data structures
-
flo_rope
An attributed and streaming implementation of the rope data structure
-
broom
An ergonomic tracing garbage collector that supports mark ’n sweep garbage collection
-
dia-i18n
ISO 3166-1 and ISO 639 codes
-
persistent_rope
An immutable persistent rope data structure
-
smart-hash
partial queries in HashSets, the traits
-
tiled-json-rs
A crate to parse and interact with Tiled editor JSON files
-
slots
Fixed size data structure with constant-time operations
-
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
-
free-ranges
An efficient data structure for keeping track of indices which are either free or not
-
jsonschema-transpiler
A tool to transpile JSON Schema into schemas for data processing
-
paginate
A framework agnostic pagination crate, that is especially suited for databases, collections and web pages
-
array_stump
A data structure mixing dynamic array and sorted set semantics
-
mucell
A cell with the ability to mutate the value through an immutable reference when safe
-
ruyi-slab
An object based allocator
-
graphstack
Graph-structured stack
-
blender-mesh
Serialize / deserialize Blender armatures
-
apint
Arbitrary precision integers library
-
algo
Algorithms & Data Structure implementations
-
permutate
Generic permutator that permutates singular and multiple lists
-
arq
Arq library to manage Arq Backup data formats
-
two-sided-vec
Double ended vectors for rust, which can grow in both the front and back
-
roadmap
model a project roadmap as a directed acyclic graph
-
normalize_interval
Normalizing interval library
-
sequence-map
Implements a map of unsigned 64-bit keys into strings. The map is optimized for creating it once, and then reading many times. The struct
Builderis used to build the map, and the structMapis used for lookups… -
cita_trie
Modified Patricia Tree (aka Trie)
-
lumberjack
Read and modify constituency trees
-
dicom-dictionary-std
Standard DICOM attribute dictionary
-
decision_table
Data structure for storing and validating decision tables
-
uvector
access two slices as a single continuous vector
-
froop
A functional reactive stream library for rust
-
genmap
A simple generational map data structure with no dependencies
-
varuint
Variable length signed and unsigned integer types
-
sprs_suitesparse_ldl
sprs bindings to the suitesparse ldl solver
-
tilecoding
Rust implementation of Dr. Richard S. Sutton’s tile coding software.
-
wccg-models
WCCG Data
-
sesstype
An implementation of Multiparty Session Types
-
weak-self
WeakSelf is simple way to have a Weak pointer to yourself
-
refactory_string
A library to modify a string using original indices. Useful for Source Code transformations.
-
minecraft_end_generation
The minecraft end generation implemented in rust
-
ika
rusty object pool
-
uid
A crate for the creation of unique IDs
-
coitrees
A very fast data structure for overlap queries on sets of intervals
-
sparseset
A Sparse Set
-
densevec
Map like collection with usize indices that stores values contiguosly
-
data_structure_traits
data structure collection traits
-
aligned-bytes
A continuous fixed-length byte array with a specified alignment
-
pod
Plain Old Data (POD) encoding and I/O
-
vec-utils
vector utilities
-
gapbuf
Generic gap buffer
-
stomp
A full STOMP 1.2 client implementation. Allows programs to interact with message queueing services like ActiveMQ and RabbitMQ.
-
enum_vec
Efficiently store a vector of enum variants as a packed n-bit vec
-
static_type_map
A type map that works over all types implementing
Any -
geogrid
Manipulate geographic data on a grid
-
hashbag
An unordered multiset implementation using a hash bag
-
ptr-union
Pointer union types the size of a pointer by storing the tag in the alignment bits
-
partial
Optional monad with fake variant
-
restor
A dynamic resource storage system in rust
-
array-const-fn-init
Initializes an array with constant values calculated by a
const fn -
teardown_tree
A binary search tree that supports fast clone and delete-range operations
-
treeflection_derive
#[derive(Node)] macro for the Treeflection library
-
actions
Software without side-effects. Redo and Undo. Macro’s.
-
nullvec
Rust nullable vector, which can contain null(missing) values as element
-
type-map
Provides a typemap container with FxHashMap
-
vec-array
Embedded scripting for Rust
-
vec4
vec4
-
geomprim2d
2D geometric primitive types
-
safe_index
Type-safe indexes
-
ternary-tree-wasm
A simplified Wasm binding to ternary-tree crate
-
dimension_shiftable_buffer
A dimension shiftable buffer
-
mediumvec
Vector types optimized for space, including a 32-bit Vec
-
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.
-
multipath
A library to split file path, like
/home/{user,admin}/file.txt -
staticsort
Implements a macro providing a compile-time quicksort function for arrays of any length, containing any primitive Copy type with a PartialOrd implementation
-
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…
-
restorable
An iterator adapter for saving and restoring iterator state
-
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)
-
bpht
A bit-packed hash table implementation using hopscotch hashing for 32-bit keys and values
-
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)…
-
traitgraph
Different representations with implemented operations on graphs
-
stonks
Sets that allow borrowing while inserting entries
-
nonminmax
Primitives types which cannot be their minimum/maximum value
-
bytes_chain
Zero copy bytes chain based on crate
bytes -
segment-tree
Quickly perform interval queries or modifications
-
soak
Transform a struct into arrays of its fields
-
divbuf
Buffer object that can be recursively divided into smaller buffers
-
generic-arrayvec
Interop between the arrayvec and generic_array crates
-
flot
Generate HTML documents with embedded charts using Flot
-
treeline
a library for visualizing tree structured data
-
dyn-iter
Wrapper around
Box<dyn Iterator<Item = V> + 'iter>to simplify your code -
ball-tree
Ball-tree implementation for K-nearest neighbors
-
grdf
Generalized RDF graphs and datasets
-
key-vec
Vec of key-value pairs sorted by key
-
replicante_models_agent
Replicante Agent API request/response models
-
ttm-rs
CLI to turn tuples into adjacency matrices
-
fp-collections
An alternate collections library for rust
-
recycle_vec
Provides a method for Vec to recycle it’s backing allocation for use with another Vec of different type
-
atone
A VecDeque and Vec variant that spreads resize load across pushes
-
wordsworth
A collection of natural language analysis functions
-
non-empty-vec
NonEmptyvector implementation, ensure non-emptiness by construction -
unsized_enum
Unsized enum implementation
-
sum-queue
Queue struct that keeps a fixed number of items by time, not capacity, and allows to get summarized stats of its content
-
type-freak
Collection of typed data structures, trait operators and aliases
-
freezebox
FreezeBox: a deref’able lazy-initialized container
-
dockerfile
A Rust library for dynamically generating Dockerfiles
-
lhlist
Labeled heterogeneous lists
-
extended-rational
Provides implementations of high-accuracy projectively-extended rational numbers and macros for creating them
-
shuffled-iter
Iterate through a set of values in random order without allocating them all
-
dary_heap
A d-ary heap
-
init_trait
A small helper trait to simplify the initialisation of ‘indexable’ data structures
-
nummap
Defines a wrapper around a
HashMapof number values which behaves as if ALL keys are mapped but0values are not stored -
loaf
Why have a slice when you can have a loaf?
-
adivon
Data Structures of daily use: Graph, HashTable, PriorityQueue, Trie, SuffixTree, Rope, SplayTree, SkipList, RedBlackTree
-
ordsearch
A data structure for efficient lower-bound lookups
-
colours
Color types for different color models with conversions between it
-
feattle-core
Featture toggles for Rust, extensible and with background synchronization and administation UI
-
vec_arith
Powerful vector/matrix arithmetic library written in Rust
-
gridd
A generic, dirt-simple, two-dimensional grid
-
rc-box
Known unique versions of Rc and Arc
-
simple_ringbuf
Simple Ringbuf is a speedy lightweight fixed-size infinite-use collection optimized for straightforward single threaded use
-
slice_ring_buf
A fast ring buffer implementation optimized for working with slices
-
abstract_integers
Defining specification-friendly bounded natural integer types
-
clampf
Clamped floating-point types
-
transducers
A transducer library for Rust
-
compare
Experimental comparators for collections to be generic over
-
helgoboss-midi
Interfaces, data structures and utilities for dealing with MIDI messages according to the MIDI 1.0 specification
-
field-ref
Field reference (like a member pointer to non-static data field in C++) for Rust
-
trie
An ordered map and set based on a trie
-
collect_slice
Collect an iterator into a slice
-
immutable-map
An immutable ordered map and set based on weight-balanced tree
-
funnel
A simple data structure that makes it easy to read from multiple channels from a single source
-
terminal-linked-hash-map
A fork of linked-hash-map that builds on stable in exchange for not allowing custom hashers
-
griditer
Contains a couple of iterators for implementing 2D grid based algoritms
-
skew-forest
Skew-binary random access lists
-
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… -
advancedresearch-higher_order_point
An experimental higher order data structure for 3D points
-
ro
Helps make stuff read-only
-
mod_utilities
A collection of data structures, traits, and functions for use in mod engine / mod language
-
bip_handshake
Common handshaking interface as well as a default handshake implementation
-
arc-string-interner
An efficient string interning data structure with minimal memory-footprint and fast access to the underlying contents
-
catalog
A file-based map to store key/value pairs in a file and get them using binary search
-
untagged-option
An unsafe Option type without discriminant. Nightly only.
-
ring-vec
A zero-dependency, no-std compatible, producer-consumer, fixed-size, item-oriented ring buffer backed by a vector
-
another-option
Another option data type; useful when allocations are expensive
-
map_vec
The Map and Set APIs backed by Vec
-
compact_path_tree
A data structure providing a compact in-memory representation of a tree of paths
-
htmldom_read
HTML reader that parses the code into easy-use tree
-
json-parser
JSON parser
-
matmath
Matrix and Vector Math with generic type elements
-
pendulum
Hashed timer wheel with various runtimes
-
MBrane
MBrane implementations in Rust
-
pegitan
A bunch of random algorithms library
-
valgrind
Small library of data structures for representing Valgrind suppressions
-
gtfs-geojson
A simple converter for GTFS to GeoJSON formats
-
protocoll
clojure inspired protocols for rust collections
-
mju-bits
no_std typed bitfield access for u8, u16, u32 and u64
-
range-collections
Sets and maps of ranges, backed by smallvec
-
loosen_map
Calls a function with self
-
empty-box
Allows for
Boxs to have their values moved out and replaced with new values, while reusing the same allocation -
rabbithole
JSON:API Data Structure & Query implementation
-
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…
-
arr
A heap based fixed-sized array
-
transit_model_relations
Modeling the relations between objects
-
fux_kdtree
K-dimensional tree implemented in Rust for fast NN querying
-
divsufsort
Rust port of Yuta Mori’s divsufsort
-
sparse-merkle-tree
Sparse merkle tree implement in rust
-
named_tuple
A macro for declaring a
structthat manages a set of fields in atuple -
shifted_vec
A growable datastructure with positive and negative indexing built on top of
std::vec::Veccalculating the offset automatically -
flatten
Tuple flatteing for rust
-
flats
flattens nested structures into a flat single dimension map
-
bytes-expand
Types and traits for working with bytes
-
bitstring
Bitstring traits and implementations
-
bk-tree
A Rust BK-tree implementation
-
version-lp
a version struct library for use with version comparing, and wildcard resolving
-
rust_release_artefact
Safely extract installable files from Rust release artefacts
-
tinybitvec
A tiny vec for tiny bits
-
csv2struct
Generate Rust struct definitions from CSV
-
mango_ir
The Mango programming IR (UNDER CONSTRUCTION)
-
puruda
Pure Rust DataFrame
-
no_vec
A library for modifying sized arrays
-
thermostat
Finite state machine for a thermostat controlling a centralized HVAC system or other heating and/or cooling apparatus
-
doubly
Doubly linked lists in rust
-
digits
Custom “numeric” incrementor without u64 MAX limit in size. Like a score flipper for a custom character set.
-
waitgroup
async waitgroup for a collection of task to finish
-
rabbot
Abstract binding tree generator
-
afi
Audio & video structures, plus encoder & decoder traits
-
ffi-convert-derive
Macros implementations of CReprOf, AsRust, CDrop traits from ffi-convert
-
visit_diff
Efficiently finding differences between data structures
-
rust_fixed_width
library that allows for easier manipulation of fixed width files allowing for the ability to name fields and such using specs
-
tree-cursor
A simple, non-intrusive tree cursor that supports node mutation without Cell/RefCell
-
bitmaptrie
Bitmapped vector trie (mutable, not persistent). Word-size path-cached indexing into essentially a sparse vector. Requires rust-nightly.
-
options
The package provides a data structure for managing named parameters
-
string-err
String error type
-
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 -
dpc-simplemap
Simple map with default value and compacting
-
ware
Immutable middleware chains
-
bigvec
A really big vec
-
entity_table
Data structure for associating data with entities in an Entity Component System
-
graphrepresentations
A crate providing efficient abstract implementations of different graph representations
-
ttmap
Trivial implementation of type map
-
banyan
Persistent indexable tree data structure
-
automerge
Rust implementation of the Automerge replicated JSON datatype
-
byte_array
A library that supports Java-like series processing with byteorder
-
makods
The Jostle Tree, a data structure for working with long sequences of variable-width items
-
aterm
Implementation of the Annotated Terms data structure
-
bitsets
BitSet implementations: Dense, Compressed, Memory-Mapped, and Roaring
-
int_traits
Provides a trait for extended functions on integers
-
closures
Abstraction for seperating code and state in closures
-
kailua_env
Basic environments for Kailua
-
dimsum
Simple multi-dimensional array library
-
roccodev-api
Rust library for RoccoDev’s API
-
glyph-bbox
Data structures for managing glyph bbox datasets and support for calculating string bbox’s
-
pdatastructs
Simple probabilistic data structures
-
map1
@ErichDonGubler’s fancy template for new Rust projects
-
shared_slice
Thread-local and thread-safe shared slice types, like
&[T]but without lifetimes. This library depends only onallocandcore, so can be used in environments withoutstd. -
bipbuffer
A Rust implementation of Simon Cooke’s Bip-Buffer
-
compactmap
Compact Vec-based map that choses assigns IDs for your values on it’s own. Very similar to Slab.
-
id-set
A bitset implementation that stores data on the stack for small sizes
-
mrslac
A Rust crate with sparse matrix data structures
-
foliage
Abstract syntax tree for first-order logic with integer arithmetics
-
querable
Quer(y)able data structure implementation
-
simple-bitrange
A simple crate for manipulating bit ranges which is common when working with IC registers
-
enum_meta
Add metadata to Enum Variants
-
ethercat-types
Common EtherCAT data structures
-
lsp_msg_internal
Definitions used for testing lsp_msg_derive
-
scalable_cuckoo_filter
A variant of Cuckoo Filter whose size automatically scales as necessary
-
prototty_file_storage
Implementation of prototty_storage::Storage backed by files
-
discord-indexmap
A fork of the popular
indexmaplibrary that adds a few extra APIs that are yet to be upstreamed -
break_array
For breaking array indexing
-
enum-map-derive
Macros 1.1 implementation of #[derive(Enum)]
-
vecdeque-stableix
Deque with stable index values
-
atomic-destroy
An value which can be atomically read and destroyed; like an atomic Option
-
try_clone_derive
a crate wich add a derive TryClone macro for the TryClone Trait of the fallible_allocation crate
-
ibuilder_derive
Interactive builder for Rust types
-
di
Dependency injection container
-
frombytes
Defines a cursor over a slice of bytes
-
default-vec
A specialized vector that has a default value
-
bip_select
Bittorrent Infrastructure Project Piece Selection Module
-
loader-rs
Rust interface to load generic objects from an URI
-
pyrpds
Python Wrapper for Rust Persistent Data Structures
-
vec_box
A single macro to create a vec of boxed elements, for trait objects
-
hayami
A simple, general use symbol table
-
evobox
A pointer type which allows for safe transformations of its content without reallocation
-
generic
Higher level serialization of rust values to rust values
-
swc_ecma_dep_graph
Dependency graph for the ecmascript
-
roma
roma is a fast routes map/path router
-
ic-agent
Agent library to communicate with the Internet Computer, following the Public Specification
-
ra_ap_arena
TBD
-
region_buffer
A growable array allowing for multiple mutable non overlapping regions
-
gtrie
Generic trie implementation with a support of different key and value types
-
histogram-sampler
Sampling from a distribution given by a histogram
-
linear-map
A map implemented by searching linearly in a vector
-
few
A generalization of
std::Optionallowing for up to two optional values -
ilog2
Integer logarithm library including some bit operations
-
id-vec
Simplify Graphs in Rust. Introduces IdVec, which automatically creates Ids for each new object, reusing deleted Ids.
-
consume
Memory order consume for when it’s known that the compiler can’t elide the dependency
-
swf-tree
Abstract Syntax Tree (AST) for SWF files
-
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)
-
glitch-in-the-matrix
A set of matrix.org bindings for Rust
-
bit-long-vec
Vector with fixed bit sized values stored in long
-
multi_mut
Methods on HashMap and BTreeMap for safely getting multiple mutable references to the contained values
-
sparse
Sparse library
-
binary-tree
Collection of Binary Tree data structures and algorithms
-
iostream
the project is rust io stream.you can easily use it to manipulate files stream and memory stream
-
thunk
Primitives for generic lazy evaluation in Rust. This crate requires nightly for
untagged_unions. -
alo
ALO means At Least One. It could contain any number of item like
Vecbut it does not heap allocation if it contains only one item -
tranche
Tranches are an alternative to slices
-
itc
Interval Tree Clocks as described in the itc2008 paper
-
any_key
Dynamically typed keys for associative arrays
-
big_enum_set
A library for creating sets of enums with a large number of variants
-
automatic-relations
Tree automatic relations
-
fricgan
A simple crate for performing basic input and output on bytes
-
lazy_concat
Lazy concatenation for Strings and Vecs
-
mat2
matrix 2x2
-
rc-dlist-deque
Doubly-linked list based on std::Rc
-
appendlist
An append-only list that preserves references to its elements
-
incremental-topo
Data structure to maintain an incremental topological ordering over a collection of values
-
compacts
compact data structures
-
leonardo-heap
Heap structure supporting fast in-place partial sorting
-
atlatl
Double-array tries
-
rahashmap
Fork of standard library HashMap with additional functionality
-
dinotree
An aabb space partitioning 2d tree data structure
-
movable
A structure whose internal content can be moved out immutably
-
sp4r53
Sparse merkle tree with on demand flushing
-
bigraph
Different representations with implemented operations on bigraphs
-
vec-option
A space optimized version of
Vec<Option<T>>that stores the discriminant seperately -
hoop
Fixed ring buffer that allows non-consuming iteration both ways
-
easy_strings
Ergonomic, garbage collected strings for Rust
-
baffa
Generic buffer for bytes
-
arenavec
An arena backed implementation of vectors and related types
-
halo
elm inspired state manager in rust
-
htable
A simple to use and extenable table that can hold hold many different types at once
-
street_index
street_index is a small utility crate for working with road name / street indexing for cartographic purposes
-
jyx
Command line tool for manipulating data structures
-
bailamos
Simple notification manager
-
prefix-tree
A map and set interfaces using trie data structure
-
spectacles-model
Discord types and structures for Spectacles.rs
-
fast-rustc-ap-rustc_data_structures
Automatically published version of the package
rustc_data_structuresin the rust-lang/rust repository from commit 15812785344d913d779d9738fe3cca8de56f71d5 The publishing script for this crate lives at: https://github… -
bit-array
A compile time sized array of bits
-
reflection
reflects of type’s fields’ names and their type names in a hierarchical tree
-
bitvec-rs
Bit vector with guaranteed
[u8]representation and the ability to get safe immutable and mutable views into its internal vector for easy I/O -
polymap
A map containing varying types of value
-
gcollections
Generic traits over Rust collections library
-
fral
Functional random-access lists
-
lumberjack-utils
Read and modify constituency trees
-
dot_json
Tools for dot map representations of serde_json Maps
-
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.
-
const-vec
Vec-like data structure with immutable push method
-
array-ops
Automatic method implementations for array data types
-
higher-cat
Functors, Applicatives, Monads and other bad ideas
-
guzzle-derive
The derive macro for guzzle, please use that crate not this one
-
eclectic
Experimental collection traits
-
take-some
A simple library that provides a way to obtain some value from various collections
-
cursed-collections
Collections that (seem) to break Rust safety
-
msiz_rustc-ap-rustc_data_structures
Automatically published version of the package
rustc_data_structuresin the rust-lang/rust repository from commit 74d5c70b174f06843049af2d764ff57ddc81c81c The publishing script for this crate lives at: https://github… -
grid_trait
2D and 3D grids with combinators
-
statiki
Static friendly data structures
-
typescript-definitions-derive-ufo-patch
serde support for exporting Typescript definitions
-
bigint-base10
Experimental API for dealing with big integers in base-ten
-
id-map
Data structure of values indexed by IDs
-
chain-map
A chain of maps with a single view into the aggregated values
-
sorted_vector_map
maps and sets backed by sorted vectors
-
ring_queue
A double-ended queue implemented using a vector that reuses space after elements are removed
-
heatmap
time-series of histograms with precision guarantees
-
ensured_bufreader
A Bufreader ensures N bytes in buffer
-
multiarray
Small Rust library for handling multi-dimensional data
-
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
-
plurals
Helps with singular/plural forms, mostly in English
-
ami
Useful data structures that are not in the standard library
-
hayami-im-rc
A simple, general use symbol table
-
push-trait
Push trait for collectons
-
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…
-
strchunk
A utility library for working with UTF-8 text in I/O
-
r-graph
Modular Graph library for Rust-lang
-
mih-rs
Multi-index hashing (MIH) for neighbor searches on 64-bit codes in the Hamming space
-
dense_mats
A strided dense tensor implementation
-
read-write-pipe
A trait for objects implementing Write, to write all content from a Read object
-
ringbuffer
A fixed-size circular buffer
-
index-fixed
convert slices into arrays using indexes ([T] -> [T;N])
-
ordered_iter
Ordered iterators
-
medianheap
A median heap for keeping track of a running median
-
immutable-seq
Immutable sequence data structure
-
map-trait
Generic Map trait
-
vec3
vec3
-
phf
Runtime support for perfect hash function data structures
-
uint
Large fixed-size integer arithmetic
-
semver-store
An HashMap structure that uses semver strings as keys
-
hashed
A Hashed type you can convert any hashable type into and still do equality checks on
-
static_merkel_tree
Static Merkel Tree is dedicated for generating Merkle Root and Merkle Proof for a static list of items
-
handlebox
A map-like collection that reuses unused keys
-
fixed-map-derive
A fixed map where storage layout is calculated by a procedural macro. This crate contains the procedural macros
-
thincollections
Alternative implementations for vector, map and set that are faster/smaller for some use cases
-
arrav
Sentinel-based heapless vector
-
tree
An ordered map and set based on a binary search tree
-
fix
Fixed-point number types
-
trie-standardmap
Standard test map for profiling tries
-
soak-derive
Custom derive macro for #[derive(Columns)]
-
tinystr-macros
Proc macros for TinyStr
-
modular-bitfield-impl
Bitfields for structs that allow for modular use of enums
-
graph_match
A library for matching patterns in directed graphs
-
snake_case
SnakeCase is a String-like type that can only contain valid non-empty snake_case
-
rs-collections
generic collections (no dependency on std)
-
bitops
Miscellaneous bit operations for any Integer
-
collections-more
Common data structure and algorithms for rust-lang to complete the already excellent std::collections
-
huji
Simple graph package still under production
-
ctrs
Rust implementations and notes on category theory
-
holyhashmap
A hash map with stable indices
-
const-arrayvec
A vec-like type backed by an array on the stack
-
dashmap-shard
A Rust port of Google’s SwissTable hash map
-
bit_range
A small library for getting bits and ranges of bits from byte collections
-
thin-vec
a vec that takes up less space on the stack
-
mwmatching
Maximum-Weight Matching: Compute a maximum-weighted matching in the general undirected weighted graph given by ‘edges’
-
mori_parallel
A parallel orientation library built around commonly used orientation representations used in crystallography and engineering applications. It contains conversion, rotation, and data…
-
skew-heap
A priority queue based on a skew heap
-
hex2d-dpcext
dpc’s hacky extensions to hex2d-rs library
-
rbtset
A set based on a RB-Tree for efficient operations
-
suffix-array-rust
A simple library that can be used to perform suffix array operations
-
sized-vec
Type level sized vectors
-
takeable
Container type that allows for temporarily moving out of the container
-
basic_tree
basic tree for rust, for now including only trie
-
slice_as_array
Cast slices to arrays
-
discrimination-tree
discrimination tree term indexing
-
ring_buffer
RingBuffer is a mix of a vector and a queue
-
rudy
Judy array implementation in pure Rust
-
byteorder_slice
Byteorder like crate for &[u8]
-
suffix_tree
Suffix trees
-
baggie
Container for storing mixed / heterogeneous values in a common structure
-
derive_di_core
This crate give traits for the parent crate derive_di
-
slice_mip
Mutate a slice in place with a map function
-
byte_trie
A compressed trie based on bytes with some weird child node bucket sizes
-
ic-utils
Collection of utilities for Rust, on top of ic-agent, to communicate with the Internet Computer, following the Public Specification
-
rotated-array-set
An ordered set supporting O(1) rank and O(√n) inserts and deletes
-
immutable_arena
An arena for immutable-once-built objects with possibly cyclic references
-
comparator
A Java-like Comparator type
-
maybe_utf8
Byte container optionally encoded as UTF-8
-
yarns
Simple lib for working with strings
-
core_collections
This is a copy of libstd::collections with all the parts that don’t work in core removed. Most importantly, it provides HashMap and HashSet. This crate is (mostly) automatically generated from the rust git source…
-
gt-graph-path
discribe a path on a graph
-
prototty_storage
Interface to persistent storage
-
easy_graph
Data structure that represent generic vertices and undirected connections
-
lazy-array
An array where entries are lazily initialized in any order
-
hamster_wheel
Looping code generator that allows for generating code over a collection
-
transit_model_collection
Manage collection of objects
-
index_key
lexicographic sort order encoding
-
bitset-fixed
Bitset for DP
-
gvec
Very simple implementation of generational indexing for vectors written in Rust
-
flashtext
Rust implementation of flashtext algorithm to search and replace keywords in given text
-
quantized-density-fields
Rust implementation of Quantized Density Fields data structure