-
hashbrown
A Rust port of Google’s SwissTable hash map
-
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…
-
arrayvec
A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.
-
bytes
Types and traits for working with bytes
-
either
The enum
Eitherwith variantsLeftandRightis a general purpose sum type with two cases -
smallvec
‘Small vector’ optimization: store up to a small number of items on the stack
-
petgraph
Graph data structure library. Provides graph types and graph algorithms.
-
bitvec
A crate for manipulating memory, bit by bit
-
hdrhistogram
A port of HdrHistogram to Rust
-
ndarray
An n-dimensional array for general elements and for numerics. Lightweight array views and slicing; views support chunking and splitting.
-
slice-deque
A double-ended queue that Deref’s into a slice
-
generic-array
Generic types implementing functionality of arrays
-
arc-swap
Atomically swappable Arc
-
vec_map
A simple map based on a vector for small integer keys
-
bit-vec
A vector of bits
-
linked-hash-map
A HashMap wrapper that holds key-value pairs in insertion order
-
fixedbitset
FixedBitSet is a simple bitset collection
-
scroll
A suite of powerful, extensible, generic, endian-aware Read/Write traits for byte buffers
-
bit-set
A set of bits
-
id_tree
A library for creating and modifying Tree structures
-
heapless
staticfriendly data structures that don’t require dynamic memory allocation -
bimap
A fast two-way bijective map implementation
-
c_vec
Structures to wrap C arrays
-
radix_trie
Generic radix trie data-structure
-
rpds
Persistent data structures with structural sharing
-
crdts
Practical serializable thoroughly tested CRDTs (ORSWOT, counters, LWW) ported from riak_dt
-
predicates
An implementation of boolean-valued predicate functions
-
string-interner
An efficient string interning data structure with minimal memory-footprint and fast access to the underlying contents
-
sequence_trie
Trie-like data-structure for storing sequences of values
-
starling
This tree structure is a binary merkle tree with branch compression via split indexes
-
generator
Stackfull Generator Library in Rust
-
suffix
Suffix arrays
-
smallbitvec
A bit vector optimized for size and inline storage
-
hibitset
Hierarchical bit set structure
-
im
Immutable collection datatypes
-
indextree
Arena based tree structure by using indices instead of reference counted pointers
-
enum-map
A map with C-like enum keys represented internally as an array
-
sized-chunks
Efficient sized chunk datatypes
-
string
A UTF-8 encoded string with configurable byte storage
-
enumset
A library for creating compact sets of enums
-
optional
This crate supplies a number of Option-like primitive types
-
fraction
Lossless fractions and decimals; drop-in float replacement
-
rstar
R*-tree library for the rust ecosystem
-
redo
Provides undo-redo functionality with static dispatch and manual command merging
-
undo
Provides undo-redo functionality with dynamic dispatch and automatic command merging
-
stackvector
StackVec: vector-like facade for stack-allocated arrays
-
num
A collection of numeric types and traits for Rust, including bigint, complex, rational, range iterators, generic integers, and more!
-
vob
Vector of Bits with Vec-like API and usize backing storage
-
typescript-definitions
serde support for exporting Typescript definitions
-
im-rc
Immutable collection datatypes (the fast but not thread safe version)
-
histogram
histogram storage and percentile metrics with precision guarentees
-
rust_decimal_macros
Shorthand macros to assist creating Decimal types
-
pagetable
simple wait-free two-level pagetable with 2mb pages
-
enum-ordinalize
This crates provides
create_ordinalized_enummacro to let enums can not only get its variants’ ordinal but also be constructed from an ordinal -
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
roaring
http://roaringbitmap.org : A better compressed bitset - pure Rust implementation
-
intrusive-collections
Intrusive collections for Rust (linked list and red-black tree)
-
trk-io
TrackVis (*.trk) reader and writer
-
ego-tree
Vec-backed ID-tree
-
vec1
a std Vec wrapper assuring that it has at least 1 element
-
rusty_ulid
Rust ULID (Universally Unique Lexicographically Sortable Identifier) generation and processing
-
min-max-heap
An efficient, double-ended priority queue
-
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. -
adapton
programming abstractions for general-purpose incremental computations
-
bitlab
Extracting a range of bits from a binary data source
-
array-init
Safe wrapper for initializing fixed-size arrays
-
ndarray-stats
Statistical routines for ArrayBase, the n-dimensional array data structure provided by ndarray
-
trees
General purpose tree data structures
-
flat-tree
Rust module for encoding/decoding varints that doesn’t do any IO. Inspired by the Node.js varint module
-
qp-trie
An idiomatic and fast QP-trie implementation in pure Rust, written with an emphasis on safety
-
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
-
bcc
Idiomatic Rust bindings for BPF Compiler Collection (BCC)
-
rc-u8-reader
A tiny implement for reading
u8data from a reference counted instance -
patricia_tree
Memory-efficient data structures based on patricia tree
-
tst
Ternary search trie collection in rust with similar API to std::collections as it possible
-
merkle
Merkle tree implementation with support for generation of inclusion proofs
-
priority-queue
A Priority Queue implemented as a heap with a function to efficiently change the priority of an item
-
binary-heap-plus
Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps
-
csv2json
Converts CSVs into JSON documents
-
fwdlist
A simply linked (forward) list
-
blender-armature
Serialize / deserialize Blender armatures
-
queues
Efficient FIFO Queue data structures
-
splay_tree
Splay Tree based Data Structures (map, set, heap)
-
hash-rings
Implementations of various hash rings
-
fp_rust
Implement fp features for Rust
-
rexsgdata
Scatter-Gather Data Descriptors
-
voluntary-servitude
Thread-safe appendable list with lock-free iterator
-
tiny_ecs
A tiny ECS that tries to avoid unnecessary copy/clones
-
treebitmap
Fast IPv4/IPv6 lookup trie
-
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.
-
enum-map-derive
Macros 1.1 implementation of #[derive(Enum)]
-
tinystr
A small ASCII-only bounded length string representation
-
kdtree
K-dimensional tree in Rust for fast geospatial indexing and lookup
-
linear-map
A map implemented by searching linearly in a vector
-
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…
-
bv
Bit-vectors and bit-slices
-
bounded-spsc-queue
A bounded SPSC queue
-
array-macro
Array multiple elements constructor syntax
-
treez
A collection of useful tree data structures
-
rc-writer
A tiny implement for writing data to a reference counted instance
-
rle_vec
A vector like struct that stores data as runs of identical values. Useful for storing sparse data.
-
treeflection_derive
#[derive(Node)] macro for the Treeflection library
-
compt
A complete binary tree visitor library
-
ordsearch
A data structure for efficient lower-bound lookups
-
succinct_rs
Succinct Data Structures library for Rust
-
abi_stable_shared
Implementation detail of abi_stable
-
unstructured
Generic types for unstructured data
-
exonum-merkledb
Persistent storage implementation based on RocksDB which provides APIs to work with Merkelized data structures
-
path-tree
Path-based routing tree
-
fixed-map
A fixed map where storage layout is calculated by a procedural macro
-
user-error
Simple error type that display in a clear and beautiful manner to the user of a CLI application
-
sharded-slab
A lock-free concurrent slab
-
polytype
A Hindley-Milner polymorphic typing system
-
nanoset-py
A memory-optimized wrapper for Python sets likely to be empty
-
cmdtree
(Rust) commands tree
-
onigiri
This crate is a tool of handling chars
-
slab_tree
A vec-backed tree structure with tree-specific generational indexes
-
succinct
Succinct data structures for Rust
-
circular-queue
A circular buffer-like queue
-
data_reader
A data loading library for data scientist
-
merkle-cbt
A library for generating efficient Merkle tree and combined Merkle proof based on complete binary tree
-
molecule
Rust bindings for molecule
-
fid
FID (Fully Indexable Dictionary) implementation for Rust
-
defaultmap
Provides a HashMap with an automatic default for missing keys
-
simd_aligned
Safe and fast SIMD-aligned data structures with easy and transparent ‘flat’ access
-
index_vec
Newtype-style helpers for
Vecandusize -
llvm-ir
LLVM IR in natural Rust data structures
-
cactus
Immutable parent pointer tree
-
histogram-sampler
Sampling from a distribution given by a histogram
-
stash
An amortized
O(1)table for cases where you don’t need to choose the keys and want something faster than a HashTable -
enum-set
A structure for holding a set of enum variants
-
enum_vec
Efficiently store a vector of enum variants as a packed n-bit vec
-
ternary-tree
A Rust implementation of Ternary Search Trees, with no unsafe blocks
-
staticvec
Implements a fixed-capacity stack-allocated Vec alternative backed by an array, using const generics
-
cidr-utils
This crate provides data structures and functions to deal with IPv4 CIDRs and IPv6 CIDRs
-
numas
numas library is implementation of multidimensional array for efficient computing
-
fst-regex
Search finite state transducers with regular expression
-
packedvec
Store vectors of integers efficiently
-
rahashmap
Fork of standard library HashMap with additional functionality
-
numeric-array
Wrapper around generic-array that adds efficient numeric trait implementations
-
base_custom
Use any characters as your own numeric base and convert to and from decimal
-
tri-mesh
A triangle mesh data structure including basic operations
-
range
A library for range addressing
-
usher
Parameterized routing for generic resources in Rust
-
galemu
Provides a workaround for generic associated types (GAT) limited to lifetimes (GAL)
-
appro-eq
Approximately equal traits and assertion
-
plain
A small Rust library that allows users to reinterpret data of certain types safely
-
hash_hasher
A hasher which is designed to work with already-hashed or hash-like data
-
disjoint-sets
Three union-find implementations
-
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
-
progress-streams
Progress callbacks for types which implement Read/Write
-
arraystring
Fixed capacity stack based generic string
-
modular-bitfield
Bitfields for structs that allow for modular use of enums
-
smart-hash
partial queries in HashSets, the traits
-
fingertrees
Immutable persisten finger trees
-
anymap
A safe and convenient store for one value of each type
-
arccstr
Thread-safe, reference-counted null-terminated immutable strings
-
dashmap-shard
A Rust port of Google’s SwissTable hash map
-
cedarwood
efficiently-updatable double-array trie in Rust (ported from cedar)
-
data_structure_traits
data structure collection traits
-
wavelet-matrix
A wavelet matrix implementation. Supports various near-O(1) queries on large number of symbols or integers.
-
heaparray
Flexible support for dynamically-sized types, using heap-allocated array of structs
-
libnv
Safe and rustic wrapper around libnv-sys
-
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.
-
id-vec
Simplify Graphs in Rust. Introduces IdVec, which automatically creates Ids for each new object, reusing deleted Ids.
-
nibble_vec
Vector data-structure for half-byte values
-
elsa
Append-only collections for Rust where borrows to entries can outlive insertions
-
mucell
A cell with the ability to mutate the value through an immutable reference when safe
-
by_address
Wrapper for comparing and hashing pointers by address
-
idcontain
Generational (or tagged) ID-based containers
-
inspector
General purpose inspection for popular data structures
-
avm1-tree
Abstract Syntax Tree (AST) for AVM1
-
binn-ir
An implementation of Binn - https://github.com/liteserver/binn
-
dinotree
An aabb space partitioning 2d tree data structure
-
ami
Useful data structures that are not in the standard library
-
intmap
Specialized HashMap for u64 keys
-
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…
-
afi
Audio & video structures, plus encoder & decoder traits
-
incremental-topo
Data structure to maintain an incremental topological ordering over a collection of values
-
isomorphism
2 directional hashmaps
-
bucket_queue
A Bucket Queue data structure that can be used as a Priority Queue
-
graphlib
Graphlib is a simple and powerful rust library for the graph data-structure
-
linked_hash_set
HashSet with insertion ordering
-
contest-algorithms
Common algorithms and data structures for programming contests
-
treeflection
A library that provides reflection for tree structures
-
panoradix
A generic map and a set, both backed by a Radix tree
-
string-wrapper
A possibly-stack-allocated string with generic bytes storage
-
sparsevec
Compress vectors using row displacement
-
rust-fsm
A framework for building finite state machines in Rust
-
predicates-tree
Render boolean-valued predicate functions results as a tree
-
smart-hash-derive
partial queries in HashSets, the traits
-
orderbook
Orderbook for Rust
-
debt64
An implementation of Base64 - https://en.wikipedia.org/wiki/Base64
-
threshold
Threshold data structures
-
shellexpand
Shell-like expansions in strings
-
jyx
Command line tool for manipulating data structures
-
slice-of-array
Extension traits for casting between slices and slices of arrays. (&[T] <-> &[[T; n]])
-
vec-tree
A safe tree using an arena allocator that allows deletion without suffering from the ABA problem by using generational indices
-
radix-tree
A radix tree implementation for router, path search
-
free-ranges
An efficient data structure for keeping track of indices which are either free or not
-
transit_model_collection
Manage collection of objects
-
vec3
vec3
-
arr_macro
Initialize arrays with ease!
-
normalize-line-endings
Takes an iterator over chars and returns a new iterator with all line endings (\r, \n, or \r\n) as \n
-
segment-tree
Quickly perform interval queries or modifications
-
graph-neighbor-matching
Graph similarity score using neighbor matching
-
bytes-expand
Types and traits for working with bytes
-
region_buffer
A growable array allowing for multiple mutable non overlapping regions
-
bipbuffer
A Rust implementation of Simon Cooke’s Bip-Buffer
-
tiled-json-rs
A crate to parse and interact with Tiled editor JSON files
-
mediumvec
Vector types optimized for space, including a 32-bit Vec
-
map_vec
The Map and Set APIs backed by Vec
-
bit-matrix
Library for bit matrices and vectors
-
rustfst
Library for constructing, combining, optimizing, and searching weighted finite-state transducers (FSTs)
-
digits
Custom “numeric” incrementor without u64 MAX limit in size. Like a score flipper for a custom character set.
-
watermark
A simple watermarking set for in-order insertions
-
lending-library
A key-value store that loans full ownership of items
-
extindex
Persisted immutable index
-
modular-bitfield-impl
Bitfields for structs that allow for modular use of enums
-
quantized-density-fields
Rust implementation of Quantized Density Fields data structure
-
non-empty-collections
Non-empty hash-map and hash-set implementations
-
bip_handshake
Common handshaking interface as well as a default handshake implementation
-
soa-vec
A simple Vec-like API over a struct of arrays layout
-
manhattan-tree
A spatial tree which can effiently find closest key to a point, by manhattan distance
-
dinotree_alg
Dinotree algorithms
-
vec2
vec2
-
gtrie
Generic trie implementation with a support of different key and value types
-
backtracking_iterator
A simple implementation of a generic iterator with an item history, capable of backtracking and forgetting
-
bitmaptrie
Bitmapped vector trie (mutable, not persistent). Word-size path-cached indexing into essentially a sparse vector. Requires rust-nightly.
-
moniker
Automatically derive variable binding and alpha equivalence for abstract syntax trees
-
alloc-wg
Attempt of collection several proposals of the allocators-wg
-
docbook-index
Index a DocBook project in to an elasticlunr-compatible JSON index, for use in static-site XHTML sites
-
varuint
Variable length signed and unsigned integer types
-
sea-canal
Identifies patterns in sequences of integers
-
exponential-decay-histogram
A histogram which exponentially weights in favor of recent values
-
graphrepresentations
A crate providing efficient abstract implementations of different graph representations
-
multiset
Multisets/bags
-
radix-heap
Fast monotone priority queues
-
queue-file
queue-file is a lightning-fast, transactional, file-based FIFO
-
cast-rs
A collection of types cast for Rust
-
rust_decimal_macro_impls
Shorthand macros to assist creating Decimal types. Do not depend on this directly; use rust_decimal_macros
-
circbuf
A growable circular buffer for working with bytes
-
holyhashmap
A hash map with stable indices
-
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)
-
compare
Experimental comparators for collections to be generic over
-
bip_metainfo
Parsing and building of bittorrent metainfo files
-
bex
A rust library for working with boolean expressions (expression trees, decision diagrams, etc.)
-
semver-store
An HashMap structure that uses semver strings as keys
-
fixed-vec-deque
A fixed-size, zero-allocation circular buffer for Rust
-
tilecoding
Rust implementation of Dr. Richard S. Sutton’s tile coding software.
-
outils
Graph and tree data structure library. Providing utilities which aren’t easily available in Rust.
-
hashlink
HashMap-like containers that hold their key-value pairs in a user controllable order
-
hedge
An index based half-edge mesh implementation
-
trie
An ordered map and set based on a trie
-
hash_ring
Consistent Hashing library for Rust
-
ensure
Ensure target state of an object
-
matmath
Matrix and Vector Math with generic type elements
-
intervaltree
A simple and generic implementation of an immutable interval tree
-
safe-graph
Graph implementation (refactored version of GraphMap from popular crate petgraph)
-
beach_map
Implementation of a slotmap
-
version-lp
a version struct library for use with version comparing, and wildcard resolving
-
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
-
dto_derive
Derive for automatic mapping DTOs to Entities and vice versa
-
apint
Arbitrary precision integers library
-
simple-matrix
A simple generic matrix library
-
sized-vec
Type level sized vectors
-
kailua_env
Basic environments for Kailua
-
bitmaps
Fixed size boolean arrays
-
kserd
Kurt’s Self-Explanatory Rust Data
-
divbuf
Buffer object that can be recursively divided into smaller buffers
-
fungi-lang
Fungi: A typed, functional language for programs that name their cached dependency graphs
-
darts
A double array trie, A Forward Maximum Matching Searcher
-
enum_set2
A bit-set indexed by enum variants
-
atlatl
Double-array tries
-
vec4
vec4
-
rbtree
the rbtree for Rust
-
uid
A crate for the creation of unique IDs
-
lz_diet
An AVL balanced Discrete Interval Encoding Tree
-
handy
A library providing handles and handlemaps
-
sortedvec
a sorted vector that enables quick lookups
-
tiled
A rust crate for loading in maps created by the Tiled editor
-
restor
A dynamic resource storage system in rust
-
visit_diff
Efficiently finding differences between data structures
-
poisson
Poisson-disk distribution generator
-
gridly
A library for managing fixed-size 2D spaces
-
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_utracker
Communication with bittorrent UDP trackers
-
json-parser
JSON parser
-
htmldom_read
HTML reader that parses the code into easy-use tree
-
cl-traits
Provides traits that describe collections
-
egg
An implementation of egraphs
-
space
A library for working with spatial trees and point clouds
-
lhlist
Labeled heterogeneous lists
-
subset-map
A map where the keys are subsets of an initial set of elements
-
restorable
An iterator adapter for saving and restoring iterator state
-
genmap
A simple generational map data structure with no dependencies
-
floating_bar
Representing rational numbers using the floating-bar number type
-
ring_buffer
RingBuffer is a mix of a vector and a queue
-
patricia_router
Radix Tree implementation for Rust
-
simple_ringbuf
Simple Ringbuf is a speedy lightweight fixed-size infinite-use collection optimized for straightforward single threaded use
-
json-trait-rs
Rust interface (aka trait) to deal with objects as they are JSON objects
-
jagged_array
Owned
[[T]]-like 2D array where each row can differ in length -
dependy
Dependency resolution with variable dependency types
-
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
-
guzzle
A derivable trait for consuming key value pairs into structs
-
stomp
A full STOMP 1.2 client implementation. Allows programs to interact with message queueing services like ActiveMQ and RabbitMQ.
-
chickenwire
A library for representing and manipulating hexagonal grids
-
merkle_light
Light merkle tree implementation with SPV support and dependency agnostic
-
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.
-
froop
A functional reactive stream library for rust
-
doubly
Doubly linked lists in rust
-
rust-cedar
efficiently-updatable double-array trie in Rust (ported from cedar)
-
nested_intervals
nested & overlapping interval set functions, overlap, union, etc
-
linebuffer
ringbuffer for dynamic sized u8-elements
-
multi_mut
Methods on HashMap and BTreeMap for safely getting multiple mutable references to the contained values
-
iowrap
Small helpers for using io::Read/io::Write
-
uset
An implementation of a set and a map designed for speed, with unsigned integers as keys
-
ring_queue
A double-ended queue implemented using a vector that reuses space after elements are removed
-
artsy
ART Tree data structure library
-
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 -
uluru
A simple, fast, LRU cache implementation
-
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.
-
dia-i18n
ISO 3166-1 and ISO 639 codes
-
byte_trie
A compressed trie based on bytes with some weird child node bucket sizes
-
checked
Implements a wrapper over the primitive Rust types that better indicates overflow during arithmetic
-
bk-tree
A Rust BK-tree implementation
-
typescript-definitions-derive
serde support for exporting Typescript definitions
-
rbtset
A set based on a RB-Tree for efficient operations
-
vec_arith
Powerful vector/matrix arithmetic library written in Rust
-
safe_index
Type-safe indexes
-
heatmap
time-series of histograms with precision guarantees
-
bailamos
Simple notification manager
-
osproto
Protocol structures for OpenStack API
-
big_enum_set
A library for creating sets of enums with a large number of variants
-
sqa-bounded-spsc-queue
A bounded SPSC queue (temporary version so I can publish sqa-engine)
-
graphsearch
A simple graph search and representation library
-
rc-dlist-deque
Doubly-linked list based on std::Rc
-
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 -
rust-fsm-dsl
Macros for rust-fsm DSL
-
itree
An interactively navigable version of the Linux utility
tree -
flot
Generate HTML documents with embedded charts using Flot
-
snake_case
SnakeCase is a String-like type that can only contain valid non-empty snake_case
-
par-array-init
Convenience functions for initializing arrays in parallel
-
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…
-
ensured_bufreader
A Bufreader ensures N bytes in buffer
-
hex2d
Helper library for working with 2d hex-grid maps
-
baggie
Container for storing mixed / heterogeneous values in a common structure
-
sesstype
An implementation of Multiparty Session Types
-
dockerfile
A Rust library for dynamically generating Dockerfiles
-
gapbuf
Generic gap buffer
-
probabilistic-collections
Various implementations of collections that use randomization to improve on running time or memory, but introduce a certain amount of error
-
street_index
street_index is a small utility crate for working with road name / street indexing for cartographic purposes
-
cons-list
An immutable singly-linked list, as seen in basically every functional language
-
ascii_num
digit to ascii numbers
-
terms
Tree terms and patterns data structures
-
gvec
Very simple implementation of generational indexing for vectors written in Rust
-
intervallum
Generic interval and interval set library
-
fux_kdtree
K-dimensional tree implemented in Rust for fast NN querying
-
cl-traits-derive
Derives for cl-traits
-
sum
General-purpose sum types
-
const-vec
Vec-like data structure with immutable push method
-
depot
A (disk) persistent queue library
-
generic-arrayvec
Interop between the arrayvec and generic_array crates
-
aci_ppm
Encode and decode PNM image files (TODO: so far only PPM)
-
bytes_chain
Zero copy bytes chain based on crate
bytes -
higher-cat
Functors, Applicatives, Monads and other bad ideas
-
rustz
A library for functional programming in Rust
-
ordered_iter
Ordered iterators
-
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
-
eclectic
Experimental collection traits
-
bit-long-vec
Vector with fixed bit sized values stored in long
-
named_tuple
A macro for declaring a
structthat manages a set of fields in atuple -
fral
Functional random-access lists
-
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
-
macaddr
MAC address types
-
pdatastructs
Simple probabilistic data structures
-
bitarray
A compile time sized array of bits
-
gcollections
Generic traits over Rust collections library
-
higher_order_point
An experimental higher order data structure for 3D points
-
tirocks
Place holder for yet another rust wrapper for rocksdb
-
pod
Plain Old Data (POD) encoding and I/O
-
enum_meta
Add metadata to Enum Variants
-
map1
@ErichDonGubler’s fancy template for new Rust projects
-
actions
Software without side-effects. Redo and Undo. Macro’s.
-
iso7816-tlv
tools and utilities for handling TLV data as defined in ISO/IEC 7816-4
-
symtern
Fast general-purpose interners for every use case
-
alg_ds
Algorithms & data structures
-
rtable
Generic Routing Table Library with Radix Tree
-
static_map
A static hashmap implementation, based on the Round-Robin hashing algorithm found in rustc
-
thincollections
Alternative implementations for vector, map and set that are faster/smaller for some use cases
-
csv2struct
Generate Rust struct definitions from CSV
-
bounded-vec-deque
A double-ended queue|ringbuffer with an upper bound on its length
-
telegram-typings
Structs represents telegram bot typings
-
smt_map
A uint-to-uint map backed by Sparse Merkle Tree (SMT), which supports generating Merkle Proofs of key-values
-
lazy-queue
Futures-driven lazy queue processing
-
stack
DSTs and arrays on the stack!
-
partial
Optional monad with fake variant
-
sbral
Fast immutable lists