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