arrayref
Macros to take array references of slices
diff
An LCS based slice and string diffing implementation
array-bytes
A collection of Array/Bytes/Hex utilities with full No-STD compatibility
typed-index-collections
Typed index version of Rust slice and Vec containers
aligned-vec
Aligned vector and box containers
mitsein
Strongly typed APIs for non-empty collections, slices, and iterators
arrow-array
Array abstractions for Apache Arrow
slice-command
slice is a command-line tool that allows you to slice the contents of a file using syntax similar to Python's slice notation
outref
Out reference
link-section
Link-time initialized slices for Rust, with full support for Linux, macOS, Windows, WASM and many more platforms
beef
More compact Cow
dyn-stack
Dynamic stack wrapper for unsized allocations
slice-dst
Slice-based custom DSTs
slice-group-by
Iterators over groups in slices and strs
slicec
The Slice parser and other core components for Slice compilers
as-slice
AsSliceandAsMutSlicetraits
str-macro
The str!() macro, similar to vec![] but for strings
hex-display
Display impl for byte slices which provides a hexdump
out
fast min and max functionality for collections
capwriter
Fast saving and loading with annotating cap for vector and slice
csgrs
Constructive solid geometry (CSG) on meshes using BSP trees in Rust
substring
method for string types
nunny
the definitive non-empty slice/array/vec library for Rust
display-more
helper to display various types
ord_subset
Tools for working with the Ord subset of certain PartialOrd types, like floats
value-traits
By-value slices and iterators
intern-mint
byte slice interning
vicut
A CLI text processor that uses Vim commands to transform text and extract fields
non-empty-slice
Non-empty slices
sync-cell-slice
Cells and slices that are accessible from multiple threads
slice-diff-patch
providing utility functions for diff and patch of slices
second-stack
A fast allocator for short-lived slices and large values
shuffle
various shuffling algorithms over slices
scattered-collect
Link-time collections for Rust (distributed slices, registries)
par_slice
Slices that may be accessed from multiple threads with different levels of safety
odds
ends — collection miscellania. Extra functionality for slices (
.find(),RevSlice), strings and other things. Things in odds may move to more appropriate crates if we find them.
slice_trait
A generic trait for any slice, with item as a type parameter
tailvec
Split Vec to mutable slice and TailVec, the TailVec can push or pop etc
abao
BLAKE3 verified streaming
slice_map
A generic container to store a single type of data into unevenly sized slices
fixed-slice-vec
FixedSliceVecis a dynamic length Vec with runtime-determined maximum capacity backed by a slice
indices
macros and methods for safely retrieving multiple mutable elements from a mutable slice, addressing scenarios where slice elements would typically require
RefCellorCell(interior mutability approach)
expanding_slice_rb
A self-expanding ring buffer similar to VecDeque optimized for working with slices of data
rav1d-disjoint-mut
A provably safe abstraction for concurrent disjoint mutable access to contiguous storage
xsv
A high performance CSV command line toolkit
dyn-slice
&[dyn Trait] implementation, inspired by a Reddit thread
read_until_slice
AsyncBufRead::read_until extension to take a slice as a delimiter instead of a single u8
fast-slice-utils
Highly optimized slice utilities using SIMD instructions when available
unslice-dst
Fancy slice-like DST support
matrix-slice
Safe abstractions for two-dimensional slices
arena-arc
A fast, chunk-based allocator for building contiguous slices and sharing them via handles
nibble_vec
Vector data-structure for half-byte values
purrdf-slice
PurRDF native slice catalog: manifest-based discovery, typed artifact inventory, content-addressed IDs
concat-string
macros for concatenating string slices into owned strings
fileslice
Slices of files
mut-str
A toolkit for working with mutable string slices (&mut str)
uniques
Analyze items in a slice and calculate the unique, first, duplicate, and subsequent items and their indices
unsafe_cell_slice
A microlibrary for creating multiple mutable references to a slice
strslice
that provides zero copy string iterators for working with string slices. The library offers iterators similar to standard Rust string methods
streplace
A tiny library for matching and replacing in strings and slices with user-defined functions
buthash
Fast hash for structs, slices and integers
sdset
Set operations for sorted and deduplicated slices. Much performances! Such Wow!
sentinel
A sentinel-terminated slice library
slice-of-array
Extension traits for casting between slices and slices of arrays. (&[T] <-> &[[T; n]])
cargo-slicer
Speed up Rust release builds by skipping codegen for unreachable functions and processing of other skippable items
rust_string_utils
String utilities for rust based on org.apache.commons.lang3
ghost_slice
Permission-carrying Indices and some collections that support them
index_permute
permuting a slice which elements are not Clone or Copy in Rust
split_slice
accessing (&[T], &[T]) as if it were a single slice
imstr
Cheaply clonable and slicable immutable strings
multiptr
Maximally convenient and efficient wrapper around a pointer to an element within a slice
borogove
A personal parsing library
k-combinations
Efficient iterator over k-element combinations of a slice
partition
slices in-place by a predicate
byte-parser
Parse a str or a slice with a function style
ezstr
A String wrapper supporting negative indexing with grapheme indexing for slices and Regex::find_iter and Regex::find
xslice
Slice representation using relative extents instead of absolute pointers
cow2
Like Cow<B>, but B is covariant
poly_it
A no-std library for manipulating polynomials with slice support and minimal allocation
byteorder_slice
Byteorder like crate for &[u8]
zip-to-irmf
Convert zipped image slices to IRMF shaders
heapify
Convenience functions to turn slices into max-heaps
stride
A strided slice type
slice_ops
A selection of useful slice operations
az-array
Array and slice utility extensions
generic_levenshtein
Generic and fast implementation of the Levenshtein distance
array-plus-extra
An array type that holds N+EXTRA elements with const generic parameters, providing safe slice access to contiguous memory
hex-slice
Extends the std::fmt::*Hex traits to slices
simple-dst
Traits for allocating and using custom DSTs
superslice
Extensions for slices
generic-vec
a vector implementation that can be used in
no_stdenvioronments
stringslice
A collection of methods to slice strings based on character indices rather than bytes
bump-into
a no_std bump allocator sourcing space from a user-provided slice
advancer
Helper for advancing over mutable slices
admissibility-kernel
Deterministic context slicing with cryptographic admissibility verification for conversation DAGs
metatype
Helper methods to determine whether a type is
TraitObject,SliceorConcrete, and work with them respectively
slicey
Ways to associate data with parts of a string
indexland
Rust Collections with Newtype Indices
index_many
A proof of concept for indexing an slice at multiple locations at once
unchecked-index
Unchecked indexing wrapper using regular index syntax
unsafe_array
Array and slice wrappers with unchecked indexing and uninitialized allocation
str-concat
Concatenate two adjacent string slices
at
Helpers for indexing slices
sapling-minibytes
Shared reference-counted bytes and str with zero-copy slicing support
slice-rc
A variety of reference-counted pointers with better support for slices than std::rc::Rc
not_empty
Slices and vectors that are statically guaranteed to be not empty
pas
strided slice
rsor
Reusable slice of references
populated
Collection types that are guaranteed to be populated (i.e. non-empty). Based on std::collections types.
ve
More compact Vec
static-slicing
enhanced slicing and indexing
vectopop
fast positional popcount for large slices
nslice
Structures for interpreting slices of variable length as arrays
index-fixed
convert slices into arrays using indexes ([T] -> [T;N])
non_empty_continuous
Non-empty continuous collections
strloin
copy on write slices of a string
gang-capability-rosbag-slice
Rosbag slicing capability — captures time-bounded slices of ROS 2 bag data and publishes them content-addressed
slice-utils
A collection of slice utils, like itertools
readfilez
Quite fast file to slice reading
fancy_slice
that provides reflection for tree structures
slice-copy
Go style copying for slices
quartet
Nibble (quartet, u4) slices
slyce
Python-like slices
is_slice
Macro to answer the question: is it a slice?
set_slice
A macro for assigning values to slices
blest-bfs-rs
BLEST: Blazingly Efficient BFS using GPU Compute Shaders
small_iter
A 3-pointer iterator that moves out of a
Vec<T>orBox<[T]>
splitter
A string and slice splitter library
shiplog-coverage
Date-window slicing utilities used by shiplog adaptive ingestion
paramodel-compiler
Paramodel compiler: turns a TestPlan into an ExecutionPlan via the four-stage reducto-derived pipeline. v0.1 scope covers the trivial case; advanced reductions are follow-up slices.
select_indices
Iterators for taking multiple shared/exclusive references from a slice
dairy
A more compact, user friendly clone-on-write smart pointer
reorder
slice based on a slice of indices
simdsplit
Experimental byte string splitter using Portable SIMD
frontmatter
A Fairly Trivial Wrapper for yaml-rust to Extract Frontmatter from a String Slice
csv-guillotine
CSV's often have metadata at top before data headers. This removes it.
validated-slice
Helper macros to implement std traits for custom validated slice types
err-rs
Error level management
thin-slice
An owned slice that packs the slice storage into a single word when possible
vecstasy
SIMD-enabled floating-point operations on vectors
hexify
Format hex
dst-container
Containers for DST objects
bevy_nine_slice_ui
A nine slice/patch texture plugin for bevy ui nodes, works in wasm
raw-slicee
Generic low-level raw slice types
bitcoin_slices
Parse Bitcoin objects without allocations
vec-dimension-shift
N-Dimension shift features for Vec<T>
astr
A const lenght stack str
dgrambuf
A fixed capacity ring buffer for datagrams (byte slices)
bswap
byte-swapping integers, pointers, and slices
slice_search
A collection of algorithms for searching within slices
sashay
Type-erased and lifetime-erased references and slices
slice_math
A selection of useful math operations on slices
sliced
A segmented vector for iterating over slices
subslice-to-array
Extract fixed-range subslices as arrays, with compile-time checks
into_index
Helper traits allowing indexing into vectors and similar types by other types than
usize
has-some
The opposite of is_empty (and is_empty for filters)
soapy-shared
Custom types used by soapy macros
slicestring
slicing Strings
io-window
Seekable I/O adapter that limits operations to a byte range
dyn_struct2
Construct dynamically sized types safely. Supports arbitrary unsized types, not just slices
resize-slice
Shrink slice references
safebit
Safe and secure bit access into integer types
rc-slice2
Reference-counted slices with easy subdivision
no_vec
modifying sized arrays
sub-array
Extract a sub-array out of an array
write-only
References/slices that provide write-access, but no read-access
slice-pool
using a slice as a memory pool
loaf
Why have a slice when you can have a loaf?
rawslice
Reimplementation of the slice iterators, with extra features. For example creation from raw pointers and start, end pointer accessors.
vecfx
Extra batteries for a vec of floats
utf8_slice
Lightweight UTF8 Slice Utilities
str_id
Interns str slices, giving you back an ID value
libpermute
A
no_stdcompatible library that provides a function to permute the items of a slice
slice-ext
Useful extensions to slices and iterable types
const-sub-array
Extract a fixed size sub-array out of an array with complie-time length and offset checks
simd_iter
iterating over slices as
Simdvectors
slice
slices for streams implementing
std::io::readandstd::io::write
easy-ffi-wrapper
Types and utilities to enable writing C FFI wrappers easily
divide_slice
methods to divide a slice into portions of same size
typeslice
type-level slices
wasefire-slice-cell
Slice with dynamic borrow checking
maxlen
Length-bounded string and slice/vector
tranche
Tranches are an alternative to slices
gnaw
Conveniently chip small pieces off a slice or
strto use elsewhere
rivulet
Asynchronous contiguous-memory streams
bin-pool
A small crate for interning binary slices
autobahn-hash
HighwayHash, a fast and strong SIMD hash function
boxed-slice
An easy abstraction around boxed slices sized by a const generic
ordslice
Extensions for ordered slices
byte_consumer
An object that can consume memory slices without copying the slice. Can be useful when processing raw binary structured data at a low level such us when reading the contents of a file that has stored binary data
wgdiff
LCS-based diff algorithm
slicefields
Allows for data structures whose members are sub byte aligned (e.g. a one bit alignment)
struct2vec
Rust structure to slice
smallint
optimized arbitrary precision integers
static-bytes
Bytes for embedded devices
new_york
Home of the dollar slice
sealingslice
A mutable slice that can seal its initial part off from mutability, and hand out the sealed parts as immutable references
uvector
access two slices as a single continuous vector
moveslice
A one-function crate to move chunks in a slice around
const-writer
Compile time checked byte manipulations
random-pick
Pick an element from a slice randomly by given weights
holodeque
Array- and slice-backed double-ended queues in 100% safe Rust
offset-views
Create and index offset views of arrays, slices, strings, etc
byteloaf
heap-allocated byte buffer (a 'loaf') via independently owned, accessed, and moved slices
pointer_vec
The PointerVec works same as the std Vec structure except the Vec has a size of 3 usize (pointer, length, capacity). This crate provides a replacement that has a size of 1 pointer.
byte-slice
Byte slice manipulation macros
Try searching with DuckDuckGo.