-
hashbrown
A Rust port of Google’s SwissTable hash map
-
smallvec
‘Small vector’ optimization: store up to a small number of items on the stack
-
bytes
Types and traits for working with bytes
-
generic-array
Generic types implementing functionality of arrays
-
hdrhistogram
A port of HdrHistogram to Rust
-
arrayvec
A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.
-
num
A collection of numeric types and traits for Rust, including bigint, complex, rational, range iterators, generic integers, and more!
-
bitvec
A crate for manipulating memory, bit by bit
-
bit-vec
A vector of bits
-
arc-swap
Atomically swappable Arc
-
predicates
An implementation of boolean-valued predicate functions
-
priority-queue
A Priority Queue implemented as a heap with a function to efficiently change the priority of an item
-
scroll
A suite of powerful, extensible, generic, endian-aware Read/Write traits for byte buffers
-
either
The enum
Eitherwith variantsLeftandRightis a general purpose sum type with two cases -
im
Immutable collection datatypes
-
crdts
Practical serializable thoroughly tested CRDTs (ORSWOT, counters, LWW) ported from riak_dt
-
staticvec
Implements a fixed-capacity stack-allocated Vec alternative backed by an array, using const generics
-
ndarray
An n-dimensional array for general elements and for numerics. Lightweight array views and slicing; views support chunking and splitting.
-
radix_trie
Generic radix trie data-structure
-
bit-set
A set of bits
-
enumset
A library for creating compact sets of enums
-
generator
Stackfull Generator Library in Rust
-
indextree
Arena based tree structure by using indices instead of reference counted pointers
-
rust_decimal_macros
Shorthand macros to assist creating Decimal types
-
starling
This tree structure is a binary merkle tree with branch compression via split indexes
-
sized-chunks
Efficient sized chunk datatypes
-
string-interner
An efficient string interning data structure with minimal memory-footprint and fast access to the underlying contents
-
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…
-
spade
Spatial datastructures like r-trees and delaunay triangulations for rust
-
bimap
A fast two-way bijective map implementation
-
rpds
Persistent data structures with structural sharing
-
vec_map
A simple map based on a vector for small integer keys
-
kdtree
K-dimensional tree in Rust for fast geospatial indexing and nearest neighbors lookup
-
merkle-cbt
A library for generating efficient Merkle tree and combined Merkle proof based on complete binary tree
-
patricia_tree
Memory-efficient data structures based on patricia tree
-
sharded-slab
A lock-free concurrent slab
-
string
A UTF-8 encoded string with configurable byte storage
-
guppy
Track and query Cargo dependency graphs
-
rstar
R*-tree library for the rust ecosystem
-
trees
General purpose tree 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…
-
tinystr
A small ASCII-only bounded length string representation
-
bv
Bit-vectors and bit-slices
-
rusty_ulid
Rust ULID (Universally Unique Lexicographically Sortable Identifier) generation and processing
-
vec1
a std Vec wrapper assuring that it has at least 1 element
-
array-macro
Array multiple elements constructor syntax
-
linked-hash-map
A HashMap wrapper that holds key-value pairs in insertion order
-
heapless
staticfriendly data structures that don’t require dynamic memory allocation -
hdf5
Thread-safe Rust bindings for the HDF5 library
-
qp-trie
An idiomatic and fast QP-trie implementation in pure Rust, written with an emphasis on safety
-
fraction
Lossless fractions and decimals; drop-in float replacement
-
anymap
A safe and convenient store for one value of each type
-
petgraph
Graph data structure library. Provides graph types and graph algorithms.
-
array-init
Safe wrapper for initializing fixed-size arrays
-
vob
Vector of Bits with Vec-like API and usize backing storage
-
flat-tree
Rust module for encoding/decoding varints that doesn’t do any IO. Inspired by the Node.js varint module
-
id_tree
A library for creating and modifying Tree structures
-
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.
-
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
-
intrusive-collections
Intrusive collections for Rust (linked list and red-black tree)
-
slice-deque
A double-ended queue that Deref’s into a slice
-
ucd-trie
A trie for storing Unicode codepoint sets and maps
-
tinyvec
Just, really the littlest Vec you could need. So smol.
-
convenient-skiplist
Convenient and Performant SkipList with serde support
-
arr_macro
Initialize arrays with ease!
-
index_vec
Newtype-style helpers for
Vecandusize -
sprs
A sparse matrix library
-
slice-dst
Slice-based custom DSTs
-
smallbitvec
A bit vector optimized for size and inline storage
-
bitlab
Extracting a range of bits from a binary data source
-
cidr-utils
This crate provides data structures and functions to deal with IPv4 CIDRs and IPv6 CIDRs
-
arccstr
Thread-safe, reference-counted null-terminated immutable strings
-
min-max-heap
An efficient, double-ended priority queue
-
stackvector
StackVec: vector-like facade for stack-allocated arrays
-
optional
This crate supplies a number of Option-like primitive types
-
im-rc
Immutable collection datatypes (the fast but not thread safe version)
-
enum-ordinalize
This crates provides a procedural macro to let enums not only get its variants’ ordinal but also be constructed from an ordinal
-
trie-root
In-memory patricia trie operations
-
dinotree_alg
Dinotree algorithms
-
typescript-definitions
serde support for exporting Typescript definitions
-
hibitset
Hierarchical bit set structure
-
graphlib
Graphlib is a simple and powerful rust library for the graph data-structure
-
circular-queue
A circular buffer-like queue
-
trk-io
TrackVis (*.trk) reader and writer
-
redo
Provides advanced undo-redo functionality with static dispatch
-
rc-u8-reader
A tiny implement for reading
u8data from a reference counted instance -
option_set
Bitflags on steroids
-
bloomfilter
Bloom filter implementation
-
ternary-tree
A Rust implementation of Ternary Search Trees, with no unsafe blocks
-
probabilistic-collections
Various implementations of collections that use approximations to improve on running time or memory, but introduce a certain amount of error
-
treeflection
A library that provides reflection for tree structures
-
flatk
Flat layout abstraction toolkit
-
tri-mesh
A triangle mesh data structure including basic operations
-
molecule
Rust bindings for molecule
-
adapton
programming abstractions for general-purpose incremental computations
-
macaddr
MAC address types
-
daab
DAG aware artifact builder
-
usher
Parameterized routing for generic resources in Rust
-
pagetable
simple wait-free two-level pagetable with 2mb pages
-
alloc-wg
Attempt of collection several proposals of the allocators-wg
-
fid
FID (Fully Indexable Dictionary) implementation for Rust
-
json_dotpath
Dotted path access to nested JSON objects (serde_json::Value)
-
hash_hasher
A hasher which is designed to work with already-hashed or hash-like data
-
roaring
http://roaringbitmap.org : A better compressed bitset - pure Rust implementation
-
slab_tree
A vec-backed tree structure with tree-specific generational indexes
-
voluntary-servitude
Thread-safe appendable list with lock-free iterator
-
threshold
Threshold data structures
-
panoradix
A generic map and a set, both backed by a Radix tree
-
bitvector
BitVector implementation in Rust
-
kstring
Key String: optimized for map keys
-
fixed-map
A fixed map where storage layout is calculated by a procedural macro
-
cactus
Immutable parent pointer tree
-
byte_set
Efficient sets of bytes
-
ibuilder
Interactive builder for Rust types
-
enum-map
A map with C-like enum keys represented internally as an array
-
typescript-definitions-ufo-patch
serde support for exporting Typescript definitions
-
abi_stable_shared
Implementation detail of abi_stable
-
ego-tree
Vec-backed ID-tree
-
ndsparse
Sparse structures for N-dimensions
-
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.
-
nanoset-py
A memory-optimized wrapper for Python sets likely to be empty
-
ndarray-stats
Statistical routines for ArrayBase, the n-dimensional array data structure provided by ndarray
-
egg
An implementation of egraphs
-
plain
A small Rust library that allows users to reinterpret data of certain types safely
-
tiled
A rust crate for loading in maps created by the Tiled editor
-
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
-
merkle
Merkle tree implementation with support for generation of inclusion proofs
-
exonum-merkledb
Persistent storage implementation based on RocksDB which provides APIs to work with Merkelized data structures
-
yyid
Yyid generator (random tokens like UUIDv4, but using all the bits)
-
skiplist
Skiplist implementation in rust, providing fast insertion and removal. A normal skiplist is implemented, as well as an ordered skiplist and a skipmap.
-
subset-map
A map where the keys are subsets of an initial set of elements
-
intervaltree
A simple and generic implementation of an immutable interval tree
-
typed_index_collection
Manage collection of objects
-
numeric-array
Wrapper around generic-array that adds efficient numeric trait implementations
-
cedarwood
efficiently-updatable double-array trie in Rust (ported from cedar)
-
bucket_vec
A vector-like data structure that guarantees to never move its contained elements
-
space
A library providing abstractions for spatial datastructures and search
-
rustfst
Library for constructing, combining, optimizing, and searching weighted finite-state transducers (FSTs)
-
blender-armature
Serialize / deserialize Blender armatures
-
toodee
A lightweight 2D wrapper around a Vec
-
fenwick
Fenwick tree: data structure that efficiently calculates prefix sums in a changing array of numbers
-
dlv-list
Semi-doubly linked list implemented using a vector
-
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. -
kserd
Kurt’s Self-Explanatory Rust Data
-
extindex
Persisted immutable index
-
hopscotch
A FIFO queue for efficiently hopping and skipping between tagged items
-
stash
An amortized
O(1)table for cases where you don’t need to choose the keys and want something faster than a HashTable -
rc-borrow
Borrowed forms of Rc and Arc
-
bitmaps
Fixed size boolean arrays
-
linked_hash_set
HashSet with insertion ordering
-
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
-
contest-algorithms
Common algorithms and data structures for programming contests
-
tst
Ternary search trie collection in rust with similar API to std::collections as it possible
-
c_vec
Structures to wrap C arrays
-
rexsgdata
Scatter-Gather Data Descriptors
-
simple_endian
A create for defining endianness within your data structures, to make handling portable data structures simpler
-
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
-
smart_access
A minimalistic “lazy bidirectional pointer” framework
-
large_int
An ease-of-use unbounded signed integer
-
beach_map
Implementation of a slotmap
-
sequence_trie
Trie-like data-structure for storing sequences of values
-
unstructured
Generic types for unstructured data
-
fm-index
FM index and its variant implementations for Rust
-
succinct
Succinct data structures for Rust
-
griddle
A HashMap variant that spreads resize load across inserts
-
treebitmap
Fast IPv4/IPv6 lookup trie
-
concread
Concurrently Readable Data-Structures for Rust
-
onigiri
This crate is a tool of handling chars
-
queues
Efficient FIFO Queue data structures
-
binn-ir
An implementation of Binn - https://github.com/liteserver/binn
-
libnv
Safe and rustic wrapper around libnv-sys
-
hashbrown_tstd
A Rust port of Google’s SwissTable hash map
-
fwdlist
A simply linked (forward) list
-
imag-id-in-collection
Part of the imag core distribution: imag-ids command
-
rsdict
Fast static rank and select data structure
-
uluru
A simple, fast, LRU cache implementation
-
succinct_rs
Succinct Data Structures library for Rust
-
simd_aligned
Safe and fast SIMD-aligned data structures with easy and transparent ‘flat’ access
-
bitwrap
pack/unpack data into byte array
-
mori
An orientation library built around commonly used orientation representations used in crystallography and engineering applications. It contains conversion, rotation, and data analysis…
-
keyed_priority_queue
Priority queue that support changing priority or early remove by key
-
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 -
vector-map
VecMap<K, V>: a Linear Search with Map API
-
galemu
Provides a workaround for generic associated types (GAT) limited to lifetimes (GAL)
-
kissunits
Different units (like distances or coordinates), keeping it small and simple
-
nested
A memory efficient container for nested collections (like
Vec<String>orVec<Vec<T>>) -
base_custom
Use any characters as your own numeric base and convert to and from decimal
-
numas
numas library is implementation of multidimensional array for efficient computing
-
sparsevec
Compress vectors using row displacement
-
verify
A validation library
-
hash-rings
Implementations of various hash rings
-
patricia_router
Radix Tree implementation for Rust
-
generational-indextree
Arena based tree structure by using indices instead of reference counted pointers
-
keyvi
Keyvi - the key value index. It is an in-memory FST-based data structure highly optimized for size and lookup performance.
-
undo
Provides simple undo-redo functionality with dynamic dispatch
-
csv2json
Converts CSVs into JSON documents
-
cast-rs
A collection of types cast for Rust
-
persist-o-vec
A Vec type that aims to have stable indices and memory location
-
tiny_ecs
A tiny ECS that tries to avoid unnecessary copy/clones
-
floating_bar
Representing rational numbers using the floating-bar number type
-
ordered-multimap
Insertion ordered multimap
-
fingertrees
Immutable persisten finger trees
-
orderbook
Orderbook for Rust
-
nested_intervals
nested & overlapping interval set functions, overlap, union, etc
-
keylist
Elixir keyword list in Rust
-
flit
Bloom filter backed by xxHash
-
sum
General-purpose sum types
-
big_unsigned_ints
A Crate For Big Unsigned Integers ranging from U256 to U2048 using u64 arrays all under a fixed-size of 32
-
outils
Graph and tree data structure library. Providing utilities which aren’t easily available in Rust.
-
sorted-iter
Typesafe extensions for sorted iterators, including set and relational operations
-
pvec
RRB-Tree based persistent vector 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. -
slabmap
HashMap-like collection that automatically determines the key
-
bitrush-index
A serializable bitmap index library able to index millions values/sec on a single thread
-
radix-tree
A radix tree implementation for router, path search
-
idcontain
Generational (or tagged) ID-based containers
-
chainmap
A ChainMap with mutability of intermediate maps
-
liblet
Library for learning about formal languages and grammars
-
exponential-decay-histogram
A histogram which exponentially weights in favor of recent values
-
slack-blocks
Models + clientside validation for Slack’s JSON Block Kit
-
cita_trie
Modified Patricia Tree (aka Trie)
-
fixedbitset
FixedBitSet is a simple bitset collection
-
splay_tree
Splay Tree based Data Structures (map, set, heap)
-
chainkov
HashMap / Tuple-backed Markov Chains
-
rc-writer
A tiny implement for writing data to a reference counted instance
-
fp_rust
Implement fp features for Rust
-
queue-file
queue-file is a lightning-fast, transactional, file-based FIFO
-
erasable
Type-erased thin pointers
-
atree
An arena based tree structure with removal support
-
json-trait-rs
Rust interface (aka trait) to deal with objects as they are JSON objects
-
watermark
A simple watermarking set for in-order insertions
-
retworkx
A python graph library implemented in Rust
-
one_way_slot_map
An implementation of SlotMap with minimal restrictions on Keys and Values
-
smallstr
String-like container based on smallvec
-
arq
Arq library to manage Arq Backup data formats
-
flatgeobuf
FlatGeobuf for Rust
-
hashlink
HashMap-like containers that hold their key-value pairs in a user controllable order
-
nibble_vec
Vector data-structure for half-byte values
-
cmp_wrap
Let you compare structes by context
-
grid
Dynamic generic 2D data structure
-
grdf
Generalized RDF graphs and datasets
-
polytype
A Hindley-Milner polymorphic typing system
-
multi_mut
Methods on HashMap and BTreeMap for safely getting multiple mutable references to the contained values
-
histogram
histogram storage and percentile metrics with precision guarentees
-
guzzle
A derivable trait for consuming key value pairs into structs
-
sea-canal
Identifies patterns in sequences of integers
-
disjoint-sets
Three union-find implementations
-
osproto
Protocol structures for OpenStack API
-
elsa
Append-only collections for Rust where borrows to entries can outlive insertions
-
bounded-spsc-queue
A bounded SPSC queue
-
ensure
Ensure target state of an object
-
radix-heap
Fast monotone priority queues
-
dync
An efficient alternative to
dyn Traitfor containerized types -
modular-bitfield
Bitfields for structs that allow for modular use of enums
-
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.
-
midas_cli
Rust port of MIDAS (Microcluster-Based Detector of Anomalies in Edge Streams)
-
defaultmap
Provides a HashMap with an automatic default for missing keys
-
fixed-vec-deque
A fixed-size, zero-allocation circular buffer for Rust
-
iset
This crates implements map and set with interval keys
-
cow_vec_item
Copy-on-write Vec, available on stable rust
-
wavelet-matrix
A wavelet matrix implementation. Supports various near-O(1) queries on large number of symbols or integers.
-
rust_decimal_macro_impls
Shorthand macros to assist creating Decimal types. Do not depend on this directly; use rust_decimal_macros
-
resources
Safe store for one value of each type, with interior mutability
-
poisson
Poisson-disk distribution generator
-
hat_trie
A hat-trie implementation that support prefix match iteration
-
backtracking_iterator
A simple implementation of a generic iterator with an item history, capable of backtracking and forgetting
-
hierarchical_hash_wheel_timer
A low-level timer implementantion using a hierarchical four-level hash wheel with overflow
-
minimal-id
A library that implements generating short, unique ids with minimal collisions and good locality
-
code_location
A library to automatically acquire a code location in a rust source code file
-
alg_ds
Algorithms & data structures
-
gridly
A library for managing fixed-size 2D spaces
-
array_ext
Extra functionality for Rust arrays
-
mset
A mset / multiset / bag implementation
-
indexed
Convenient allocator for index-linked data structures
-
fallible_collections
a crate which adds fallible allocation api to std collections
-
boolvec
A vector of boolean stored contiguously in memory
-
simple-matrix
A simple generic matrix library
-
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.
-
xml-schema
Structure generator from XSD source file
-
string-wrapper
A possibly-stack-allocated string with generic bytes storage
-
bipbuffer
A Rust implementation of Simon Cooke’s Bip-Buffer
-
chainbuf
Fast chained buffers
-
packedvec
Store vectors of integers efficiently
-
static_merkle_tree
Static Merkle Tree is dedicated for generating Merkle Root and Merkle Proof for a static list of items
-
om2
A set of classes generated from the OM2 RDF schema (mainly Unit)
-
multiset
Multisets/bags
-
moniker
Automatically derive variable binding and alpha equivalence for abstract syntax trees
-
smallbigint
Big integer types that have a small on-stack representation for small values. Uses num-bigint internally.
-
inspector
General purpose inspection for popular data structures
-
edit_tree
Edit trees in rust
-
bucket_queue
A Bucket Queue data structure that can be used as a Priority Queue
-
ahtable
Array Hash Table implementation
-
uuid-rs
A Simple Universally Unique IDentifier (UUID)
-
vf-rs
A set of classes generated from the ValueFlows RDF schema
-
bitmaptrie
Bitmapped vector trie (mutable, not persistent). Word-size path-cached indexing into essentially a sparse vector. Requires rust-nightly.
-
map_vec
The Map and Set APIs backed by Vec
-
bex
A rust library for working with boolean expressions (expression trees, decision diagrams, etc.)
-
vec-tree
A safe tree using an arena allocator that allows deletion without suffering from the ABA problem by using generational indices
-
collectable
Fallible, no_std-friendly collection traits
-
dispatchtable
Small library used to specify function dispatch tables HashMap<K, Box<Fn(..)>>
-
arraystring
Fixed capacity stack based generic string
-
atlatl
Double-array tries
-
heaparray
Flexible support for dynamically-sized types, using heap-allocated array of structs
-
broom
An ergonomic tracing garbage collector that supports mark ’n sweep garbage collection
-
mown
Maybe owned values. Wrappers for values that can be either owned or borrowed.
-
guppy-summaries
Build summaries for Cargo, created by guppy
-
rtable
Generic Routing Table Library with Radix Tree
-
chunked-bytes
A rope-like non-contiguous buffer for efficient data structure serialization and vectored output
-
fuzzy_trie
Key-value collection to make fuzzy searches
-
gtrie
Generic trie implementation with a support of different key and value types
-
swaybar-types
A library for building swaybar status commands in rust
-
generic-tree
A very simple, intuitive API for storing data in a tree-like structure
-
sparseset
A Sparse Set
-
predicates-tree
Render boolean-valued predicate functions results as a tree
-
bip_metainfo
Parsing and building of bittorrent metainfo files
-
avm1-tree
Abstract Syntax Tree (AST) for AVM1
-
handy
A library providing handles and handlemaps
-
manhattan-tree
A spatial tree which can effiently find closest key to a point, by manhattan distance
-
non-empty-collections
Non-empty hash-map and hash-set implementations
-
debt64
An implementation of Base64 - https://en.wikipedia.org/wiki/Base64
-
gtfs-geojson
A simple converter for GTFS to GeoJSON formats
-
smartstring
Compact inlined strings
-
range
A library for range addressing
-
paginate
A framework agnostic pagination crate, that is especially suited for databases, collections and web pages
-
atomic-take
Atomically take a value out of a container once
-
tag-vec
A vector used for storing tags
-
no_vec
A library for modifying sized arrays
-
roadmap
model a project roadmap as a directed acyclic graph
-
bpht
A bit-packed hash table implementation using hopscotch hashing for 32-bit keys and values
-
discord-indexmap
A fork of the popular
indexmaplibrary that adds a few extra APIs that are yet to be upstreamed -
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.
-
lz_diet
An AVL balanced Discrete Interval Encoding Tree
-
hedge
An index based half-edge mesh implementation
-
slice-of-array
Extension traits for casting between slices and slices of arrays. (&[T] <-> &[[T; n]])
-
dia-i18n
ISO 3166-1 and ISO 639 codes
-
prefix-tree
A map and set interfaces using trie data structure
-
intervallum
Generic interval and interval set library
-
default-vec
A specialized vector that has a default value
-
checked
Implements a wrapper over the primitive Rust types that better indicates overflow during arithmetic
-
compt
A complete binary tree visitor library
-
Project2
Implementations of red black tree and AVL tree
-
lumberjack
Read and modify constituency trees
-
uid
A crate for the creation of unique IDs
-
strict
NonEmptyVec, a vec guaranteed to hold at least one element
-
enum_vec
Efficiently store a vector of enum variants as a packed n-bit vec
-
sqa-bounded-spsc-queue
A bounded SPSC queue (temporary version so I can publish sqa-engine)
-
lending-library
A key-value store that loans full ownership of items
-
advancedresearch-higher_order_point
An experimental higher order data structure for 3D points
-
rust-fsm
A framework for building finite state machines in Rust
-
hash-chain
A tiered hashmap and hashset implementation that allows for easily representing lexically scoped variables
-
gsrs
Generic Self Referencing Struct
-
passive
A trio of marker traits to classify passive data structures
-
tiled-json-rs
A crate to parse and interact with Tiled editor JSON files
-
theban_interval_tree
A simple Interval Tree implementation
-
idlset
Fast u64 set operations library
-
free-ranges
An efficient data structure for keeping track of indices which are either free or not
-
region_buffer
A growable array allowing for multiple mutable non overlapping regions
-
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… -
restor
A dynamic resource storage system in rust
-
segment-tree
Quickly perform interval queries or modifications
-
jagged_array
Owned
[[T]]-like 2D array where each row can differ in length -
flo_rope
An attributed and streaming implementation of the rope data structure
-
ruyi-slab
An object based allocator
-
slots
Fixed size data structure with constant-time operations
-
rudac
A crate for common data structures and algorithms
-
isomorphism
2 directional hashmaps
-
jirachi
A collision resistant runtime agnostic key-generator
-
generic-arrayvec
Interop between the arrayvec and generic_array crates
-
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
-
string_map
Create a record to store any type of value
-
cliquers
Manage filesequences with a common numeric component
-
ttm-rs
CLI to turn tuples into adjacency matrices
-
tranche
Tranches are an alternative to slices
-
rustz
A library for functional programming in Rust
-
hex2d
Helper library for working with 2d hex-grid maps
-
data_reader
A data loading library for data scientist
-
iowrap
Small helpers for using io::Read/io::Write
-
atone
A VecDeque and Vec variant that spreads resize load across pushes
-
bonzai
An abstraction for optimizing the memory layout and pointer aliasing of trees
-
intrusive_splay_tree
An intrusive splay tree implementation that is no-std compatible and free from allocation and moves
-
hash_ring
Consistent Hashing library for Rust
-
soak
Transform a struct into arrays of its fields
-
safe_index
Type-safe indexes
-
mucell
A cell with the ability to mutate the value through an immutable reference when safe
-
puruda
Pure Rust DataFrame
-
ordsearch
A data structure for efficient lower-bound lookups
-
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)
-
arc-string-interner
An efficient string interning data structure with minimal memory-footprint and fast access to the underlying contents
-
treeflection_derive
#[derive(Node)] macro for the Treeflection library
-
reso_dd
Structures and Enumerations that implement the Real Estate Standards Organization (RESO) Data Dictionary
-
basic_tree
basic tree for rust, for now including only trie
-
fast_paths
Fast shortest path calculations on directed graphs made possible by pre-processing the graph using Contraction Hierarchies
-
aci_ppm
Encode and decode PNM image files (TODO: so far only PPM)
-
grafana-dashboard
grafana import/export data serializable structures
-
stable_bst
An ordered map and set based on a binary search tree. Works with stable Rust 1.9.0.
-
soa-vec
A simple Vec-like API over a struct of arrays layout
-
helgoboss-midi
Interfaces, data structures and utilities for dealing with MIDI messages according to the MIDI 1.0 specification
-
blender-mesh
Serialize / deserialize Blender armatures
-
staticsort
Implements a macro providing a compile-time quicksort function for arrays of any length, containing any primitive Copy type with a PartialOrd implementation
-
apint
Arbitrary precision integers library
-
mju-bits
no_std typed bitfield access for u8, u16, u32 and u64
-
varuint
Variable length signed and unsigned integer types
-
bet
Helps parsing and evaluating binary expression trees
-
stomp
A full STOMP 1.2 client implementation. Allows programs to interact with message queueing services like ActiveMQ and RabbitMQ.
-
mediumvec
Vector types optimized for space, including a 32-bit Vec
-
sesstype
An implementation of Multiparty Session Types
-
sortedvec
a sorted vector that enables quick lookups
-
spool
Simple object pool for upfront allocation!
-
smart-hash
partial queries in HashSets, the traits
-
gapbuf
Generic gap buffer
-
ptr-union
Pointer union types the size of a pointer by storing the tag in the alignment bits
-
tilecoding
Rust implementation of Dr. Richard S. Sutton’s tile coding software.
-
gridd
A generic, dirt-simple, two-dimensional grid
-
vec4
vec4
-
skew-forest
Skew-binary random access lists
-
wccg-models
WCCG Data
-
uvector
access two slices as a single continuous vector
-
refactory_string
A library to modify a string using original indices. Useful for Source Code transformations.
-
divbuf
Buffer object that can be recursively divided into smaller buffers
-
froop
A functional reactive stream library for rust
-
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)…
-
growable-bloom-filter
Scalable Bloom Filters with serde support
-
array-const-fn-init
Initializes an array with constant values calculated by a
const fn -
derive_wrapper
Rust custom derive macro for wrapping types
-
restorable
An iterator adapter for saving and restoring iterator state
-
automerge
Rust implementation of the Automerge replicated JSON datatype
-
version-rs
A struct for Versions, with the methods you expect
-
ring_buffer
RingBuffer is a mix of a vector and a queue
-
big_enum_set
A library for creating sets of enums with a large number of variants
-
multipath
A library to split file path, like
/home/{user,admin}/file.txt -
nullvec
Rust nullable vector, which can contain null(missing) values as element
-
colours
Color types for different color models with conversions between it
-
actions
Software without side-effects. Redo and Undo. Macro’s.
-
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…
-
webe_id
Unique ID generator based on Snowflake, but for us wizards
-
stonks
Sets that allow borrowing while inserting entries
-
teardown_tree
A binary search tree that supports fast clone and delete-range operations
-
geogrid
Manipulate geographic data on a grid
-
xlru-cache
A cache that holds a limited number of key-value pairs
-
multiref
Multireferences: a safe way to do [&T] -> &[T]
-
divsufsort
Rust port of Yuta Mori’s divsufsort
-
partial
Optional monad with fake variant
-
extended-rational
Provides implementations of high-accuracy projectively-extended rational numbers and macros for creating them
-
matmath
Matrix and Vector Math with generic type elements
-
flot
Generate HTML documents with embedded charts using Flot
-
loader-rs
Rust interface to load generic objects from an URI
-
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.
-
iostream
the project is rust io stream.you can easily use it to manipulate files stream and memory stream
-
incremental-topo
Data structure to maintain an incremental topological ordering over a collection of values
-
simple_ringbuf
Simple Ringbuf is a speedy lightweight fixed-size infinite-use collection optimized for straightforward single threaded use
-
another-option
Another option data type; useful when allocations are expensive
-
ro
Helps make stuff read-only
-
geomprim2d
2D geometric primitive types
-
field-ref
Field reference (like a member pointer to non-static data field in C++) for Rust
-
stack
DSTs and arrays on the stack!
-
ternary-tree-wasm
A simplified Wasm binding to ternary-tree crate
-
string-err
String error type
-
bytes_chain
Zero copy bytes chain based on crate
bytes -
pl-lens
Provides support for lenses, which are a mechanism in functional programming for focusing on a part of a complex data structure
-
lhlist
Labeled heterogeneous lists
-
histogram-sampler
Sampling from a distribution given by a histogram
-
json-parser
JSON parser
-
ball-tree
Ball-tree implementation for K-nearest neighbors
-
pegitan
A bunch of random algorithms library
-
wrapping
Wrapping slices and arrays
-
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.
-
ttmap
Trivial implementation of type map
-
grid_trait
2D and 3D grids with combinators
-
shifted_vec
A growable datastructure with positive and negative indexing built on top of
std::vec::Veccalculating the offset automatically -
htmldom_read
HTML reader that parses the code into easy-use tree
-
dockerfile
A Rust library for dynamically generating Dockerfiles
-
named_tuple
A macro for declaring a
structthat manages a set of fields in atuple -
k2_tree
A space-efficient representation of sparsely populated bit-matrices
-
funnel
A simple data structure that makes it easy to read from multiple channels from a single source
-
baffa
Generic buffer for bytes
-
rc-box
Known unique versions of Rc and Arc
-
int_traits
Provides a trait for extended functions on integers
-
shuffled-iter
Iterate through a set of values in random order without allocating them all
-
compact_path_tree
A data structure providing a compact in-memory representation of a tree of paths
-
terminal-linked-hash-map
A fork of linked-hash-map that builds on stable in exchange for not allowing custom hashers
-
glyph-bbox
Data structures for managing glyph bbox datasets and support for calculating string bbox’s
-
trie
An ordered map and set based on a trie
-
ringbuffer
A fixed-size circular buffer
-
doubly
Doubly linked lists in rust
-
flatten
Tuple flatteing for rust
-
lazy_concat
Lazy concatenation for Strings and Vecs
-
transit_model_relations
Modeling the relations between objects
-
querable
Quer(y)able data structure implementation
-
enum_meta
Add metadata to Enum Variants
-
rust_release_artefact
Safely extract installable files from Rust release artefacts
-
clampf
Clamped floating-point types
-
transducers
A transducer library for Rust
-
bit-long-vec
Vector with fixed bit sized values stored in long
-
bip_handshake
Common handshaking interface as well as a default handshake implementation
-
foliage
Abstract syntax tree for first-order logic with integer arithmetics
-
rc-dlist-deque
Doubly-linked list based on std::Rc
-
protocoll
clojure inspired protocols for rust collections
-
grammers-tl-types
Rust definitions for Telegram’s API types and functions
-
MBrane
MBrane implementations in Rust
-
roma
roma is a fast routes map/path router
-
type-map
Provides a typemap container with FxHashMap
-
bayesic
A string classification library that focuses on efficiency when dealing with many possible classifications
-
matrix-sdk-common
Collection of common types used in the matrix-sdk
-
digits
Custom “numeric” incrementor without u64 MAX limit in size. Like a score flipper for a custom character set.
-
visit_diff
Efficiently finding differences between data structures
-
pdatastructs
Simple probabilistic data structures
-
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… -
aterm
Implementation of the Annotated Terms data structure
-
break_array
For breaking array indexing
-
vec-collections
Rust collections that are newtype wrappers around vectors
-
ware
Immutable middleware chains
-
ketree
A tree representing a symbolic expression that can be created with Ketos
-
genmap
A simple generational map data structure with no dependencies
-
bk-tree
A Rust BK-tree implementation
-
neolistqueue
A buffer?
-
infinibuffer
A buffer?
-
thermostat
Finite state machine for a thermostat controlling a centralized HVAC system or other heating and/or cooling apparatus
-
empty-box
Allows for
Boxs to have their values moved out and replaced with new values, while reusing the same allocation -
hayami
A simple, general use symbol table
-
loosen_map
Calls a function with self
-
len-trait
Len trait for collectons
-
flats
flattens nested structures into a flat single dimension map
-
csv2struct
Generate Rust struct definitions from CSV
-
tree-cursor
A simple, non-intrusive tree cursor that supports node mutation without Cell/RefCell
-
const-vec
Vec-like data structure with immutable push method
-
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…
-
fral
Functional random-access lists
-
version-lp
a version struct library for use with version comparing, and wildcard resolving
-
id-vec
Simplify Graphs in Rust. Introduces IdVec, which automatically creates Ids for each new object, reusing deleted Ids.
-
atomic-destroy
An value which can be atomically read and destroyed; like an atomic Option
-
hoop
Fixed ring buffer that allows non-consuming iteration both ways
-
rabbot-plugin
Compiler plugin for Rabbot
-
fitnesstrax-lib
Library for managing fitness time series data
-
map1
@ErichDonGubler’s fancy template for new Rust projects
-
afi
Audio & video structures, plus encoder & decoder traits
-
sorted_vector_map
maps and sets backed by sorted vectors
-
data_structure_traits
data structure collection traits
-
immutable-map
An immutable ordered map and set based on weight-balanced tree
-
dimsum
Simple multi-dimensional array library
-
enum-map-derive
Macros 1.1 implementation of #[derive(Enum)]
-
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)
-
rust_fixed_width
library that allows for easier manipulation of fixed width files allowing for the ability to name fields and such using specs
-
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. -
pyrpds
Python Wrapper for Rust Persistent Data Structures
-
map-trait
Generic Map trait
-
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 -
bitstring
Bitstring traits and implementations
-
artsy
ART Tree data structure library
-
par-array-init
Convenience functions for initializing arrays in parallel
-
tirocks
Place holder for yet another rust wrapper for rocksdb
-
fux_kdtree
K-dimensional tree implemented in Rust for fast NN querying
-
bytes-expand
Types and traits for working with bytes
-
type-info
Meta type information and type reflection at compile-time and runtime
-
transit_model_collection
Manage collection of objects
-
shellexpand
Shell-like expansions in strings
-
isolanguage-1
ISO 639-1 library with optional Serde support
-
closures
Abstraction for seperating code and state in closures
-
decision_table
Data structure for storing and validating decision tables
-
vec_box
A single macro to create a vec of boxed elements, for trait objects
-
kailua_env
Basic environments for Kailua
-
rate_limit
A simple token-bucket style rate limiter
-
dashmap-shard
A Rust port of Google’s SwissTable hash map
-
marked-yaml
A simplified YAML structure with provenance spans
-
scalable_cuckoo_filter
A variant of Cuckoo Filter whose size automatically scales as necessary
-
graphrepresentations
A crate providing efficient abstract implementations of different graph representations
-
rtrees
A Bunch of completely safe augmented tree implementation in rust
-
ibuilder_derive
Interactive builder for Rust types
-
iodyn
An incremental collections library making use of Adapton
-
trie_lib
A small library implementing a trie data structure
-
consume
Memory order consume for when it’s known that the compiler can’t elide the dependency
-
lsp_msg_internal
Definitions used for testing lsp_msg_derive
-
itc
Interval Tree Clocks as described in the itc2008 paper
-
bitsets
BitSet implementations: Dense, Compressed, Memory-Mapped, and Roaring
-
aspen
A behavior tree implementation in Rust
-
few
A generalization of
std::Optionallowing for up to two optional values -
stable-skiplist
Skiplist implementation in rust, providing fast insertion and removal. A normal skiplist is implemented, as well as an ordered skiplist and a skipmap. This is modified to work on stable Rust 1.9.0.
-
redbpf-probes
eBPF probe-related types for redbpf
-
strchunk
A utility library for working with UTF-8 text in I/O
-
rahashmap
Fork of standard library HashMap with additional functionality
-
movable
A structure whose internal content can be moved out immutably
-
bytes32
Used to create a custom type for 32-bit-wide byte arrays. Used for Drops of Diamond (more information about DoD is available at https://github.com/Drops-of-Diamond/Diamond-drops).
-
snake_case
SnakeCase is a String-like type that can only contain valid non-empty snake_case
-
mrslac
A Rust crate with sparse matrix data structures
-
evobox
A pointer type which allows for safe transformations of its content without reallocation
-
bailamos
Simple notification manager
-
binary-tree
Collection of Binary Tree data structures and algorithms
-
arr
A heap based fixed-sized array
-
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
-
swimmer
Thread-safe object pool type
-
hashbag
An unordered multiset implementation using a hash bag
-
const-buffer
A fixed-capacity memory buffer allocated on the stack using const generics
-
map_in_place
Reuse the memory of a Vec, Box<[T]> or Box when mapping the elements if possible
-
vec_saver
Rust Vector Saving Library
-
untis
Rust library to access the webuntis jsonrpc
-
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.
-
linear-map
A map implemented by searching linearly in a vector
-
multiarray
Small Rust library for handling multi-dimensional data
-
handler_map
Map from types to functions that receive them
-
eclectic
Experimental collection traits
-
rundo
Rundo is a redo / undo library for rust which can auto generate undo op. Below is an example to use Rundo.
-
compacts
compact data structures
-
svec
A utility for Dart-style list in Rust
-
chickenwire
A library for representing and manipulating hexagonal grids
-
pod
Plain Old Data (POD) encoding and I/O
-
thunk
Primitives for generic lazy evaluation in Rust. This crate requires nightly for
untagged_unions. -
synctree
Thread-safe tree data structure
-
any_key
Dynamically typed keys for associative arrays
-
ordered_iter
Ordered iterators
-
deoxy-core
Core utilities for deoxy
-
esc-seq
Library to print simple escape sequences
-
street_index
street_index is a small utility crate for working with road name / street indexing for cartographic purposes
-
vecfile
A Vec-type collection that sits in a file vs in memory
-
byte_trie
A compressed trie based on bytes with some weird child node bucket sizes
-
courgette
Colour manipulation/conversion library
-
nbits_vec
Small bits value (e.g. 1,2.. bits) vector implementation.
-
take-some
A simple library that provides a way to obtain some value from various collections
-
slice_as_array
Cast slices to arrays
-
ring_queue
A double-ended queue implemented using a vector that reuses space after elements are removed
-
statiki
Static friendly data structures
-
collectioner
collection helper
-
terms
Tree terms and patterns data structures
-
mat3
matrix 3x3
-
topia
a simple tree library
-
abbrev-tree
highly inefficient data structure for text completion
-
arrav
Sentinel-based heapless vector
-
blockbuffers
Blockbuffers is a serialization tool which builds strict Flatbuffers binaries
-
easy_strings
Ergonomic, garbage collected strings for Rust
-
smt_map
A uint-to-uint map backed by Sparse Merkle Tree (SMT), which supports generating Merkle Proofs of key-values
-
guzzle-derive
The derive macro for guzzle, please use that crate not this one
-
insert_multiple
insert multiple items into a stream in reasonable runtime
-
array-ops
Automatic method implementations for array data types
-
sprs-ldl
Sparse cholesky factorization
-
polymap
A map containing varying types of value
-
ensured_bufreader
A Bufreader ensures N bytes in buffer
-
bigint-base10
Experimental API for dealing with big integers in base-ten
-
leonardo-heap
Heap structure supporting fast in-place partial sorting
-
halo
elm inspired state manager in rust
-
htable
A simple to use and extenable table that can hold hold many different types at once
-
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 -
trie_tree
basic trie tree for 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…
-
fricgan
A simple crate for performing basic input and output on bytes
-
chain-map
A chain of maps with a single view into the aggregated values
-
lumberjack-utils
Read and modify constituency trees
-
hamt-rs
A Hash Array Mapped Trie implementation based on the Ideal Hash Trees paper by Phil Bagwell
-
arenavec
An arena backed implementation of vectors and related types
-
linebuffer
ringbuffer for dynamic sized u8-elements
-
graphsearch
A simple graph search and representation library
-
dot_json
Tools for dot map representations of serde_json Maps
-
slice_mip
Mutate a slice in place with a map function
-
reflection
reflects of type’s fields’ names and their type names in a hierarchical tree
-
gcollections
Generic traits over Rust collections library
-
fix
Fixed-point number types
-
bit-array
A compile time sized array of bits
-
id-set
A bitset implementation that stores data on the stack for small sizes
-
const-arrayvec
A vec-like type backed by an array on the stack
-
plurals
Helps with singular/plural forms, mostly in English
-
fixed-map-derive
A fixed map where storage layout is calculated by a procedural macro. This crate contains the procedural macros
-
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 -
mih-rs
Multi-index hashing (MIH) for neighbor searches on 64-bit codes in the Hamming space
-
scell
A smart container for objects in recursive data structures
-
weighted_random_list
A Vec that allows you to define the weight of each entry and randomly get entries
-
const_enum_map
Get const value from enum handle
-
hashed
A Hashed type you can convert any hashable type into and still do equality checks on
-
weak_static
A macro for declaring lazy droppable statics
-
soak-derive
Custom derive macro for #[derive(Columns)]
-
ami
Useful data structures that are not in the standard library
-
louds
LOUDS implementation for Rust
-
relational_types
Manage relations between objects
-
medianheap
A median heap for keeping track of a running median
-
thincollections
Alternative implementations for vector, map and set that are faster/smaller for some use cases
-
id-map
Data structure of values indexed by IDs
-
semver-store
An HashMap structure that uses semver strings as keys
-
higher-cat
Functors, Applicatives, Monads and other bad ideas
-
aiowrap
Small helpers for using AsyncRead/AsyncWrite
-
zerobuf
A growable chunk of zeroed memory
-
heatmap
time-series of histograms with precision guarantees
-
read-write-pipe
A trait for objects implementing Write, to write all content from a Read object
-
immutable-seq
Immutable sequence data structure
-
holyhashmap
A hash map with stable indices
-
big_s
Rust’s missing
Stringliteral -
bit_range
A small library for getting bits and ranges of bits from byte collections
-
r-graph
Modular Graph library for Rust-lang
-
sized-vec
Type level sized vectors
-
rbtset
A set based on a RB-Tree for efficient operations
-
tree
An ordered map and set based on a binary search tree
-
rudy
Judy array implementation in pure Rust
-
takeable
Container type that allows for temporarily moving out of the container
-
suffix-array-rust
A simple library that can be used to perform suffix array operations
-
dense_bitset
A variably sized, heap allocated, dense bitset implemented using no
unsafecode -
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
-
index_key
lexicographic sort order encoding
-
mat2
matrix 2x2
-
dpc-simplemap
Simple map with default value and compacting
-
modular-bitfield-impl
Bitfields for structs that allow for modular use of enums
-
quantized-density-fields
Rust implementation of Quantized Density Fields data structure
-
huji
Simple graph package still under production
-
slicevec
A vector using an external slice as backing storage
-
sbf
Spatial Bloom Filter, a probabilistic data structure that maps elements of a space to indexed disjoint subsets of that space
-
glowygraph
A library for drawing glowy graphs
-
golomb-coded-set
An implementation of BIP158 Golomb-Coded Set data structure
-
jyx
Command line tool for manipulating data structures
-
flashtext
Rust implementation of flashtext algorithm to search and replace keywords in given text
-
sliding-window-aggregation
Sliding window aggregation
-
darts
A double array trie, A Forward Maximum Matching Searcher
-
bintrie
A performant binary trie data structure that doesnt store data or keys
-
baggie
Container for storing mixed / heterogeneous values in a common structure
-
ctrs
Rust implementations and notes on category theory
-
col_proc_macros
A bunch of procedural macros for declare collections of various kinds from their contents as fast as possible
-
graph_match
A library for matching patterns in directed graphs
-
compacts-dict
succinct dictionary
-
tensor
Currently, a sketch of a Tensor library
-
range-collections
Sets and maps of ranges, backed by smallvec
-
higher_order_point
An experimental higher order data structure for 3D points
-
bounded-vec-deque
A double-ended queue|ringbuffer with an upper bound on its length
-
typescript-definitions-derive-ufo-patch
serde support for exporting Typescript definitions
-
mori_parallel
A parallel orientation library built around commonly used orientation representations used in crystallography and engineering applications. It contains conversion, rotation, and data…
-
immutable_arena
An arena for immutable-once-built objects with possibly cyclic references
-
skew-heap
A priority queue based on a skew heap
-
vec_file
A Vec-type collection that sits in a file vs in memory
-
discrimination-tree
discrimination tree term indexing
-
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…
-
mwmatching
Maximum-Weight Matching: Compute a maximum-weighted matching in the general undirected weighted graph given by ‘edges’
-
compare
Experimental comparators for collections to be generic over
-
hex2d-dpcext
dpc’s hacky extensions to hex2d-rs library
-
push-trait
Push trait for collectons
-
thin_str
A string type that’s smaller than
Box<str>or String -
bitset-fixed
Bitset for DP
-
bitset
A simple bitset library like C++ (interface adapted)
-
fixed_circular_buffer
A queue (the abstract data structure) implemented using a fixed size circular buffer
-
gvec
Very simple implementation of generational indexing for vectors written in Rust
-
typescript-definitions-derive
serde support for exporting Typescript definitions
-
comparator
A Java-like Comparator type
-
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
static_map
A static hashmap implementation, based on the Round-Robin hashing algorithm found in rustc
-
coll
Some basic (persistent) collections
-
bitarray-set
A set of bits backed by bit-array
-
vertree
A persistent trie where each node is typed and versioned
-
suffix_tree
Suffix trees
-
maybe_utf8
Byte container optionally encoded as UTF-8
-
trashmap
A HashMap and HashSet that operate directly on hashes instead of keys, avoiding rehashing
-
ascii_num
digit to ascii numbers
-
appendix
Append-only, on-disk key-value index
-
judy-wrap
Judy arrays FFI mid-level binding
-
svec_macro
A utility for Dart-style list in Rust