-
bytes
Types and traits for working with bytes
-
smallvec
‘Small vector’ optimization: store up to a small number of items on the stack
-
num
A collection of numeric types and traits for Rust, including bigint, complex, rational, range iterators, generic integers, and more!
-
arc-swap
Atomically swappable Arc
-
hashbrown
A Rust port of Google’s SwissTable hash map
-
predicates
An implementation of boolean-valued predicate functions
-
arrayvec
A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.
-
hdrhistogram
A port of HdrHistogram to Rust
-
bitvec
A crate for manipulating memory, bit by bit
-
priority-queue
A Priority Queue implemented as a heap with a function to efficiently change the priority of an item
-
scroll
A suite of powerful, extensible, generic, endian-aware Read/Write traits for byte buffers
-
generic-array
Generic types implementing functionality of arrays
-
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…
-
ndarray
An n-dimensional array for general elements and for numerics. Lightweight array views and slicing; views support chunking and splitting.
-
heapless
staticfriendly data structures that don’t require dynamic memory allocation -
generator
Stackfull Generator Library in Rust
-
staticvec
Implements a fixed-capacity stack-allocated Vec alternative backed by an array, using const generics
-
crdts
Practical serializable thoroughly tested CRDTs (ORSWOT, counters, LWW) ported from riak_dt
-
guppy
Track and query Cargo dependency graphs
-
rpds
Persistent data structures with structural sharing
-
tinystr
A small ASCII-only bounded length string representation
-
bimap
Bijective maps
-
radix_trie
Generic radix trie data-structure
-
array-init
Safe wrapper for initializing fixed-size arrays
-
enum-ordinalize
This crates provides a procedural macro to let enums not only get its variants’ ordinal but also be constructed from an ordinal
-
rusty_ulid
Rust ULID (Universally Unique Lexicographically Sortable Identifier) generation and processing
-
hdf5
Thread-safe Rust bindings for the HDF5 library
-
sized-chunks
Efficient sized chunk datatypes
-
rust_decimal_macros
Shorthand macros to assist creating Decimal types
-
vec_map
A simple map based on a vector for small integer keys
-
enumset
A library for creating compact sets of enums
-
im
Immutable collection datatypes
-
fraction
Lossless fractions and decimals; drop-in float replacement
-
vec1
a std Vec wrapper assuring that it has at least 1 element
-
fixedbitset
FixedBitSet is a simple bitset collection
-
roaring
http://roaringbitmap.org : A better compressed bitset - pure Rust implementation
-
prometheus
Prometheus instrumentation library for Rust applications
-
weak-table
Weak hash maps and sets
-
bit-vec
A vector of bits
-
tinyvec
tinyvecprovides 100% safe vec-like data structures -
starling
This tree structure is a binary merkle tree with branch compression via split indexes
-
qp-trie
An idiomatic and fast QP-trie implementation in pure Rust, written with an emphasis on safety
-
modular-bitfield
Allows to easily define bitfield types with modular building blocks
-
enum-map
A map with C-like enum keys represented internally as an array
-
merkle-cbt
A library for generating efficient Merkle tree and combined Merkle proof based on complete binary tree
-
binary-heap-plus
Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps
-
string-interner
Efficient string interner with minimal memory footprint and fast access to the underlying strings
-
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
-
rstar
R*-tree library for the rust ecosystem
-
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…
-
blender-armature
Serialize / deserialize Blender armatures
-
cidr-utils
This crate provides data structures and functions to deal with IPv4 CIDRs and IPv6 CIDRs
-
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.
-
slice-deque
A double-ended queue that Deref’s into a slice
-
trees
General purpose tree data structures
-
slice-dst
Slice-based custom DSTs
-
leb128
Read and write DWARF’s “Little Endian Base 128” (LEB128) variable length integer encoding
-
bv
Bit-vectors and bit-slices
-
indextree
Arena based tree structure by using indices instead of reference counted pointers
-
spade
Spatial datastructures like r-trees and delaunay triangulations for rust
-
flatk
Flat layout abstraction toolkit
-
patricia_tree
Memory-efficient data structures based on patricia tree
-
colorous
Professional color schemes ported from d3-scale-chromatic
-
bloomfilter
Bloom filter implementation
-
molecule
Rust bindings for molecule
-
concread
Concurrently Readable Data-Structures for Rust
-
wide
A crate to help you go wide
-
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
-
bitstream-io
Library for reading/writing un-aligned values from/to streams in big-endian and little-endian formats
-
ndarray-stats
Statistical routines for ArrayBase, the n-dimensional array data structure provided by ndarray
-
kstring
Key String: optimized for map keys
-
convenient-skiplist
Convenient and Performant SkipList with serde support
-
typed-index-collections
Typed index version of Rust slice and Vec containers
-
typescript-definitions-ufo-patch
serde support for exporting Typescript definitions
-
sorted-iter
Typesafe extensions for sorted iterators, including set and relational operations
-
array-macro
Array multiple elements constructor syntax
-
rc-u8-reader
A tiny implement for reading
u8data from a reference counted instance -
defaultmap
Provides a HashMap with an automatic default for missing keys
-
ucd-trie
A trie for storing Unicode codepoint sets and maps
-
index_vec
Newtype-style helpers for
Vecandusize -
predicates-tree
Render boolean-valued predicate functions results as a tree
-
griddle
A HashMap variant that spreads resize load across inserts
-
trie-root
In-memory patricia trie operations
-
trk-io
TrackVis (*.trk) reader and writer
-
zbus_macros
proc-macros for zbus
-
id_tree
A library for creating and modifying Tree structures
-
rle_vec
A vector like struct that stores data as runs of identical values. Useful for storing sparse data.
-
fid
FID (Fully Indexable Dictionary) implementation for Rust
-
smallbitvec
A bit vector optimized for size and inline storage
-
uluru
A simple, fast, LRU cache implementation
-
string
A UTF-8 encoded string with configurable byte storage
-
undo
Low-level undo-redo functionality
-
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
-
threshold
Threshold data structures
-
ordered-multimap
Insertion ordered multimap
-
vob
Vector of Bits with Vec-like API and usize backing storage
-
kserd
Kurt’s Self-Explanatory Rust Data
-
smartstring
Compact inlined strings
-
rtdlib
TDLib for rust
-
hash_hasher
A hasher which is designed to work with already-hashed or hash-like data
-
intervaltree
A simple and generic implementation of an immutable interval tree
-
building_blocks_storage
Efficient storage for maps on sparse or dense, 2D and 3D integer lattices
-
plain
A small Rust library that allows users to reinterpret data of certain types safely
-
solvent
Dependency Resolver library
-
hibitset
Hierarchical bit set structure
-
min-max-heap
An efficient, double-ended priority queue
-
openapiv3
This crate aims to provide data structures that represent the Open API v3 specification easily deserializable with serde
-
ena
Union-find, congruence closure, and other unification code. Based on code from rustc.
-
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…
-
keyvi
Keyvi - the key value index. It is an in-memory FST-based data structure highly optimized for size and lookup performance.
-
intrusive-collections
Intrusive collections for Rust (linked list and red-black tree)
-
json_dotpath
Dotted path access to nested JSON objects (serde_json::Value)
-
cactus
Immutable parent pointer tree
-
hash_ring
Consistent Hashing library for Rust
-
suff_collections
Fast realization of suffix array and suffix tree
-
bitlab
Extracting a range of bits from a binary data source
-
optional
This crate supplies a number of Option-like primitive types
-
feattle
Featture toggles for Rust, extensible and with background synchronization and administration UI
-
ringbuffer
A fixed-size circular buffer
-
rb_tree
A Red Black Tree implementation in Rust
-
bitvector
BitVector implementation in Rust
-
lignin
A virtual DOM structure, primarily for web use
-
generational-indextree
Arena based tree structure by using indices instead of reference counted pointers
-
persist-o-vec
A Vec type that aims to have stable indices and memory location
-
rust-fsm
A framework for building finite state machines in Rust
-
egg
An implementation of egraphs
-
ibuilder
Interactive builder for Rust types
-
flatgeobuf
FlatGeobuf for Rust
-
histogram
histogram storage and percentile metrics with precision guarentees
-
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…
-
ndsparse
Sparse structures for N-dimensions
-
stackvector
StackVec: vector-like facade for stack-allocated arrays
-
vec-collections
Rust collections that are newtype wrappers around smallvec
-
enso-data
A collection of useful data structures
-
typescript-definitions
serde support for exporting Typescript definitions
-
slab_tree
A vec-backed tree structure with tree-specific generational indexes
-
flat-tree
Rust module for encoding/decoding varints that doesn’t do any IO. Inspired by the Node.js varint module
-
panoradix
A generic map and a set, both backed by a Radix tree
-
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…
-
treez
A collection of useful data structures
-
retworkx
A python graph library implemented in Rust
-
lfchring
Concurrent, lock-free implementation of a consistent hashing ring data structure, supporting virtual nodes and keeping track of replication
-
rsdict
Fast static rank and select data structure
-
velcro
Convenience macros for initializing vectors, hash maps and other Rust collections
-
microkelvin
A library for tree traversal over annotated datastructures
-
llvm-ir
LLVM IR in natural Rust data structures
-
kelvin
Merkle tree tooklit and backend
-
circular-queue
A circular buffer-like queue
-
c_vec
Structures to wrap C arrays
-
toodee
A lightweight 2D wrapper around a Vec
-
rexsgdata
Scatter-Gather Data Descriptors
-
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. -
tcgeneric
Generic data types used internally by Tinychain. Unstable.
-
unstructured
Generic types for unstructured data
-
cc-traits
Common collection traits
-
subset-map
A map where the keys are subsets of an initial set of elements
-
anymap
A safe and convenient store for one value of each type
-
cervine
A slightly more flexible Cow; roughly to T: Borrow as alloc::borrow::Cow is to B: ToOwned
-
ternary-tree
A Rust implementation of Ternary Search Trees, with no unsafe blocks
-
queues
Efficient FIFO Queue data structures
-
nanoset-py
A memory-optimized wrapper for Python sets likely to be empty
-
exponential-decay-histogram
A histogram which exponentially weights in favor of recent values
-
biodivine-lib-bdd
A simple thread-safe implementation of basic binary decision diagrams
-
sum
General-purpose sum types
-
bit_mask_ring_buf
A fast ring buffer implementation with cheap and safe indexing
-
linestring
2d and 3d polylines
-
verify
A validation library
-
petgraph
Graph data structure library. Provides graph types and graph algorithms.
-
misc_utils
A small collection of convenient and utility functions developed for personal use
-
macaddr
MAC address types
-
timely_communication
Communication layer for timely dataflow
-
large_int
An ease-of-use unbounded signed integer
-
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…
-
flexpolyline
Flexible Polyline encoding: a lossy compressed representation of a list of coordinate pairs or triples
-
helgoboss-midi
Interfaces, data structures and utilities for dealing with MIDI messages according to the MIDI 1.0 specification
-
banyan
Persistent indexable tree data structure
-
keyed_priority_queue
Priority queue that support changing priority or early remove by key
-
designal
Procedural macro for use with futures-signals
-
gapbuf
Generic gap buffer
-
uid
A crate for the creation of unique IDs
-
cow_vec_item
Copy-on-write Vec, available on stable rust
-
pair_macro
Create types consisting of the same type values such that Pair, Triplet, and so on
-
graphity
Model signal flow between nodes within a directed graph
-
fwdlist
A simply linked (forward) list
-
petal-clustering
A collection of clustering algorithms
-
typed_index_collection
Manage collection of objects
-
guppy-summaries
Build summaries for Cargo, created by guppy
-
usher
Parameterized routing for generic resources in Rust
-
nested_containment_list
A data structure for efficiently storing and querying nested intervals
-
fingertrees
Immutable persisten finger trees
-
base_custom
Use any characters as your own numeric base and convert to and from decimal
-
space
A library providing abstractions for spatial datastructures and search
-
genmap
A simple generational map data structure with no dependencies
-
ra_ap_la-arena
Simple index-based arena without deletion
-
floating_bar
Representing rational numbers using the floating-bar number 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.
-
identifier
Generate 128 bits id structs easily
-
tobz1000-petgraph
Pseudo-namespaced fork of
petgraph: Graph data structure library. Provides graph types and graph algorithms. -
ulid-generator-rs
A Rust crate for generating ULIDs
-
siraph
A node-based digital signal processing crate
-
sgf-parse
A parser for the SGF file format for Go games
-
buffer-trigger
A data collection trigger based on the maximum number and refresh time
-
nopetgraph
Graph data structure library. Provides graph types and graph algorithms.
-
watermark
A simple watermarking set for in-order insertions
-
beach_map
Implementation of a slotmap
-
graphlib
Graphlib is a simple and powerful rust library for the graph data-structure
-
ware
Immutable middleware chains
-
field-ref
Field reference (like a member pointer to non-static data field in C++) for Rust
-
comp_input
Input library for competitive programming
-
intrusive_splay_tree
An intrusive splay tree implementation that is no-std compatible and free from allocation and moves
-
tri-mesh
A triangle mesh data structure including basic operations
-
rust_decimal_macro_impls
Shorthand macros to assist creating Decimal types. Do not depend on this directly; use rust_decimal_macros
-
kvdb
Generic key-value trait
-
btree-slab
A memory compact Slab-based B-tree implementation
-
option_set
Bitflags on steroids
-
merkle
Merkle tree implementation with support for generation of inclusion proofs
-
tst
Ternary search trie collection in rust with similar API to std::collections as it possible
-
gridly
A library for managing fixed-size 2D spaces
-
rc-borrow
Borrowed forms of Rc and Arc
-
rudac
A crate for common data structures and algorithms
-
atone
A VecDeque and Vec variant that spreads resize load across pushes
-
kd-tree
k-dimensional tree
-
rc-writer
A tiny implement for writing data to a reference counted instance
-
cast-rs
A collection of types cast for Rust
-
minivec
A version of Vec that’s only the size of a single pointer
-
tokio-cadence
Tokio-based metric sinks for Cadence
-
osproto
Protocol structures for OpenStack API (Obsolete)
-
sequencetree
a new type of collection to store keys and their corresponding values
-
va_list
Provides a rust implementation of the ‘va_list’ type for a small set of ABIs. Allowing rust implementations of functions like vprintf.
-
bounded-spsc-queue
A bounded SPSC queue
-
exonum-merkledb
Persistent storage implementation based on RocksDB which provides APIs to work with Merkelized data structures
-
rs-snowflake
Rust version of the Twitter snowflake algorithm
-
lz_diet
An AVL balanced Discrete Interval Encoding Tree
-
shortlist
An efficient data structure to track the largest items pushed to it
-
bitmaps
Fixed size boolean arrays
-
velcro_core
Core dependencies used by the
velcrocrate. Seevelcrofor documentation. It is not advised to depend on this crate directly; it is an internal dependency ofvelcroand may be subject to breaking changes. -
graph_solver
An undirected graph constraint solver for node and edge colors
-
redo
Provides advanced undo-redo functionality with static dispatch
-
dynvec
This crate provides the
DynVectype that acts like a vector to store any datatype -
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
-
fixed-macro
Macros for creating fixed-point constants for types in the
fixedcrate -
charcoal
Implements tree data structures and interfaces to work with them
-
im-rc
Immutable collection datatypes (the fast but not thread safe version)
-
do-notation
Monadic do syntactic sugar
-
outils
Graph and tree data structure library. Providing utilities which aren’t easily available in Rust.
-
vast
Verilog AST library
-
one_way_slot_map
An implementation of SlotMap with minimal restrictions on Keys and Values
-
cedarwood
efficiently-updatable double-array trie in Rust (ported from cedar)
-
xml-schema
Structure generator from XSD source file
-
rustc-ap-rustc_data_structures
Automatically published version of the package
rustc_data_structuresin the rust-lang/rust repository from commit a4e595db8f12f9ee926256745d757004b850703f The publishing script for this crate lives at: https://github… -
rusty-perm
Rusty permutation with no-std
-
dlv-list
Semi-doubly linked list implemented using a vector
-
tc-value
Tinychain’s representation of a value which can be collated and stored. Unstable.
-
granite
Generic backing storage framework for building data structures
-
delay
A collection of trait and classes to make your thread wait (and timeout)
-
simple_endian
A create for defining endianness within your data structures, to make handling portable data structures simpler
-
yyid
Yyid generator (random tokens like UUIDv4, but using all the bits)
-
resiter
Helper crate for handling iterators over result
-
numeric-array
Wrapper around generic-array that adds efficient numeric trait implementations
-
xtree
A simple general purpose tree data structure
-
vec-dimension-shift
N-Dimension shift features for Vec
-
plum
Probabilistic data structures for rust
-
disjoint-sets
Three union-find implementations
-
coca
Data structures with constant capacity
-
fixed-vec-deque
A fixed-size, zero-allocation circular buffer for Rust
-
splay_tree
Splay Tree based Data Structures (map, set, heap)
-
index-map
A map with automatically generated usizes as keys
-
simple_bitfield
Create bitfields with the same memory structure as integers using a simple macro
-
serde_single_or_vec
Type which can be deserialized from either a sequence or a single value
-
word_filter
A robust implementation of a Word Filter
-
multiref
Multireferences: a safe way to do [&T] -> &[T]
-
slist
Algebraic lists with statically determined size that live on stack
-
ldpc
A toolbox for classical (and soon quantum) LDPC codes
-
sea-canal
Identifies patterns in sequences of integers
-
strchunk
Data types for working with UTF-8 text in I/O
-
treers
Simple implementation of Sedgewick’s tree maps
-
onigiri
This crate is a tool of handling chars
-
idlset
Fast u64 set operations library
-
scapegoat
Ordered set and map data structures via an arena-based scapegoat tree
-
aliasable
Basic aliasable (non unique pointer) types
-
mset
A mset / multiset / bag implementation
-
wccg-models
WCCG Data
-
patricia_router
Radix Tree implementation for Rust
-
binn-ir
An implementation of Binn - https://github.com/liteserver/binn
-
fm-index
FM index and its variant implementations for Rust
-
ux_serde
Implement the following non standard integers: u2, u3, u4, u5, u6, u7, u9, u10, u11, u12, u13, u14, u15, u17, u18, u19, u20, u21, u22, u23, u24, u25, u26, u27, u28, u29, u30, u31, u33…
-
btree_graph
A generic graph data structure
-
grdf
Generalized RDF graphs and datasets
-
bloom
Fast Bloom Filter and Counting Bloom Filter implementation
-
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. -
allwords
Generate all the words over a given alphabet
-
bailamos
Simple notification manager
-
simple-grid
A simple 2d-grid structure
-
deltastruct
Allows defining deltas for tagged structs for later application
-
erasable
Type-erased thin pointers
-
succinct_rs
Succinct Data Structures library for Rust
-
vector-map
VecMap<K, V>: a Linear Search with Map API
-
libflow
library grouping network flow data
-
bucket_queue
A Bucket Queue data structure that can be used as a Priority Queue
-
validbr
Provides data structure and validation for Brazilian Registries, such as CPF, CNPJ and CNH (currently only CPF and CNPJ is supported)
-
type-map
Provides a typemap container with FxHashMap
-
tsil_cev
LinkedList on Vec
-
osm-xml
OSM xml parser for Rust
-
index-ext
Index slices with arbitrary ints and as arrays
-
resources
Safe store for one value of each type, with interior mutability
-
either
The enum
Eitherwith variantsLeftandRightis a general purpose sum type with two cases -
todo_lib
Collection of utilities for todo.txt format
-
gstore
Global state management for GTK applications
-
quickscope
Multi-layer HashMap and HashSet implementations for performant representation of variable scopes
-
dary_heap
A d-ary heap
-
safe_index
Type-safe indexes
-
csv2json
Converts CSVs into JSON documents
-
streamson-generator
A library which integrates streamson with generators
-
isolanguage-1
ISO 639-1 library with optional Serde support
-
entity
Library that provides entity-like constructs
-
big_enum_set
A library for creating sets of enums with a large number of variants
-
sequence_trie
Trie-like data-structure for storing sequences of values
-
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 -
k2_tree
A space-efficient representation of sparsely populated bit-matrices
-
alloc-wg
Attempt of collection several proposals of the allocators-wg
-
simple-matrix
A simple generic matrix library
-
utote
Stack allocated uint multiset, with optional SIMD implementations
-
tinystr-raw
Raw string-to-integer conversions for tinystr
-
fixed-map
A fixed map where storage layout is calculated by a procedural macro
-
modular-bitfield-impl
Bitfields for structs that allow for modular use of enums
-
theban_interval_tree
A simple Interval Tree implementation
-
cargo-extras
A collection of cargo subcommands
-
sparsevec
Compress vectors using row displacement
-
slabmap
HashMap-like collection that automatically determines the key
-
slack-blocks
Models + clientside validation for Slack’s JSON Block Kit
-
mediumvec
Vector types optimized for space, including a 32-bit Vec
-
rio_api
Common data structures for RDF formats parsers and serializers
-
statemachine-rs
A statemachine crate which have zero dependencies
-
static_type_map
A type map that works over all types implementing
Any -
tiny_ecs
A tiny ECS that tries to avoid unnecessary copy/clones
-
noise_rs
The perlin and simplex noise implementation in 2d and 3d
-
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 -
hypergraph
Hypergraph is data structure library to create a directed hypergraph in which an hyperedge can join any number of vertices
-
stadium
A allocated chunk of memory populated with a fixed set of types
-
handy
A library providing handles and handlemaps
-
differential-dataflow
An incremental data-parallel dataflow platform
-
av-data
Multimedia data structures
-
galemu
Provides a workaround for generic associated types (GAT) limited to lifetimes (GAL)
-
bloom_filter_simple
A simple and generic bloom filter implementation
-
uuid-rs
A Simple Universally Unique IDentifier (UUID)
-
moniker
Automatically derive variable binding and alpha equivalence for abstract syntax trees
-
nested_intervals
nested & overlapping interval set functions, overlap, union, etc
-
orderbook
Orderbook for Rust
-
cmp_wrap
Let you compare structes by context
-
libreda-db
Layout and netlist datastructures for chip design
-
smallbigint
Big integer types that have a small on-stack representation for small values. Uses num-bigint internally.
-
code_location
A library to automatically acquire a code location in a rust source code file
-
boolvec
A vector of boolean stored contiguously in memory
-
passive
A trio of marker traits to classify passive data structures
-
jirachi
A collision resistant runtime agnostic key-generator
-
keylist
Elixir keyword list in Rust
-
wavelet-matrix
A wavelet matrix implementation. Supports various near-O(1) queries on large number of symbols or integers.
-
mergle
A data structure with fast merging and comparison
-
polytype
A Hindley-Milner polymorphic typing system
-
swaybar-types
A library for building swaybar status commands in rust
-
intervallum
Generic interval and interval set library
-
bigraph
Different representations with implemented operations on bigraphs
-
smallstr
String-like container based on smallvec
-
multiset
Multisets/bags
-
swimmer
Thread-safe object pool type
-
dusk-kelvin-map
BST Map implementation with Microkelvin backend
-
toboggan-kv
Toboggan-kv is an abstraction layer over multiple KV stores
-
langtag
Language tags implementation following RFC 5646
-
bitrush-index
A serializable bitmap index library able to index millions values/sec on a single thread
-
email-format
Email message format (parser and data structure)
-
ordsearch
A data structure for efficient lower-bound lookups
-
bip_utracker
Communication with bittorrent UDP trackers
-
chainmap
A ChainMap with mutability of intermediate maps
-
skiplist
Skiplist implementation in rust, providing fast insertion and removal. A normal skiplist is implemented, as well as an ordered skiplist and a skipmap.
-
simd_aligned
Safe and fast SIMD-aligned data structures with easy and transparent ‘flat’ access
-
manhattan-tree
A spatial tree which can effiently find closest key to a point, by manhattan distance
-
nibble_vec
Vector data-structure for half-byte values
-
exprz
An Expression Library
-
bucket_vec
A vector-like data structure that guarantees to never move its contained elements
-
vec-tree
A safe tree using an arena allocator that allows deletion without suffering from the ABA problem by using generational indices
-
libnv
Safe and rustic wrapper around libnv-sys
-
midas_cli
Rust port of MIDAS (Microcluster-Based Detector of Anomalies in Edge Streams)
-
slice-of-array
Extension traits for casting between slices and slices of arrays. (&[T] <-> &[[T; n]])
-
bex
A rust library for working with boolean expressions (syntax trees, decision diagrams, algebraic normal form, etc.)
-
probabilistic-collections
Various implementations of collections that use approximations to improve on running time or memory, but introduce a certain amount of error
-
multipath
A library to split file path, like
/home/{user,admin}/file.txt -
dynamization
Fast insertion for static containers
-
packed-integers
A growable array for integer types in the range
u1tou31 -
hash-rings
Implementations of various hash rings
-
nstack
Arity 4 stack for the kelvin merkle toolkit
-
dst
Data structures for DSTs
-
bigs
A bipartite graph sampler
-
win-variant
This is a rust crate that aims to provide a more ergonomic way of working with variants in winapi based projects
-
liblet
Library for learning about formal languages and grammars
-
graphific
Graphific is a graph data structure library
-
debruijn
Tools for DNA sequences: efficient k-mer manipulation, De Bruijn graph construction and compaction and handling of DNA strings
-
block-grid
A quick, cache-conscious, tiled 2D array
-
growable-bitmap
A growable (and shrinkable) compact boolean array
-
ic-types
Types related to the Internet Computer Public Specification
-
iowrap
Small helpers for using io::Read/io::Write
-
raphy
A graph data structure library
-
lending-library
A key-value store that loans full ownership of items
-
rustz
A library for functional programming in Rust
-
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
-
smallbitset
This crate provides a series of allocation free sets capable of holding small integer values
-
spool
Simple object pool for upfront allocation!
-
syntastic
Generic abstract syntax representation
-
derive_wrapper
Rust custom derive macro for wrapping types
-
truetree
Trees in Rust
-
anti-r
A spatial data structure outperforming r-trees for low numbers of elements
-
guzzle
A derivable trait for consuming key value pairs into structs
-
sbf
Spatial Bloom Filter, a probabilistic data structure that maps elements of a space to indexed disjoint subsets of that space
-
string-wrapper
A possibly-stack-allocated string with generic bytes storage
-
pour
Optionally consed radix tries for fast set operations
-
gen-vec
Vector indexed with generational indices
-
elaru
Memory safe implementation of LRU cache
-
zc-derive
Derive macro for zc crate
-
leak
Safely leak data from owned data structures
-
hashable_rc
Hashable wrappers for reference countings
-
elsa
Append-only collections for Rust where borrows to entries can outlive insertions
-
inspector
General purpose inspection for popular data structures
-
succinct
Succinct data structures for Rust
-
bonzai
An abstraction for optimizing the memory layout and pointer aliasing of trees
-
text-style
Types and conversions for styled text
-
isomorphism
2 directional hashmaps
-
blender-mesh
Serialize / deserialize Blender armatures
-
rbtset
A set based on a RB-Tree for efficient operations
-
offset
Glorified offsets for arbitrary structures
-
linux-stats
typesafe procfs info
-
path-value
Universal type and access property(s) by path
-
hashcons
Hash cons’ing for compact representations of shared, immutable data structures
-
backtracking_iterator
A simple implementation of a generic iterator with an item history, capable of backtracking and forgetting
-
smart-hash
partial queries in HashSets, the traits
-
mucell
A cell with the ability to mutate the value through an immutable reference when safe
-
push-while-ref
push while having a reference
-
easy_collections
Wrappers around standard collections for ease of use and quick prototyping
-
matrix-sdk-common
Collection of common types and imports used in the matrix-sdk
-
grafana-dashboard
grafana import/export data serializable structures
-
nested
A memory efficient container for nested collections (like
Vec<String>orVec<Vec<T>>) -
maybe-cell
An UnsafeCell optionally containing a value, with the state externally managed
-
hirpdag
Library and procedural macros for Hash Consed, Immutable, Reference Counted, Persistent, Directed Acyclic Graph data structures
-
stride
A strided slice type
-
python-packed-resources
Manage data structures containing Python resources
-
aci_ppm
Encode and decode PNM image files (TODO: so far only PPM)
-
imag-id-in-collection
Part of the imag core distribution: imag-ids command
-
alphabet-macro
Provides a macro that can be used to easily create const alphabets
-
data_reader
A data loading library for data scientist
-
checked
Implements a wrapper over the primitive Rust types that better indicates overflow during arithmetic
-
soa-vec
A simple Vec-like API over a struct of arrays layout
-
trie
An ordered map and set based on a trie
-
fuzzy_trie
Key-value collection to make fuzzy searches
-
static_merkle_tree
Static Merkle Tree is dedicated for generating Merkle Root and Merkle Proof for a static list of items
-
indexed
Convenient allocator for index-linked data structures
-
cpt
A filesystem tool that will copy a folder structure and if there is provided templating data when it encounders any
.tplfiles, it tries to fill it using Handlebar syntax and prints out the transformed version -
fast_paths
Fast shortest path calculations on directed graphs made possible by pre-processing the graph using Contraction Hierarchies
-
grammers-tl-types
Rust definitions for Telegram’s API types and functions
-
om2
A set of classes generated from the OM2 RDF schema (mainly Unit)
-
stable_bst
An ordered map and set based on a binary search tree. Works with stable Rust 1.9.0.
-
minecraft_end_generation
The minecraft end generation implemented in rust
-
hat_trie
A hat-trie implementation that support prefix match iteration
-
packedvec
Store vectors of integers efficiently
-
pl-lens
Provides support for lenses, which are a mechanism in functional programming for focusing on a part of a complex data structure
-
radix-heap
Fast monotone priority queues
-
bip_metainfo
Parsing and building of bittorrent metainfo files
-
graphrepresentations
A crate providing efficient abstract implementations of different graph representations
-
data_structure_traits
data structure collection traits
-
bk-tree
A Rust BK-tree implementation
-
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.
-
version-rs
A struct for Versions, with the methods you expect
-
nave
Thinking about the construction of distributed systems starting from the consistent hash algorithm
-
free-ranges
An efficient data structure for keeping track of indices which are either free or not
-
tui-tree-widget
Tree Widget for tui-rs
-
hedge
An index based half-edge mesh implementation
-
partial_const
This library provides a way to handle constant and non-constant values in a unified way
-
arq
Arq library to manage Arq Backup data formats
-
bitmaptrie
Bitmapped vector trie (mutable, not persistent). Word-size path-cached indexing into essentially a sparse vector. Requires rust-nightly.
-
simple-rate-limit
Rate limit enforcement as simple data structures, no atomics
-
graphstack
Graph-structured stack
-
ensure
Ensure target state of an object
-
slots
Fixed size data structure with constant-time operations
-
gsrs
Generic Self Referencing Struct
-
uvector
access two slices as a single continuous vector
-
froop
A functional reactive stream library for rust
-
permutate
Generic permutator that permutates singular and multiple lists
-
vk_api
The Vulkan API XML exposed as a byte string constant
-
elementtree
Parse an XML file into Python elementtree like structure
-
collectable
Fallible, no_std-friendly collection traits
-
tilecoding
Rust implementation of Dr. Richard S. Sutton’s tile coding software.
-
more_ranges
Range types not provided in the standard library
-
mop-structs
Low-level structures for MOP
-
vf-rs
A set of classes generated from the ValueFlows RDF schema
-
noindexmap
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…
-
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…
-
roadmap
model a project roadmap as a directed acyclic graph
-
ika
rusty object pool
-
Project2
Implementations of red black tree and AVL tree
-
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.
-
transaction-pool
Generic transaction pool
-
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.
-
incr
Simple, fast and self-contained data structures for checking whether a new value is greater than the previous maximum
-
ux-primitives
Data Primitives to handle and visualize DataFrames
-
iterable
An iterable library for Rust collection like types
-
pod
Plain Old Data (POD) encoding and I/O
-
segment-tree
Quickly perform interval queries or modifications
-
feattle-core
Featture toggles for Rust, extensible and with background synchronization and administration UI
-
hash-chain
A tiered hashmap and hashset implementation that allows for easily representing lexically scoped variables
-
ahtable
Array Hash Table implementation
-
replicante_logging
Replicante common logging logic
-
btree_network
A generic network (undirected graph) data structure
-
set-trie
A trie for fast subset and superset queries
-
partial
Optional monad with fake variant
-
lumberjack
Read and modify constituency trees
-
queue-file
queue-file is a lightning-fast, transactional, file-based FIFO
-
atomic-take
Atomically take a value out of a container once
-
freezebox
FreezeBox: a deref’able lazy-initialized container
-
actions
Software without side-effects. Redo and Undo. Macro’s.
-
ub
Can bundle multiple sources to a single one and extract back
-
varuint
Variable length signed and unsigned integer types
-
puruda-macro
proc macro for puruda
-
flit
Bloom filter backed by xxHash
-
slice_ring_buf
A fast ring buffer implementation optimized for working with slices
-
nullvec
Rust nullable vector, which can contain null(missing) values as element
-
geomprim2d
2D geometric primitive types
-
ethercat-types
Common EtherCAT data structures
-
sparse-bin-mat
A sparse implementation of a binary matrix optimized for row operations
-
skip-linked-list
a skiplist-backed linked list that support fast random writes, written in Rust
-
adivon
Data Structures of daily use: Graph, HashTable, PriorityQueue, Trie, SuffixTree, Rope, SplayTree, SkipList, RedBlackTree
-
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.
-
typemap_core
A no_std typemap with trait-based value-presence guarantees (on nightly)
-
restorable
An iterator adapter for saving and restoring iterator state
-
bidirectional-map
A two-way map data structure for small keys and values
-
geogrid
Manipulate geographic data on a grid
-
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)…
-
extended-rational
Provides implementations of high-accuracy projectively-extended rational numbers and macros for creating them
-
keyed
Implement comparison traits by specifying a key
-
pvec
RRB-Tree based persistent vector implementation
-
hierarchical_hash_wheel_timer
A low-level timer implementantion using a hierarchical four-level hash wheel with overflow
-
edit_tree
Edit trees in rust
-
dispatchtable
Small library used to specify function dispatch tables HashMap<K, Box<Fn(..)>>
-
collect_result
Crate for collecting an iterator of results into a result of a collection
-
persistent_rope
An immutable persistent rope data structure
-
terms
Tree terms and patterns data structures
-
avl
A map and a set implemented with an AVL tree
-
igraph
A graph representation data structure with a built in index on keys
-
ttv-helix
A wrapper around
twitch_api2for publishing as part ofttv-rs -
minimal-id
A library that implements generating short, unique ids with minimal collisions and good locality
-
ball-tree
Ball-tree implementation for K-nearest neighbors
-
watchface
A smartwatch watchface implementation
-
apint
Arbitrary precision integers library
-
mush
Visual graph/dialogue editor
-
cliquers
Manage filesequences with a common numeric component
-
mown
Maybe owned values. Wrappers for values that can be either owned or borrowed.
-
tapa-trait-serde
A collection of Tapalogi’s reusable crates
-
reso_dd
Structures and Enumerations that implement the Real Estate Standards Organization (RESO) Data Dictionary
-
sesstype
An implementation of Multiparty Session Types
-
wordsworth
A collection of natural language analysis functions
-
chunked-bytes
A rope-like non-contiguous buffer for efficient data structure serialization and vectored output
-
rosary
A Library About Rose Trees
-
densevec
Map like collection with usize indices that stores values contiguosly
-
lineartree
A simple tree data structure for rust
-
cita_trie
Modified Patricia Tree (aka Trie)
-
safe-graph
Graph implementation (refactored version of GraphMap from popular crate petgraph)
-
bytes_chain
Zero copy bytes chain based on crate
bytes -
perm-vec
Datatype representing permutations of indices
-
debt64
An implementation of Base64 - https://en.wikipedia.org/wiki/Base64
-
graphsearch
A simple graph search and representation library
-
dockerfile
A Rust library for dynamically generating Dockerfiles
-
lhlist
Labeled heterogeneous lists
-
phollaits
Here is a collection of traits that I use in my projects from time to time - feel free to use them in your projects as well
-
mmap_json_file
A library to parse, count, filter JSON files using memory mapped io library
-
bens_naive_rational_number
A crate centered around a naive implementation of a Rational Number structure
-
funnel
A simple data structure that makes it easy to read from multiple channels from a single source
-
tiled-json-rs
A crate to parse and interact with Tiled editor JSON files
-
epoch-timestamp
Boilerplate collection for epoch timestamping
-
ternary-tree-wasm
A simplified Wasm binding to ternary-tree crate
-
byte_set
Efficient sets of bytes
-
pciids
A library to parse the pci.ids data file
-
entity_table
Data structure for associating data with entities in an Entity Component System
-
growable-bloom-filter
Scalable Bloom Filters with serde support
-
fenwick
Fenwick tree: data structure that efficiently calculates prefix sums in a changing array of numbers
-
be-tree
B𝛆 Tree library in Rust
-
la-arena
Simple index-based arena without deletion
-
id-map
Data structure of values indexed by IDs
-
hotmic
high-speed metrics collection library
-
hodgepodge
A hodgepodge of enums
-
coitrees
A very fast data structure for overlap queries on sets of intervals
-
json-parser
JSON parser
-
iron-shapes
Basic data types and routines for computational geometry focused on VLSI chip design
-
timely_logging
Common timely logging infrastructure
-
bytes-utils
Additional utilities for working with the bytes crate
-
bittyset
A BitSet type for manipulating bit sets
-
tag-vec
A vector used for storing tags
-
clampf
Clamped floating-point types
-
transducers
A transducer library for Rust
-
incremental-topo
Data structure to maintain an incremental topological ordering over a collection of values
-
named_tuple
A macro for declaring a
structthat manages a set of fields in atuple -
ego-tree
Vec-backed ID-tree
-
immutable-map
An immutable ordered map and set based on weight-balanced tree
-
shared-string
Split a string without another allocation
-
take-some
A simple library that provides a way to obtain some value from various collections
-
ibuilder_derive
Interactive builder for Rust types
-
protein-get
Working with protein structures
-
depot
A (disk) persistent queue library
-
finite-automata
A collection of extendable finite automata with immutable state and transition data
-
velcro_macros
Procedural macros used by the
velcrocrate. Seevelcrofor documentation. It is not advised to depend on this crate directly; it is an internal dependency ofvelcroand may be subject to breaking changes. -
weak-self
WeakSelf is simple way to have a Weak pointer to yourself
-
simple_ringbuf
Simple Ringbuf is a speedy lightweight fixed-size infinite-use collection optimized for straightforward single threaded use
-
hamst
Hash Array Mapped Shareable Trie
-
flo_rope
An attributed and streaming implementation of the rope data structure
-
kdt
k-dimensional tree implemented with const generics
-
htmldom_read
HTML reader that parses the code into easy-use tree
-
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…
-
id-vec
Simplify Graphs in Rust. Introduces IdVec, which automatically creates Ids for each new object, reusing deleted Ids.
-
simple-bitrange
A simple crate for manipulating bit ranges which is common when working with IC registers
-
catalog
A file-based map to store key/value pairs in a file and get them using binary search
-
rabbithole
JSON:API Data Structure & Query implementation
-
protocoll
clojure inspired protocols for rust collections
-
win-idispatch
This is a rust crate that aims to provide a more ergonomic way of working with idispatch in winapi based projects
-
enum-map-derive
Macros 1.1 implementation of #[derive(Enum)]
-
atree
An arena based tree structure with removal support
-
empty-box
Allows for
Boxs to have their values moved out and replaced with new values, while reusing the same allocation -
hashbag
An unordered multiset implementation using a hash bag
-
chunky-vec
A pin safe, append only vector never moves the backing store for an element
-
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… -
bitstring
Bitstring traits and implementations
-
flats
flattens nested structures into a flat single dimension map
-
vega-lite
Generated code for using the Vega-Lite schema from Rust
-
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…
-
version-lp
a version struct library for use with version comparing, and wildcard resolving
-
aterm
Implementation of the Annotated Terms data structure
-
csv2struct
Generate Rust struct definitions from CSV
-
dinotree
An aabb space partitioning 2d tree data structure
-
rustupolis
An implementation of the tuple space data structure in Rust
-
MBrane
MBrane implementations in Rust
-
quantized-density-fields
Rust implementation of Quantized Density Fields data structure
-
restor
A dynamic resource storage system in rust
-
digits
Custom “numeric” incrementor without u64 MAX limit in size. Like a score flipper for a custom character set.
-
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)
-
thermostat
Finite state machine for a thermostat controlling a centralized HVAC system or other heating and/or cooling apparatus
-
rust_fixed_width
library that allows for easier manipulation of fixed width files allowing for the ability to name fields and such using specs
-
break_array
For breaking array indexing
-
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… -
afi
Audio & video structures, plus encoder & decoder traits
-
appstream
Appstream files parser
-
another-option
Another option data type; useful when allocations are expensive
-
tree-cursor
A simple, non-intrusive tree cursor that supports node mutation without Cell/RefCell
-
binary-data-schema
Meta language for raw binary serialization
-
options
The package provides a data structure for managing named parameters
-
matmath
Matrix and Vector Math with generic type elements
-
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 -
ruyi-slab
An object based allocator
-
unsized_enum
Unsized enum implementation
-
automerge
Rust implementation of the Automerge replicated JSON datatype
-
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.
-
paginate
A framework agnostic pagination crate, that is especially suited for databases, collections and web pages
-
enum_meta
Add metadata to Enum Variants
-
comprende
Python-style collection comprehensions in Rust
-
bpht
A bit-packed hash table implementation using hopscotch hashing for 32-bit keys and values
-
untagged-option
An unsafe Option type without discriminant. Nightly only.
-
rc-box
Known unique versions of Rc and Arc
-
bip_bencode
Efficient decoding and encoding for bencode
-
dia-i18n
ISO 3166-1 and ISO 639 codes
-
fp-collections
An alternate collections library for rust
-
scalable_cuckoo_filter
A variant of Cuckoo Filter whose size automatically scales as necessary
-
soak
Transform a struct into arrays of its fields
-
shifted_vec
A growable datastructure with positive and negative indexing built on top of
std::vec::Veccalculating the offset automatically -
ttv-rs
A hopefully-eventually-comprehensive interface to the Twitch API. Somewhat modeled after Twitch4j.
-
advancedresearch-higher_order_point
An experimental higher order data structure for 3D points
-
wrapping
Wrapping slices and arrays
-
head
Common types with inline headers, such as HeaderVec for Vec
-
entity_macros
Macro library that provides ability to generate ent logic at compile-time
-
provenance
Container structures that generate key upon insertion that only works with the map that generated it
-
arraystring
Fixed capacity stack based generic string
-
hashbrown_tstd
A Rust port of Google’s SwissTable hash map
-
bytes-expand
Types and traits for working with bytes
-
mju-bits
no_std typed bitfield access for u8, u16, u32 and u64
-
region_buffer
A growable array allowing for multiple mutable non overlapping regions
-
matrixmultiply_mt
Multithreaded Fork of bluss’s matrixmultiply crate. General matrix multiplication of f32 and f64 matrices in Rust. Supports matrices with general strides. Uses a microkernel strategy…
-
numas
numas library is implementation of multidimensional array for efficient computing
-
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)
-
traitgraph
Different representations with implemented operations on graphs
-
exotic-iter
My personal collection of special-case iterator methods
-
symbolmap-trait
A trait for generic implementation of symbol tables
-
ppar
Persistent immutable array
-
grid
Dynamic generic 2D data structure
-
pdatastructs
Simple probabilistic data structures
-
bitsets
BitSet implementations: Dense, Compressed, Memory-Mapped, and Roaring
-
leonardo-heap
Heap structure supporting fast in-place partial sorting
-
any_key
Dynamically typed keys for associative arrays
-
relational_types
Manage relations between objects
-
type-freak
Collection of typed data structures, trait operators and aliases
-
consume
Memory order consume for when it’s known that the compiler can’t elide the dependency
-
hoop
Fixed ring buffer that allows non-consuming iteration both ways
-
vk_generator
Generate Rust bindings to the Vulkan API
-
street_index
street_index is a small utility crate for working with road name / street indexing for cartographic purposes
-
gtrie
Generic trie implementation with a support of different key and value types
-
json-trait-rs
Rust interface (aka trait) to deal with objects as they are JSON objects
-
xml-schema-derive
Structure generator from XSD source file
-
bipbuffer
A Rust implementation of Simon Cooke’s Bip-Buffer
-
iostream
the project is rust io stream.you can easily use it to manipulate files stream and memory stream
-
higher-cat
Functors, Applicatives, Monads and other bad ideas
-
collections-more
Common data structure and algorithms for rust-lang to complete the already excellent std::collections
-
puruda
Pure Rust DataFrame
-
refactory_string
A library to modify a string using original indices. Useful for Source Code transformations.
-
bip_select
Bittorrent Infrastructure Project Piece Selection Module
-
replicante_models_agent
Replicante Agent API request/response models
-
binary-tree
Collection of Binary Tree data structures and algorithms
-
sum-queue
Queue struct that keeps a fixed number of items by time, not capacity, and allows to get summarized stats of its content
-
compacts
compact data structures
-
ngds
Rust bindings for AVFounation
-
histogram-sampler
Sampling from a distribution given by a histogram
-
evobox
A pointer type which allows for safe transformations of its content without reallocation
-
fricgan
A simple crate for performing basic input and output on bytes
-
mori
An orientation library built around commonly used orientation representations used in crystallography and engineering applications. It contains conversion, rotation, and data analysis…
-
bittree
A crate for O(1) find functions in a special data structure called a bit tree
-
ro
Helps make stuff read-only
-
cbloom
Concurrent implementation of Bloom filters
-
prehash
A crate for storing values with precomputed hashes
-
sprs_suitesparse_camd
sprs bindings to the suitesparse camd fill-in reducting ordering
-
ic-cdk
Canister Developer Kit for the Internet Computer
-
dimension_shiftable_buffer
A dimension shiftable buffer
-
divbuf
Buffer object that can be recursively divided into smaller buffers
-
tetsy-kvdb
Generic key-value trait
-
staticsort
Implements a macro providing a compile-time quicksort function for arrays of any length, containing any primitive Copy type with a PartialOrd implementation
-
map_vec
The Map and Set APIs backed by Vec
-
ring-vec
A zero-dependency, no-std compatible, producer-consumer, fixed-size, item-oriented ring buffer backed by a vector
-
divsufsort
Rust port of Yuta Mori’s divsufsort
-
calf-vec
Small copy-on-write arrays, essentially combining
SmallVecandCow -
holyhashmap
A hash map with stable indices
-
ttmap
Trivial implementation of type map
-
vecdeque-stableix
Deque with stable index values
-
atlist-rs
A LinkedList which is allowed to insert/remove element by immutable iterator.Adding, removing and moving the elements within the list or across several lists does not invalidate the iterators or references…
-
lazy_concat
Lazy concatenation for Strings and Vecs
-
rc-dlist-deque
Doubly-linked list based on std::Rc
-
eclectic
Experimental collection traits
-
automap
Simple pattern to implement key-value maps where the value type contains the key type
-
pyrpds
Python Wrapper for Rust Persistent Data Structures
-
fral
Functional random-access lists
-
reflection
reflects of type’s fields’ names and their type names in a hierarchical tree
-
transit_model_collection
Manage collection of objects
-
sparseset
A Sparse Set
-
generic-arrayvec
Interop between the arrayvec and generic_array crates
-
ring_queue
A double-ended queue implemented using a vector that reuses space after elements are removed
-
batching-queue
An Israeli Queue implementation
-
btree_dag
A generic DAG (undirected graph) data structure
-
non-empty-collections
Non-empty hash-map and hash-set implementations
-
rudy
Judy array implementation in pure Rust
-
dot_json
Tools for dot map representations of serde_json Maps
-
dynstr
A string implementation optimized for manipulations
-
thunk
Primitives for generic lazy evaluation in Rust. This crate requires nightly for
untagged_unions. -
handlebox
A map-like collection that reuses unused keys
-
canonical_collections
Data structures for use with Canonical
-
frombytes
Defines a cursor over a slice of bytes
-
heatmap
time-series of histograms with precision guarantees
-
ensured_bufreader
A Bufreader ensures N bytes in buffer
-
maybe-string
Provides a newtype wrapper that represents a byte vector that may be a valid UTF-8 string
-
minecraft_nether_generation
The minecraft nether generation implemented in rust
-
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…
-
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
-
bip_handshake
Common handshaking interface as well as a default handshake implementation
-
hayami
A simple, general use symbol table
-
mrslac
A Rust crate with sparse matrix data structures
-
arc-string-interner
An efficient string interning data structure with minimal memory-footprint and fast access to the underlying contents
-
stonks
Sets that allow borrowing while inserting entries
-
gcollections
Generic traits over Rust collections library
-
appendlist
An append-only list that preserves references to its elements
-
graph-arena
Collection type to store immutable graph structures efficiently
-
traitsequence
Traits to abstract over sequences
-
lock-free-stack
Lock-free (atomic-based) Collection which internally represent data as a Stack, and exposes an interface allowing to add elements, get size, and remove all giving a reverse-iterator
-
baffa
Generic buffer for bytes
-
medianheap
A median heap for keeping track of a running median
-
guzzle-derive
The derive macro for guzzle, please use that crate not this one
-
timely
A low-latency data-parallel dataflow system in Rust
-
functional_list
A functional, immutable list for Rust
-
simid
A Simple Universally Unique IDentifier (UUID)
-
semver-store
An HashMap structure that uses semver strings as keys
-
immutable-seq
Immutable sequence data structure
-
higher_order_functions
A small collection of traits for implementing higher order functions
-
discord-indexmap
A fork of the popular
indexmaplibrary that adds a few extra APIs that are yet to be upstreamed -
takeable
Container type that allows for temporarily moving out of the container
-
tetsy-transaction-pool
Generic transaction pool
-
loader-rs
Rust interface to load generic objects from an URI
-
litemap
A key-value Map implementation based on a flat, sorted Vec
-
easy_graph
Data structure that represent generic vertices and undirected connections
-
prefix-tree
A map and set interfaces using trie data structure
-
jagged_array
Owned
[[T]]-like 2D array where each row can differ in length -
sized-vec
Type level sized vectors
-
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.
-
byte_trie
A compressed trie based on bytes with some weird child node bucket sizes
-
tapa-trait-serde-derive
Tapalogi’s derive macro for tapa-trait-serde
-
nue
I/O, POD, and misc. binary data encoding
-
thincollections
Alternative implementations for vector, map and set that are faster/smaller for some use cases
-
tapa-cgloop-nats
A collection of Tapalogi’s reusable crates
-
hashindexed
A cache. A set which compares elements in a customisable way without overriding the eq() and hash() functions on the type itself.
-
feattle-ui
Featture toggles for Rust, extensible and with background synchronization and administration UI
-
expanding_slice_rb
A self-expanding ring buffer optimized for working with slices of data
-
tree-automata
Term Rewriting Systems
-
gvec
Very simple implementation of generational indexing for vectors written in Rust
-
typescript-definitions-derive-ufo-patch
serde support for exporting Typescript definitions