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::boxed::Box
    A pointer type that uniquely owns a heap allocation of …
    module
    radix_rust::rust::boxed
    The Box<T> type for heap allocation.
    function
    radix_rust::rust::boxed::box_new
    Constructs a Box<T> by calling the exchange_malloc lang …
    struct
    radix_rust::rust::boxed::ThinBox
    ThinBox.
    method
    radix_rust::rust::prelude::String::into_boxed_str
    Converts this String into a Box<str>.
    method
    radix_rust::rust::prelude::Box::into_boxed_slice
    Converts a Box<T> into a Box<[T]>
    method
    radix_rust::rust::prelude::Vec::into_boxed_slice
    Converts the vector into Box<[T]>.
    function
    radix_rust::rust::str::from_boxed_utf8_unchecked
    Converts a boxed slice of bytes to a boxed string slice …
    method
    radix_rust::rust::prelude::String::from
    Box<str> -> String
    Converts the given boxed str slice to a String. It is …
    method
    radix_rust::rust::prelude::Box::into_iter
    Box<Slice<T>> ->
    method
    radix_rust::rust::prelude::Box::from
    Box<ByteStr> -> Box<[u8]>
    method
    radix_rust::rust::prelude::Box::clone
    &Box<ByteStr> -> Box<ByteStr>
    method
    radix_rust::rust::prelude::Box::into_raw
    Box<T, A> ->
    Consumes the Box, returning a wrapped raw pointer.
    method
    radix_rust::rust::prelude::Box::as_raw_fd
    &Box<T> -> i32
    method
    radix_rust::rust::prelude::Box::into_inner
    Box<T, A> -> T
    Consumes the Box, returning the wrapped value.
    function
    radix_rust::rust::str::from_boxed_utf8_unchecked
    Box<[u8]> -> Box<str>
    Converts a boxed slice of bytes to a boxed string slice …
    method
    radix_rust::rust::prelude::Box::as_fd
    &Box<T> -> BorrowedFd
    method
    radix_rust::rust::prelude::Box::as_ptr
    &Box<T, A> ->
    Returns a raw pointer to the Box’s contents.
    method
    radix_rust::rust::prelude::Box::description
    &Box<E> -> &str
    method
    radix_rust::rust::prelude::Box::is_read_vectored
    &Box<R> -> bool
    method
    radix_rust::rust::prelude::Box::is_write_vectored
    &Box<W> -> bool
    method
    radix_rust::rust::prelude::Box::last
    Box<I, A> -> Option
    method
    radix_rust::rust::prelude::Box::cause
    &Box<E> -> Option<&Error>
    method
    radix_rust::rust::prelude::Box::source
    &Box<E> -> Option<&Error>
    method
    radix_rust::rust::prelude::Box::try_from
    Box<[T]> -> Result<Box<[T]>>
    Attempts to convert a Box<[T]> into a Box<[T; N]>.
    method
    radix_rust::rust::prelude::Box::as_mut_ptr
    &mut Box<T, A> ->
    Returns a raw mutable pointer to the Box’s contents.
    method
    radix_rust::rust::prelude::Box::into_array
    Box<[T]> -> Option<Box<[T]>>
    Converts the boxed slice into a boxed array.
    method
    radix_rust::rust::prelude::Box::into_non_null
    Box<T, A> -> NonNull<T>
    Consumes the Box, returning a wrapped NonNull pointer.
    method
    radix_rust::rust::prelude::Box::into_raw_with_allocator
    Box<T, A> -> (A)
    Consumes the Box, returning a wrapped raw pointer and the …
    method
    radix_rust::rust::prelude::Box::len
    &Box<I, A> -> usize
    method
    radix_rust::rust::prelude::Box::drop
    &mut Box<T, A> -> ()
    method
    radix_rust::rust::prelude::Rc::from
    Box<T, A> -> Rc<T, A>
    Move a boxed object to a new, reference counted, …
    method
    radix_rust::rust::prelude::Arc::from
    Box<T, A> -> Arc<T, A>
    Move a boxed object to a new, reference-counted allocation.
    method
    radix_rust::rust::prelude::Vec::from
    Box<[T], A> -> Vec<T, A>
    Converts a boxed slice into a vector by transferring …
    method
    radix_rust::rust::prelude::Box::leak
    Box<T, A> -> &mut T
    Consumes and leaks the Box, returning a mutable reference, …
    method
    radix_rust::rust::prelude::Box::deref
    &Box<T, A> -> &T
    method
    radix_rust::rust::prelude::Box::as_ref
    &Box<T, A> -> &T
    method
    radix_rust::rust::prelude::Box::borrow
    &Box<T, A> -> &T
    method
    radix_rust::rust::prelude::Box::finish
    &Box<T, A> -> u64
    method
    radix_rust::rust::prelude::Box::consume
    &mut Box<B>, usize -> ()
    method
    radix_rust::rust::prelude::Box::provide
    &Box<E>, &mut Request -> ()
    method
    radix_rust::rust::prelude::Box::is_empty
    &Box<I, A> -> bool
    method
    radix_rust::rust::prelude::Box::allocator
    &Box<T, A> -> &A
    Returns a reference to the underlying allocator.
    method
    radix_rust::rust::prelude::Box::assume_init
    Box<MaybeUninit<T>, A> -> Box<T, A>
    Converts to Box<T, A>.
    method
    radix_rust::rust::prelude::Box::into_boxed_slice
    Box<T, A> -> Box<[T], A>
    Converts a Box<T> into a Box<[T]>
    method
    radix_rust::rust::prelude::Box::downcast_unchecked
    Box<Any, A> -> Box<T, A>
    Downcasts the box to a concrete type.
    method
    radix_rust::rust::prelude::Box::next
    &mut Box<I, A> -> Option
    method
    radix_rust::rust::prelude::Box::flush
    &mut Box<W> -> Result<(), Error>
    method
    radix_rust::rust::prelude::Box::write
    Box<MaybeUninit<T>, A>, T -> Box<T, A>
    Writes the value and converts to Box<T, A>.
    method
    radix_rust::rust::prelude::Box::rewind
    &mut Box<S> -> Result<(), Error>
    method
    radix_rust::rust::prelude::Box::into_pin
    Box<T, A> -> Pin<Box<T, A>>
    Converts a Box<T> into a Pin<Box<T>>. If T does not …
    method
    radix_rust::rust::prelude::Box::call_once
    Box<F, A>, Args ->
    method
    radix_rust::rust::prelude::Box::next_back
    &mut Box<I, A> -> Option
    method
    radix_rust::rust::prelude::Box::stream_len
    &mut Box<S> -> Result<u64, Error>
    method
    radix_rust::rust::prelude::Box::has_data_left
    &mut Box<B> -> Result<bool, Error>
    method
    radix_rust::rust::prelude::Box::async_call_once
    Box<F, A>, Args ->
    method
    radix_rust::rust::prelude::Box::stream_position
    &mut Box<S> -> Result<u64, Error>
    method
    radix_rust::rust::prelude::Box::into_non_null_with_allocator
    Box<T, A> -> (NonNull<T>, A)
    Consumes the Box, returning a wrapped NonNull pointer and …
    method
    radix_rust::rust::prelude::Box::nth
    &mut Box<I, A>, usize -> Option
    method
    radix_rust::rust::prelude::Box::call
    &Box<F, A>, Args ->
    method
    radix_rust::rust::prelude::Box::seek
    &mut Box<S>, SeekFrom -> Result<u64, Error>
    method
    radix_rust::rust::prelude::Box::as_mut
    &mut Box<T, A> -> &mut T
    method
    radix_rust::rust::prelude::Box::nth_back
    &mut Box<I, A>, usize -> Option
    method
    radix_rust::rust::prelude::Box::read_buf
    &mut Box<R>, BorrowedCursor -> Result<(), Error>
    method
    radix_rust::rust::prelude::Box::write_i8
    &mut Box<T, A>, i8 -> ()
    method
    radix_rust::rust::prelude::Box::write_u8
    &mut Box<T, A>, u8 -> ()
    method
    radix_rust::rust::prelude::Box::deref_mut
    &mut Box<T, A> -> &mut T
    method
    radix_rust::rust::prelude::Box::size_hint
    &Box<S> -> (usize, Option<usize>)
    method
    radix_rust::rust::prelude::Box::write_fmt
    &mut Box<W>, Arguments -> Result<(), Error>
    method
    radix_rust::rust::prelude::Box::write_i16
    &mut Box<T, A>, i16 -> ()
    method
    radix_rust::rust::prelude::Box::write_i32
    &mut Box<T, A>, i32 -> ()
    method
    radix_rust::rust::prelude::Box::write_i64
    &mut Box<T, A>, i64 -> ()
    method
    radix_rust::rust::prelude::Box::write_u16
    &mut Box<T, A>, u16 -> ()
    method
    radix_rust::rust::prelude::Box::write_u32
    &mut Box<T, A>, u32 -> ()
    method
    radix_rust::rust::prelude::Box::write_u64
    &mut Box<T, A>, u64 -> ()
    method
    radix_rust::rust::prelude::Box::async_call
    &Box<F, A>, Args ->
    method
    radix_rust::rust::prelude::Box::borrow_mut
    &mut Box<T, A> -> &mut T
    method
    radix_rust::rust::prelude::Box::skip_until
    &mut Box<B>, u8 -> Result<usize, Error>
    method
    radix_rust::rust::prelude::Box::write_i128
    &mut Box<T, A>, i128 -> ()
    method
    radix_rust::rust::prelude::Box::write_u128
    &mut Box<T, A>, u128 -> ()
    method
    radix_rust::rust::prelude::Box::write_isize
    &mut Box<T, A>, isize -> ()
    method
    radix_rust::rust::prelude::Box::write_usize
    &mut Box<T, A>, usize -> ()
    method
    radix_rust::rust::prelude::Box::seek_relative
    &mut Box<S>, i64 -> Result<(), Error>
    method
    radix_rust::rust::prelude::Box::read_buf_exact
    &mut Box<R>, BorrowedCursor -> Result<(), Error>
    method
    radix_rust::rust::prelude::Box::write_length_prefix
    &mut Box<T, A>, usize -> ()
    method
    radix_rust::rust::prelude::Box::call_mut
    &mut Box<F, A>, Args ->
    method
    radix_rust::rust::prelude::Box::fill_buf
    &mut Box<B> -> Result<&[u8], Error>
    method
    radix_rust::rust::prelude::Box::write_str
    &mut Box<T, A>, &str -> ()
    method
    radix_rust::rust::prelude::Box::async_call_mut
    &mut Box<F, A>, Args ->
    method
    radix_rust::rust::prelude::Box::eq
    &Box<T, A>, &Box<T, A> -> bool
    method
    radix_rust::rust::prelude::Box::ge
    &Box<T, A>, &Box<T, A> -> bool
    method
    radix_rust::rust::prelude::Box::gt
    &Box<T, A>, &Box<T, A> -> bool
    method
    radix_rust::rust::prelude::Box::le
    &Box<T, A>, &Box<T, A> -> bool
    method
    radix_rust::rust::prelude::Box::lt
    &Box<T, A>, &Box<T, A> -> bool
    method
    radix_rust::rust::prelude::Box::ne
    &Box<T, A>, &Box<T, A> -> bool
    method
    radix_rust::rust::prelude::Box::cmp
    &Box<T, A>, &Box<T, A> -> Ordering
    method
    radix_rust::rust::prelude::Box::fmt
    &Box<T, A>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::prelude::Box::hash
    &Box<T, A>, &mut H -> ()
    method
    radix_rust::rust::prelude::Box::downcast
    Box<Any, A> -> Result<Box<T, A>, Box<Any, A>>
    Attempts to downcast the box to a concrete type.
    method
    radix_rust::rust::prelude::Box::read_line
    &mut Box<B>, &mut String -> Result<usize, Error>
    method
    radix_rust::rust::prelude::Box::write_all
    &mut Box<W>, &[u8] -> Result<(), Error>
    method
    radix_rust::rust::prelude::Box::read_to_string
    &mut Box<R>, &mut String -> Result<usize, Error>
    method
    radix_rust::rust::prelude::Box::write_vectored
    &mut Box<W>, &[IoSlice] -> Result<usize, Error>
    method
    radix_rust::rust::prelude::Box::read
    &mut Box<R>, &mut [u8] -> Result<usize, Error>
    method
    radix_rust::rust::prelude::Box::clone_from
    &mut Box<T, A>, &Box<T, A> -> ()
    Copies source’s contents into self without creating a …
    method
    radix_rust::rust::prelude::Box::read_exact
    &mut Box<R>, &mut [u8] -> Result<(), Error>
    method
    radix_rust::rust::prelude::Box::partial_cmp
    &Box<T, A>, &Box<T, A> -> Option<Ordering>
    method
    radix_rust::rust::prelude::Box::read_to_end
    &mut Box<R>, &mut Vec<u8> -> Result<usize, Error>
    method
    radix_rust::rust::prelude::Box::read_vectored
    &mut Box<R>, &mut [IoSliceMut] -> Result<usize, Error>
    method
    radix_rust::rust::prelude::Box::write_all_vectored
    &mut Box<W>, &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::Box::default
    -> Box<OsStr>
    method
    radix_rust::rust::prelude::Box::new
    T -> Box<T>
    Allocates memory on the heap and then places x into it.
    method
    radix_rust::rust::prelude::Box::from
    String -> Box<str>
    Converts the given String to a boxed str slice that is …
    function
    radix_rust::rust::boxed::box_new
    T -> Box<T>
    Constructs a Box<T> by calling the exchange_malloc lang …
    method
    radix_rust::rust::prelude::Box::from_raw
    -> Box<T>
    Constructs a box from a raw pointer.
    method
    radix_rust::rust::prelude::Box::new_uninit
    -> Box<MaybeUninit<T>>
    Constructs a new box with uninitialized contents.
    method
    radix_rust::rust::prelude::Box::new_zeroed
    -> Box<MaybeUninit<T>>
    Constructs a new Box with uninitialized contents, with the …
    method
    radix_rust::rust::prelude::String::into_boxed_str
    String -> Box<str>
    Converts this String into a Box<str>.
    method
    radix_rust::rust::prelude::Box::try_new
    T -> Result<Box<T>, AllocError>
    Allocates memory on the heap then places x into it, …
    method
    radix_rust::rust::prelude::Box::from_non_null
    NonNull<T> -> Box<T>
    Constructs a box from a NonNull pointer.
    method
    radix_rust::rust::prelude::Box::try_new_uninit
    -> Result<Box<MaybeUninit<T>>, AllocError>
    Constructs a new box with uninitialized contents on the …
    method
    radix_rust::rust::prelude::Box::try_new_zeroed
    -> Result<Box<MaybeUninit<T>>, AllocError>
    Constructs a new Box with uninitialized contents, with the …
    method
    radix_rust::rust::prelude::Box::new_uninit_slice
    usize -> Box<[MaybeUninit<T>]>
    Constructs a new boxed slice with uninitialized contents.
    method
    radix_rust::rust::prelude::Box::new_zeroed_slice
    usize -> Box<[MaybeUninit<T>]>
    Constructs a new boxed slice with uninitialized contents, …
    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::Box::from_iter
    T -> Box<str>
    method
    radix_rust::rust::prelude::Box::from_raw_in
    A -> Box<T, A>
    Constructs a box from a raw pointer in the given allocator.
    method
    radix_rust::rust::prelude::Box::new_in
    T, A -> Box<T, A>
    Allocates memory in the given allocator then places x into …
    method
    radix_rust::rust::prelude::Box::new_uninit_in
    A -> Box<MaybeUninit<T>, A>
    Constructs a new box with uninitialized contents in the …
    method
    radix_rust::rust::prelude::Box::new_zeroed_in
    A -> Box<MaybeUninit<T>, A>
    Constructs a new Box with uninitialized contents, with the …
    method
    radix_rust::rust::prelude::Box::try_new_uninit_slice
    usize -> Result<Box<[MaybeUninit<T>]>, AllocError>
    Constructs a new boxed slice with uninitialized contents. …
    method
    radix_rust::rust::prelude::Box::try_new_zeroed_slice
    usize -> Result<Box<[MaybeUninit<T>]>, AllocError>
    Constructs a new boxed slice with uninitialized contents, …
    method
    radix_rust::rust::prelude::Box::from_non_null_in
    NonNull<T>, A -> Box<T, A>
    Constructs a box from a NonNull pointer in the given …
    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::Box::new_uninit_slice_in
    usize, A -> Box<[MaybeUninit<T>], A>
    Constructs a new boxed slice with uninitialized contents …
    method
    radix_rust::rust::prelude::Box::new_zeroed_slice_in
    usize, A -> Box<[MaybeUninit<T>], A>
    Constructs a new boxed slice with uninitialized contents …
    method
    radix_rust::rust::prelude::Box::try_new_in
    T, A -> Result<Box<T, A>, AllocError>
    Allocates memory in the given allocator then places x into …
    method
    radix_rust::rust::prelude::Box::try_new_uninit_in
    A -> Result<Box<MaybeUninit<T>, A>, AllocError>
    Constructs a new box with uninitialized contents in the …
    method
    radix_rust::rust::prelude::Box::try_new_zeroed_in
    A -> Result<Box<MaybeUninit<T>, A>, AllocError>
    Constructs a new Box with uninitialized contents, with the …
    method
    radix_rust::rust::prelude::Box::try_new_uninit_slice_in
    usize, A -> Result<Box<[MaybeUninit<T>], A>, AllocError>
    Constructs a new boxed slice with uninitialized contents …
    method
    radix_rust::rust::prelude::Box::try_new_zeroed_slice_in
    usize, A -> Result<Box<[MaybeUninit<T>], A>, AllocError>
    Constructs a new boxed slice with uninitialized contents …
    method
    radix_rust::rust::prelude::Box::clone
    &Box<ByteStr> -> Box<ByteStr>
    function
    radix_rust::rust::str::from_boxed_utf8_unchecked
    Box<[u8]> -> Box<str>
    Converts a boxed slice of bytes to a boxed string slice …
    method
    radix_rust::rust::prelude::Box::into_array
    Box<[T]> -> Option<Box<[T]>>
    Converts the boxed slice into a boxed array.
    method
    radix_rust::rust::prelude::Box::assume_init
    Box<MaybeUninit<T>, A> -> Box<T, A>
    Converts to Box<T, A>.
    method
    radix_rust::rust::prelude::Box::into_boxed_slice
    Box<T, A> -> Box<[T], A>
    Converts a Box<T> into a Box<[T]>
    method
    radix_rust::rust::prelude::Box::downcast_unchecked
    Box<Any, A> -> Box<T, A>
    Downcasts the box to a concrete type.
    method
    radix_rust::rust::prelude::Box::write
    Box<MaybeUninit<T>, A>, T -> Box<T, A>
    Writes the value and converts to Box<T, A>.
    method
    radix_rust::rust::prelude::Box::downcast
    Box<Any, A> -> Result<Box<T, A>, Box<Any, A>>
    Attempts to downcast the box to a concrete type.