Docs.rs
  • radix-rust-1.3.0
    • radix-rust 1.3.0
    • Permalink
    • Docs.rs crate page
    • Links
    • Repository
    • crates.io
    • Source
    • Owners
    • radixbot
    • Dependencies
      • hashbrown ^0.13.2 normal optional
      • indexmap ^2.2.5 normal
      • serde ^1.0.144 normal optional
    • Versions
    • 39.55% of the crate is documented
  • Platform
    • i686-pc-windows-msvc
    • i686-unknown-linux-gnu
    • x86_64-apple-darwin
    • x86_64-pc-windows-msvc
    • x86_64-unknown-linux-gnu
  • Feature flags
  • docs.rs
    • About docs.rs
    • Privacy policy
  • Rust
    • Rust website
    • The Book
    • Standard Library API Reference
    • Rust by Example
    • The Cargo Guide
    • Clippy Documentation

Crate radix_rust

radix_rust1.3.0

  • All Items

Crate Items

  • Modules
  • Macros
  • Structs
  • Traits
  • Functions

Crates

  • radix_rust

Crate radix_rust

Source

Modules§

iterators
prelude
Each module should have its own prelude, which:
rust

Macros§

assert_matches
Attempts to be a replacement for assert!(matches!(...)) but with better error messages, and allowing further code on success.
btreemap
btreeset
hashmap
hashset
indexmap
indexset
labelled_resolvable_using_resolvable_impl
labelled_resolvable_with_identity_impl
resolvable_with_identity_impl
resolvable_with_try_into_impls

Structs§

ContextDisplayable

Traits§

ContextualDisplay
This trait is used where context is required to correctly display a value.
ContextualTryFrom
ContextualTryInto
LabelResolver
LabelledResolvable
LabelledResolvable is a marker trait, serving a few purposes:
LabelledResolve
This trait is intended to be used as an impl argument in helper methods, to accept a wider range of arguments.
LabelledResolveFrom
The inverse trait of LabelledResolve.
Resolvable
Resolvable is a marker trait, mainly to make resolution opt-in and to avoid polluting every type with a resolve method.
Resolve
This trait is intended to be used as an impl argument in helper methods, to accept a wider range of arguments.
ResolveFrom
The inverse trait of Resolve.

Functions§

combine
Combines a u8 with a u8 slice.
copy_u8_array
Copies a slice to a fixed-sized array.

Results

Settings
Help
    struct
    radix_rust::rust::prelude::Vec
    A contiguous growable array type, written as Vec<T>, short …
    module
    radix_rust::rust::vec
    A contiguous growable array type with heap-allocated …
    macro
    radix_rust::rust::vec
    Creates a Vec containing the arguments.
    struct
    radix_rust::rust::collections::VecDeque
    A double-ended queue implemented with a growable ring …
    method
    radix_rust::rust::prelude::Box::read_vectored
    method
    radix_rust::rust::prelude::Arc::read_vectored
    method
    radix_rust::rust::prelude::String::as_mut_vec
    Returns a mutable reference to the contents of this String.
    method
    radix_rust::rust::collections::VecDeque::write_vectored
    method
    radix_rust::rust::prelude::Box::write_vectored
    method
    radix_rust::rust::prelude::Arc::write_vectored
    method
    radix_rust::rust::prelude::Vec::write_vectored
    method
    radix_rust::rust::prelude::Box::is_read_vectored
    method
    radix_rust::rust::prelude::Arc::is_read_vectored
    method
    radix_rust::rust::collections::VecDeque::is_write_vectored
    method
    radix_rust::rust::prelude::Box::is_write_vectored
    method
    radix_rust::rust::prelude::Arc::is_write_vectored
    method
    radix_rust::rust::prelude::Vec::is_write_vectored
    method
    radix_rust::rust::collections::VecDeque::write_all_vectored
    method
    radix_rust::rust::prelude::Box::write_all_vectored
    method
    radix_rust::rust::prelude::Vec::write_all_vectored
    method
    radix_rust::rust::prelude::String::from_utf8_unchecked
    Vec<u8> -> String
    Converts a vector of bytes to a String without checking …
    method
    radix_rust::rust::prelude::String::from_utf8_lossy_owned
    Vec<u8> -> String
    Converts a Vec<u8> to a String, substituting invalid UTF-8 …
    method
    radix_rust::rust::prelude::String::try_from
    Vec<u8> -> Result<String>
    Converts the given Vec<u8> into a String if it contains …
    method
    radix_rust::rust::prelude::Vec::into_iter
    Vec<T, A> ->
    Creates a consuming iterator, that is, one that moves each …
    method
    radix_rust::rust::prelude::Vec::as_ptr
    &Vec<T, A> ->
    Returns a raw pointer to the vector’s buffer, or a …
    method
    radix_rust::rust::prelude::String::from_utf8
    Vec<u8> -> Result<String, FromUtf8Error>
    Converts a vector of bytes to a String.
    method
    radix_rust::rust::prelude::Vec::eq
    &Vec<u8>, &ByteStr -> bool
    method
    radix_rust::rust::prelude::Vec::len
    &Vec<T, A> -> usize
    Returns the number of elements in the vector, also …
    method
    radix_rust::rust::prelude::Cow::from
    Vec<T> -> Cow<[T]>
    Creates an Owned variant of Cow from an owned instance of …
    method
    radix_rust::rust::prelude::Vec::capacity
    &Vec<T, A> -> usize
    Returns the total number of elements the vector can hold …
    method
    radix_rust::rust::prelude::Vec::is_empty
    &Vec<T, A> -> bool
    Returns true if the vector contains no elements.
    method
    radix_rust::rust::prelude::Box::try_from
    Vec<T> -> Result<Box<[T]>>
    Attempts to convert a Vec<T> into a Box<[T; N]>.
    method
    radix_rust::rust::prelude::Vec::as_mut_ptr
    &mut Vec<T, A> ->
    Returns a raw mutable pointer to the vector’s buffer, or …
    method
    radix_rust::rust::prelude::Vec::is_write_vectored
    &Vec<u8, A> -> bool
    method
    radix_rust::rust::prelude::Vec::drop
    &mut Vec<T, A> -> ()
    method
    radix_rust::rust::collections::VecDeque::from
    Vec<T, A> -> VecDeque<T, A>
    Turn a Vec<T> into a VecDeque<T>.
    method
    radix_rust::rust::prelude::Vec::clear
    &mut Vec<T, A> -> ()
    Clears the vector, removing all values.
    method
    radix_rust::rust::prelude::Vec::allocator
    &Vec<T, A> -> &A
    Returns a reference to the underlying allocator.
    method
    radix_rust::rust::prelude::Vec::shrink_to_fit
    &mut Vec<T, A> -> ()
    Shrinks the capacity of the vector as much as possible.
    method
    radix_rust::rust::prelude::Vec::into_raw_parts
    Vec<T, A> -> (usize, usize)
    Decomposes a Vec<T> into its raw components: …
    method
    radix_rust::rust::prelude::Vec::pop
    &mut Vec<T, A> -> Option<T>
    Removes the last element from a vector and returns it, or …
    method
    radix_rust::rust::prelude::Box::from
    Vec<T, A> -> Box<[T], A>
    Converts a vector into a boxed slice.
    method
    radix_rust::rust::prelude::Rc::from
    Vec<T, A> -> Rc<[T], A>
    Allocates a reference-counted slice and moves v’s items …
    method
    radix_rust::rust::prelude::Vec::leak
    Vec<T, A> -> &mut [T]
    Consumes and leaks the Vec, returning a mutable reference …
    method
    radix_rust::rust::prelude::Vec::push
    &mut Vec<T, A>, T -> ()
    Appends an element to the back of a collection.
    method
    radix_rust::rust::prelude::Vec::dedup
    &mut Vec<T, A> -> ()
    Removes consecutive repeated elements in the vector …
    method
    radix_rust::rust::prelude::Vec::deref
    &Vec<T, A> -> &[T]
    method
    radix_rust::rust::prelude::Vec::as_ref
    &Vec<T, A> -> &[T]
    method
    radix_rust::rust::prelude::Vec::borrow
    &Vec<T, A> -> &[T]
    method
    radix_rust::rust::prelude::Vec::remove
    &mut Vec<T, A>, usize -> T
    Removes and returns the element at position index within …
    method
    radix_rust::rust::prelude::Vec::reserve
    &mut Vec<T, A>, usize -> ()
    Reserves capacity for at least additional more elements to …
    method
    radix_rust::rust::prelude::Vec::set_len
    &mut Vec<T, A>, usize -> ()
    Forces the length of the vector to new_len.
    method
    radix_rust::rust::prelude::Vec::as_slice
    &Vec<T, A> -> &[T]
    Extracts a slice containing the entire vector.
    method
    radix_rust::rust::prelude::Vec::truncate
    &mut Vec<T, A>, usize -> ()
    Shortens the vector, keeping the first len elements and …
    method
    radix_rust::rust::prelude::Vec::shrink_to
    &mut Vec<T, A>, usize -> ()
    Shrinks the capacity of the vector with a lower bound.
    method
    radix_rust::rust::prelude::Vec::extend_one
    &mut Vec<T, A>, T -> ()
    method
    radix_rust::rust::prelude::Vec::as_non_null
    &mut Vec<T, A> -> NonNull<T>
    Returns a NonNull pointer to the vector’s buffer, or a …
    method
    radix_rust::rust::prelude::Vec::swap_remove
    &mut Vec<T, A>, usize -> T
    Removes an element from the vector and returns it.
    method
    radix_rust::rust::prelude::Vec::reserve_exact
    &mut Vec<T, A>, usize -> ()
    Reserves the minimum capacity for at least additional more …
    method
    radix_rust::rust::prelude::Vec::extend_reserve
    &mut Vec<T, A>, usize -> ()
    method
    radix_rust::rust::prelude::Vec::into_flattened
    Vec<[T], A> -> Vec<T, A>
    Takes a Vec<[T; N]> and flattens it into a Vec<T>.
    method
    radix_rust::rust::prelude::Vec::into_boxed_slice
    Vec<T, A> -> Box<[T], A>
    Converts the vector into Box<[T]>.
    method
    radix_rust::rust::prelude::Vec::into_raw_parts_with_alloc
    Vec<T, A> -> (usize, usize, A)
    Decomposes a Vec<T> into its raw components: …
    method
    radix_rust::rust::prelude::Arc::from
    Vec<T, A> -> Arc<[T], A>
    Allocates a reference-counted slice and moves v’s items …
    method
    radix_rust::rust::prelude::Vec::flush
    &mut Vec<u8, A> -> Result<(), Error>
    method
    radix_rust::rust::prelude::Vec::insert
    &mut Vec<T, A>, usize, T -> ()
    Inserts an element at position index within the vector, …
    method
    radix_rust::rust::prelude::Vec::into_parts
    Vec<T, A> -> (NonNull<T>, usize, usize)
    Decomposes a Vec<T> into its raw components: …
    method
    radix_rust::rust::prelude::Vec::clone
    &Vec<T, A> -> Vec<T, A>
    method
    radix_rust::rust::prelude::Vec::index
    &Vec<T, A>, I -> &
    method
    radix_rust::rust::prelude::Vec::as_mut
    &mut Vec<T, A> -> &mut [T]
    method
    radix_rust::rust::prelude::Vec::resize
    &mut Vec<T, A>, usize, T -> ()
    Resizes the Vec in-place so that len is equal to new_len.
    method
    radix_rust::rust::prelude::Vec::deref_mut
    &mut Vec<T, A> -> &mut [T]
    method
    radix_rust::rust::prelude::Vec::borrow_mut
    &mut Vec<T, A> -> &mut [T]
    method
    radix_rust::rust::prelude::Vec::try_reserve
    &mut Vec<T, A>, usize -> Result<(), TryReserveError>
    Tries to reserve capacity for at least additional more …
    method
    radix_rust::rust::prelude::Vec::as_mut_slice
    &mut Vec<T, A> -> &mut [T]
    Extracts a mutable slice of the entire vector.
    method
    radix_rust::rust::prelude::Vec::try_reserve_exact
    &mut Vec<T, A>, usize -> Result<(), TryReserveError>
    Tries to reserve the minimum capacity for at least …
    method
    radix_rust::rust::prelude::Vec::push_within_capacity
    &mut Vec<T, A>, T -> Result<(), T>
    Appends an element if there is sufficient spare capacity, …
    method
    radix_rust::rust::prelude::Vec::into_parts_with_alloc
    Vec<T, A> -> (NonNull<T>, usize, usize, A)
    Decomposes a Vec<T> into its raw components: …
    method
    radix_rust::rust::prelude::Vec::ne
    &Vec<T, A>, &[U] -> bool
    method
    radix_rust::rust::prelude::Vec::cmp
    &Vec<T, A>, &Vec<T, A> -> Ordering
    method
    radix_rust::rust::prelude::Vec::hash
    &Vec<T, A>, &mut H -> ()
    method
    radix_rust::rust::prelude::Vec::extend
    &mut Vec<T, A>, I -> ()
    method
    radix_rust::rust::prelude::Vec::split_off
    &mut Vec<T, A>, usize -> Vec<T, A>
    Splits the collection into two at the given index.
    method
    radix_rust::rust::prelude::Arc::read_to_end
    &mut Arc<File>, &mut Vec<u8> -> Result<usize, Error>
    method
    radix_rust::rust::prelude::Vec::extend_from_slice
    &mut Vec<T, A>, &[T] -> ()
    Clones and appends all elements in a slice to the Vec.
    method
    radix_rust::rust::prelude::Vec::extend_from_within
    &mut Vec<T, A>, R -> ()
    Given a range src, clones a slice of elements in that …
    method
    radix_rust::rust::prelude::Vec::spare_capacity_mut
    &mut Vec<T, A> -> &mut [MaybeUninit<T>]
    Returns the remaining spare capacity of the vector as a …
    method
    radix_rust::rust::collections::VecDeque::eq
    &VecDeque<T, A>, &Vec<U, A> -> bool
    method
    radix_rust::rust::prelude::Vec::fmt
    &Vec<T, A>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::prelude::Vec::drain
    &mut Vec<T, A>, R -> Drain<T, A>
    Removes the subslice indicated by the given range from the …
    method
    radix_rust::rust::prelude::Vec::write
    &mut Vec<u8, A>, &[u8] -> Result<usize, Error>
    method
    radix_rust::rust::prelude::Vec::append
    &mut Vec<T, A>, &mut Vec<T, A> -> ()
    Moves all the elements of other into self, leaving other …
    method
    radix_rust::rust::prelude::Vec::index_mut
    &mut Vec<T, A>, I -> &mut
    method
    radix_rust::rust::prelude::Vec::write_all
    &mut Vec<u8, A>, &[u8] -> Result<(), Error>
    method
    radix_rust::rust::prelude::Vec::resize_with
    &mut Vec<T, A>, usize, F -> ()
    Resizes the Vec in-place so that len is equal to new_len.
    method
    radix_rust::rust::prelude::Vec::write_vectored
    &mut Vec<u8, A>, &[IoSlice] -> Result<usize, Error>
    method
    radix_rust::rust::prelude::Cow::eq
    &Cow<[T]>, &Vec<U, A> -> bool
    method
    radix_rust::rust::prelude::Cow::ne
    &Cow<[T]>, &Vec<U, A> -> bool
    method
    radix_rust::rust::prelude::Vec::retain
    &mut Vec<T, A>, F -> ()
    Retains only the elements specified by the predicate.
    method
    radix_rust::rust::prelude::Vec::clone_from
    &mut Vec<T, A>, &Vec<T, A> -> ()
    Overwrites the contents of self with a clone of the …
    method
    radix_rust::rust::prelude::Vec::partial_cmp
    &Vec<T, A1>, &Vec<T, A2> -> Option<Ordering>
    method
    radix_rust::rust::collections::VecDeque::read_to_end
    &mut VecDeque<u8, A>, &mut Vec<u8> -> Result<usize, Error>
    method
    radix_rust::rust::prelude::Box::read_to_end
    &mut Box<R>, &mut Vec<u8> -> Result<usize, Error>
    method
    radix_rust::rust::prelude::Vec::write_all_vectored
    &mut Vec<u8, A>, &mut [IoSlice] -> Result<(), Error>
    method
    radix_rust::rust::prelude::Box::read_until
    &mut Box<B>, u8, &mut Vec<u8> -> Result<usize, Error>
    method
    radix_rust::rust::prelude::Vec::retain_mut
    &mut Vec<T, A>, F -> ()
    Retains only the elements specified by the predicate, …
    method
    radix_rust::rust::prelude::Vec::pop_if
    &mut Vec<T, A>, undefined -> Option<T>
    Removes and returns the last element from a vector if the …
    method
    radix_rust::rust::prelude::Vec::splice
    &mut Vec<T, A>, R, I -> Splice<A>
    Creates a splicing iterator that replaces the specified …
    method
    radix_rust::rust::prelude::Vec::dedup_by_key
    &mut Vec<T, A>, F -> ()
    Removes all but the first of consecutive elements in the …
    method
    radix_rust::rust::prelude::Vec::split_at_spare_mut
    &mut Vec<T, A> -> (&mut [T], &mut [MaybeUninit<T>])
    Returns vector content as a slice of T, along with the …
    method
    radix_rust::rust::prelude::Vec::dedup_by
    &mut Vec<T, A>, F -> ()
    Removes all but the first of consecutive elements in the …
    method
    radix_rust::rust::prelude::Vec::extract_if
    &mut Vec<T, A>, R, F -> ExtractIf<T, F, A>
    Creates an iterator which uses a closure to determine if …
    method
    radix_rust::rust::prelude::Vec::new
    -> Vec<T>
    Constructs a new, empty Vec<T>.
    method
    radix_rust::rust::prelude::Vec::default
    -> Vec<T>
    Creates an empty Vec<T>.
    method
    radix_rust::rust::prelude::Vec::from
    CString -> Vec<u8>
    Converts a CString into a Vec<u8>.
    method
    radix_rust::rust::prelude::String::into_bytes
    String -> Vec<u8>
    Converts a String into a byte vector.
    method
    radix_rust::rust::string::FromUtf8Error::into_bytes
    FromUtf8Error -> Vec<u8>
    Returns the bytes that were attempted to convert to a …
    method
    radix_rust::rust::prelude::Vec::with_capacity
    usize -> Vec<T>
    Constructs a new, empty Vec<T> with at least the specified …
    method
    radix_rust::rust::prelude::Vec::from_raw_parts
    usize, usize -> Vec<T>
    Creates a Vec<T> directly from a pointer, a length, and a …
    method
    radix_rust::rust::prelude::Vec::new_in
    A -> Vec<T, A>
    Constructs a new, empty Vec<T, A>.
    method
    radix_rust::rust::prelude::Vec::try_with_capacity
    usize -> Result<Vec<T>, TryReserveError>
    Constructs a new, empty Vec<T> with at least the specified …
    function
    radix_rust::combine
    u8, &[u8] -> Vec<u8>
    Combines a u8 with a u8 slice.
    method
    radix_rust::rust::prelude::Vec::from_iter
    I -> Vec<T>
    method
    radix_rust::rust::prelude::Vec::from_parts
    NonNull<T>, usize, usize -> Vec<T>
    Creates a Vec<T> directly from a NonNull pointer, a …
    method
    radix_rust::rust::prelude::Vec::with_capacity_in
    usize, A -> Vec<T, A>
    Constructs a new, empty Vec<T, A> with at least the …
    method
    radix_rust::rust::prelude::String::as_mut_vec
    &mut String -> &mut Vec<u8>
    Returns a mutable reference to the contents of this String.
    method
    radix_rust::rust::prelude::Vec::from_raw_parts_in
    usize, usize, A -> Vec<T, A>
    Creates a Vec<T, A> directly from a pointer, a length, a …
    method
    radix_rust::rust::prelude::Vec::try_with_capacity_in
    usize, A -> Result<Vec<T, A>, TryReserveError>
    Constructs a new, empty Vec<T, A> with at least the …
    method
    radix_rust::rust::prelude::Vec::labelled_resolve_from
    T, &undefined -> Vec<X>
    method
    radix_rust::rust::prelude::Vec::from_parts_in
    NonNull<T>, usize, usize, A -> Vec<T, A>
    Creates a Vec<T, A> directly from a NonNull pointer, a …
    method
    radix_rust::rust::prelude::Vec::into_flattened
    Vec<[T], A> -> Vec<T, A>
    Takes a Vec<[T; N]> and flattens it into a Vec<T>.
    method
    radix_rust::rust::prelude::Vec::as_ref
    &Vec<T, A> -> &Vec<T, A>
    method
    radix_rust::rust::prelude::Vec::clone
    &Vec<T, A> -> Vec<T, A>
    method
    radix_rust::rust::prelude::Vec::as_mut
    &mut Vec<T, A> -> &mut Vec<T, A>
    method
    radix_rust::rust::prelude::Vec::split_off
    &mut Vec<T, A>, usize -> Vec<T, A>
    Splits the collection into two at the given index.