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
    trait
    radix_rust::rust::marker::Sized
    Types with a constant size known at compile time.
    trait
    radix_rust::rust::marker::UnsizedConstParamTy
    A marker for types which can be used as types of const …
    derive macro
    radix_rust::rust::marker::UnsizedConstParamTy
    Derive macro generating an impl of the trait ConstParamTy.
    struct
    radix_rust::rust::iter::ByRefSized
    Like Iterator::by_ref, but requiring Sized so it can …
    trait
    radix_rust::rust::ops::CoerceUnsized
    Trait that indicates that this is a pointer or a wrapper …
    function
    radix_rust::rust::mem::forget_unsized
    Like forget, but also accepts unsized values.
    method
    radix_rust::rust::alloc::Layout::size
    The minimum size in bytes for a memory block of this …
    function
    radix_rust::rust::ptr::from_ref
    &T ->
    where
    T: Sized
    Converts a reference to a raw pointer.
    method
    radix_rust::rust::mem::TransmuteFrom::transmute
    Src -> TransmuteFrom
    where
    Src: Sized
    Transmutes a Src value into a Self.
    function
    radix_rust::rust::mem::forget_unsized
    T -> ()
    where
    T: Sized
    Like forget, but also accepts unsized values.
    function
    radix_rust::rust::ptr::from_mut
    &mut T ->
    where
    T: Sized
    Converts a mutable reference to a raw pointer.
    method
    radix_rust::rust::alloc::Layout::for_value
    &T -> Layout
    where
    T: Sized
    Produces layout describing a record that could be used to …
    function
    radix_rust::rust::mem::size_of_val
    &T -> usize
    where
    T: Sized
    Returns the size of the pointed-to value in bytes.
    function
    radix_rust::rust::mem::align_of_val
    &T -> usize
    where
    T: Sized
    Returns the ABI-required minimum alignment of the type of …
    function
    radix_rust::rust::mem::min_align_of_val
    &T -> usize
    where
    T: Sized
    Returns the ABI-required minimum alignment of the type of …
    method
    radix_rust::rust::ptr::NonNull::from
    &T -> NonNull<T>
    where
    T: Sized
    Converts a &T to a NonNull<T>.
    method
    radix_rust::rust::ptr::NonNull::write
    NonNull<T>, T -> ()
    where
    T: Sized
    Overwrites a memory location with the given value without …
    method
    radix_rust::rust::ptr::NonNull::replace
    NonNull<T>, T -> T
    where
    T: Sized
    Replaces the value at self with src, returning the old …
    method
    radix_rust::rust::ptr::NonNull::from_ref
    &T -> NonNull<T>
    where
    T: Sized
    Converts a reference to a NonNull pointer.
    method
    radix_rust::rust::prelude::Box::into_raw
    Box<T, A> ->
    where
    T: Sized
    Consumes the Box, returning a wrapped raw pointer.
    method
    radix_rust::rust::prelude::Rc::into_raw
    Rc<T, A> ->
    where
    T: Sized
    Consumes the Rc, returning the wrapped pointer.
    method
    radix_rust::rust::prelude::Arc::into_raw
    Arc<T, A> ->
    where
    T: Sized
    Consumes the Arc, returning the wrapped pointer.
    method
    radix_rust::rust::ptr::NonNull::write_volatile
    NonNull<T>, T -> ()
    where
    T: Sized
    Performs a volatile write of a memory location with the …
    method
    radix_rust::rust::ptr::NonNull::write_unaligned
    NonNull<T>, T -> ()
    where
    T: Sized
    Overwrites a memory location with the given value without …
    trait method
    radix_rust::rust::prelude::PartialEq::eq
    &PartialEq, &Rhs -> bool
    where
    Rhs: Sized
    Tests for self and other values to be equal, and is used …
    method
    radix_rust::rust::prelude::PartialOrd::ge
    &PartialOrd, &Rhs -> bool
    where
    Rhs: Sized
    Tests greater than or equal to (for self and other) and is …
    method
    radix_rust::rust::prelude::PartialOrd::gt
    &PartialOrd, &Rhs -> bool
    where
    Rhs: Sized
    Tests greater than (for self and other) and is used by the …
    method
    radix_rust::rust::prelude::PartialOrd::le
    &PartialOrd, &Rhs -> bool
    where
    Rhs: Sized
    Tests less than or equal to (for self and other) and is …
    method
    radix_rust::rust::prelude::PartialOrd::lt
    &PartialOrd, &Rhs -> bool
    where
    Rhs: Sized
    Tests less than (for self and other) and is used by the < …
    method
    radix_rust::rust::prelude::PartialEq::ne
    &PartialEq, &Rhs -> bool
    where
    Rhs: Sized
    Tests for !=. The default implementation is almost always …
    method
    radix_rust::rust::prelude::Box::as_fd
    &Box<T> -> BorrowedFd
    where
    T: AsFd + Sized
    method
    radix_rust::rust::prelude::Rc::as_fd
    &Rc<T> -> BorrowedFd
    where
    T: AsFd + Sized
    method
    radix_rust::rust::prelude::Arc::as_fd
    &Arc<T> -> BorrowedFd
    where
    T: AsFd + Sized
    method
    radix_rust::rust::prelude::Box::as_ptr
    &Box<T, A> ->
    where
    T: Sized
    Returns a raw pointer to the Box’s contents.
    method
    radix_rust::rust::prelude::Rc::as_ptr
    &Rc<T, A> ->
    where
    T: Sized
    Provides a raw pointer to the data.
    method
    radix_rust::rust::prelude::Arc::as_ptr
    &Arc<T, A> ->
    where
    T: Sized
    Provides a raw pointer to the data.
    method
    radix_rust::rust::ptr::NonNull::from_mut
    &mut T -> NonNull<T>
    where
    T: Sized
    Converts a mutable reference to a NonNull pointer.
    method
    radix_rust::rust::prelude::Box::is_read_vectored
    &Box<R> -> bool
    where
    R: Read + Sized
    method
    radix_rust::rust::prelude::Box::is_write_vectored
    &Box<W> -> bool
    where
    W: Write + Sized
    method
    radix_rust::rust::prelude::Box::last
    Box<I, A> -> Option
    where
    I: Iterator + Sized
    method
    radix_rust::rust::prelude::Cell::from_mut
    &mut T -> &Cell<T>
    where
    T: Sized
    Returns a &Cell<T> from a &mut T
    method
    radix_rust::rust::prelude::Arc::is_unique
    &Arc<T, A> -> bool
    where
    T: Sized
    Determine whether this is the unique reference to the …
    method
    radix_rust::rust::prelude::Box::as_mut_ptr
    &mut Box<T, A> ->
    where
    T: Sized
    Returns a raw mutable pointer to the Box’s contents.
    method
    radix_rust::rust::prelude::Rc::weak_count
    &Rc<T, A> -> usize
    where
    T: Sized
    Gets the number of Weak pointers to this allocation.
    method
    radix_rust::rust::prelude::Arc::weak_count
    &Arc<T, A> -> usize
    where
    T: Sized
    Gets the number of Weak pointers to this allocation.
    method
    radix_rust::rust::prelude::Arc::description
    &Arc<T> -> &str
    where
    T: Error + Sized
    trait method
    radix_rust::rust::prelude::PartialOrd::partial_cmp
    &PartialOrd, &Rhs -> Option<Ordering>
    where
    Rhs: Sized
    This method returns an ordering between self and other …
    method
    radix_rust::rust::prelude::Rc::strong_count
    &Rc<T, A> -> usize
    where
    T: Sized
    Gets the number of strong (Rc) pointers to this allocation.
    method
    radix_rust::rust::prelude::Arc::strong_count
    &Arc<T, A> -> usize
    where
    T: Sized
    Gets the number of strong (Arc) pointers to this …
    method
    radix_rust::rust::prelude::Box::into_non_null
    Box<T, A> -> NonNull<T>
    where
    T: Sized
    Consumes the Box, returning a wrapped NonNull pointer.
    method
    radix_rust::rust::prelude::Box::into_raw_with_allocator
    Box<T, A> -> (A)
    where
    T: Sized
    Consumes the Box, returning a wrapped raw pointer and the …
    method
    radix_rust::rust::prelude::Rc::into_raw_with_allocator
    Rc<T, A> -> (A)
    where
    T: Sized
    Consumes the Rc, returning the wrapped pointer and …
    method
    radix_rust::rust::prelude::Arc::into_raw_with_allocator
    Arc<T, A> -> (A)
    where
    T: Sized
    Consumes the Arc, returning the wrapped pointer and …
    method
    radix_rust::rust::prelude::Box::len
    &Box<I, A> -> usize
    where
    I: ExactSizeIterator + Sized
    method
    radix_rust::rust::prelude::Rc::drop
    &mut Rc<T, A> -> ()
    where
    T: Sized
    Drops the Rc.
    method
    radix_rust::rust::prelude::Arc::drop
    &mut Arc<T, A> -> ()
    where
    T: Sized
    Drops the Arc.
    method
    radix_rust::rust::prelude::Box::drop
    &mut Box<T, A> -> ()
    where
    T: Sized
    method
    radix_rust::rust::prelude::Rc::from
    Box<T, A> -> Rc<T, A>
    where
    T: Sized
    Move a boxed object to a new, reference counted, …
    method
    radix_rust::rust::prelude::Arc::from
    Box<T, A> -> Arc<T, A>
    where
    T: Sized
    Move a boxed object to a new, reference-counted allocation.
    method
    radix_rust::rust::prelude::Box::leak
    Box<T, A> -> &mut T
    where
    T: Sized
    Consumes and leaks the Box, returning a mutable reference, …
    method
    radix_rust::rust::prelude::Arc::cause
    &Arc<T> -> Option<&Error>
    where
    T: Error + Sized
    method
    radix_rust::rust::prelude::Box::deref
    &Box<T, A> -> &T
    where
    T: Sized
    method
    radix_rust::rust::prelude::Rc::deref
    &Rc<T, A> -> &T
    where
    T: Sized
    method
    radix_rust::rust::prelude::Arc::deref
    &Arc<T, A> -> &T
    where
    T: Sized
    method
    radix_rust::rust::prelude::Box::as_ref
    &Box<T, A> -> &T
    where
    T: Sized
    method
    radix_rust::rust::prelude::Rc::as_ref
    &Rc<T, A> -> &T
    where
    T: Sized
    method
    radix_rust::rust::prelude::Arc::as_ref
    &Arc<T, A> -> &T
    where
    T: Sized
    method
    radix_rust::rust::prelude::Box::borrow
    &Box<T, A> -> &T
    where
    T: Sized
    method
    radix_rust::rust::prelude::Rc::borrow
    &Rc<T, A> -> &T
    where
    T: Sized
    method
    radix_rust::rust::prelude::Arc::borrow
    &Arc<T, A> -> &T
    where
    T: Sized
    method
    radix_rust::rust::prelude::Box::finish
    &Box<T, A> -> u64
    where
    T: Hasher + Sized
    method
    radix_rust::rust::prelude::Arc::source
    &Arc<T> -> Option<&Error>
    where
    T: Error + Sized
    method
    radix_rust::rust::prelude::Box::consume
    &mut Box<B>, usize -> ()
    where
    B: BufRead + Sized
    method
    radix_rust::rust::prelude::UnsafeCell::from_mut
    &mut T -> &mut UnsafeCell<T>
    where
    T: Sized
    Converts from &mut T to &mut UnsafeCell<T>.
    method
    radix_rust::rust::sync::Exclusive::from_mut
    &mut T -> &mut Exclusive<T>
    where
    T: Sized
    Build a mutable reference to an Exclusive<T> from a mutable…
    method
    radix_rust::rust::prelude::Box::is_empty
    &Box<I, A> -> bool
    where
    I: ExactSizeIterator + Sized
    method
    radix_rust::rust::prelude::Box::allocator
    &Box<T, A> -> &A
    where
    T: Sized
    Returns a reference to the underlying allocator.
    method
    radix_rust::rust::prelude::Rc::allocator
    &Rc<T, A> -> &A
    where
    T: Sized
    Returns a reference to the underlying allocator.
    method
    radix_rust::rust::prelude::Arc::allocator
    &Arc<T, A> -> &A
    where
    T: Sized
    Returns a reference to the underlying allocator.
    trait method
    radix_rust::rust::ops::IndexMut::index_mut
    &mut IndexMut, Idx -> &mut Index::Output
    where
    Idx: Sized
    Performs the mutable indexing (container[index]) operation.
    method
    radix_rust::rust::prelude::Box::next
    &mut Box<I, A> -> Option
    where
    I: Iterator + Sized
    method
    radix_rust::rust::prelude::Box::flush
    &mut Box<W> -> Result<(), Error>
    where
    W: Write + Sized
    trait method
    radix_rust::rust::ops::Index::index
    &Index, Idx -> &Index::Output
    where
    Idx: Sized
    Performs the indexing (container[index]) operation.
    trait method
    radix_rust::rust::slice::SliceIndex::index
    SliceIndex, &T -> &SliceIndex::Output
    where
    T: Sized
    Returns a shared reference to the output at this location, …
    method
    radix_rust::rust::prelude::Box::rewind
    &mut Box<S> -> Result<(), Error>
    where
    S: Seek + Sized
    method
    radix_rust::rust::prelude::Arc::provide
    &Arc<T>, &mut Request -> ()
    where
    T: Error + Sized
    method
    radix_rust::rust::prelude::Box::into_pin
    Box<T, A> -> Pin<Box<T, A>>
    where
    T: Sized
    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 ->
    where
    F: FnOnce (Args) + Sized
    method
    radix_rust::rust::prelude::Box::next_back
    &mut Box<I, A> -> Option
    where
    I: DoubleEndedIterator + Sized
    method
    radix_rust::rust::iter::Peekable::next_if_eq
    &mut Peekable<I>, &T -> Option
    where
    T: Sized
    Consume and return the next item if it is equal to expected…
    method
    radix_rust::rust::prelude::Box::stream_len
    &mut Box<S> -> Result<u64, Error>
    where
    S: Seek + Sized
    method
    radix_rust::rust::prelude::Box::has_data_left
    &mut Box<B> -> Result<bool, Error>
    where
    B: BufRead + Sized
    method
    radix_rust::rust::prelude::Box::async_call_once
    Box<F, A>, Args ->
    where
    F: AsyncFnOnce<Args> + Sized
    method
    radix_rust::rust::prelude::Box::stream_position
    &mut Box<S> -> Result<u64, Error>
    where
    S: Seek + Sized
    method
    radix_rust::rust::prelude::Box::into_non_null_with_allocator
    Box<T, A> -> (NonNull<T>, A)
    where
    T: Sized
    Consumes the Box, returning a wrapped NonNull pointer and …
    trait method
    radix_rust::rust::slice::SliceIndex::get
    SliceIndex, &T -> Option<&SliceIndex::Output>
    where
    T: Sized
    Returns a shared reference to the output at this location, …
    method
    radix_rust::rust::prelude::Box::nth
    &mut Box<I, A>, usize -> Option
    where
    I: Iterator + Sized
    method
    radix_rust::rust::prelude::Box::call
    &Box<F, A>, Args ->
    where
    F: Fn (Args) + Sized
    method
    radix_rust::rust::prelude::Box::seek
    &mut Box<S>, SeekFrom -> Result<u64, Error>
    where
    S: Seek + Sized
    method
    radix_rust::rust::prelude::Rc::clone
    &Rc<T, A> -> Rc<T, A>
    where
    T: Sized
    Makes a clone of the Rc pointer.
    method
    radix_rust::rust::prelude::Arc::clone
    &Arc<T, A> -> Arc<T, A>
    where
    T: Sized
    Makes a clone of the Arc pointer.
    method
    radix_rust::rust::prelude::Box::as_mut
    &mut Box<T, A> -> &mut T
    where
    T: Sized
    method
    radix_rust::rust::prelude::Box::nth_back
    &mut Box<I, A>, usize -> Option
    where
    I: DoubleEndedIterator + Sized
    method
    radix_rust::rust::prelude::Box::read_buf
    &mut Box<R>, BorrowedCursor -> Result<(), Error>
    where
    R: Read + Sized
    method
    radix_rust::rust::prelude::Box::write_i8
    &mut Box<T, A>, i8 -> ()
    where
    T: Hasher + Sized
    method
    radix_rust::rust::prelude::Box::write_u8
    &mut Box<T, A>, u8 -> ()
    where
    T: Hasher + Sized
    method
    radix_rust::rust::prelude::Box::deref_mut
    &mut Box<T, A> -> &mut T
    where
    T: Sized
    method
    radix_rust::rust::prelude::Rc::downgrade
    &Rc<T, A> -> Weak<T, A>
    where
    T: Sized
    Creates a new Weak pointer to this allocation.
    method
    radix_rust::rust::prelude::Arc::downgrade
    &Arc<T, A> -> Weak<T, A>
    where
    T: Sized
    Creates a new Weak pointer to this allocation.
    method
    radix_rust::rust::prelude::Box::size_hint
    &Box<S> -> (usize, Option<usize>)
    where
    S: AsyncIterator + Unpin + Sized
    method
    radix_rust::rust::prelude::Box::write_fmt
    &mut Box<W>, Arguments -> Result<(), Error>
    where
    W: Write + Sized
    method
    radix_rust::rust::prelude::Box::write_i16
    &mut Box<T, A>, i16 -> ()
    where
    T: Hasher + Sized
    method
    radix_rust::rust::prelude::Box::write_i32
    &mut Box<T, A>, i32 -> ()
    where
    T: Hasher + Sized
    method
    radix_rust::rust::prelude::Box::write_i64
    &mut Box<T, A>, i64 -> ()
    where
    T: Hasher + Sized
    method
    radix_rust::rust::prelude::Box::write_u16
    &mut Box<T, A>, u16 -> ()
    where
    T: Hasher + Sized
    method
    radix_rust::rust::prelude::Box::write_u32
    &mut Box<T, A>, u32 -> ()
    where
    T: Hasher + Sized
    method
    radix_rust::rust::prelude::Box::write_u64
    &mut Box<T, A>, u64 -> ()
    where
    T: Hasher + Sized
    method
    radix_rust::rust::prelude::Box::async_call
    &Box<F, A>, Args ->
    where
    F: AsyncFn<Args> + Sized
    method
    radix_rust::rust::prelude::Box::borrow_mut
    &mut Box<T, A> -> &mut T
    where
    T: Sized
    method
    radix_rust::rust::prelude::Box::skip_until
    &mut Box<B>, u8 -> Result<usize, Error>
    where
    B: BufRead + Sized
    method
    radix_rust::rust::prelude::Box::write_i128
    &mut Box<T, A>, i128 -> ()
    where
    T: Hasher + Sized
    method
    radix_rust::rust::prelude::Box::write_u128
    &mut Box<T, A>, u128 -> ()
    where
    T: Hasher + Sized
    method
    radix_rust::rust::prelude::Box::write_isize
    &mut Box<T, A>, isize -> ()
    where
    T: Hasher + Sized
    method
    radix_rust::rust::prelude::Box::write_usize
    &mut Box<T, A>, usize -> ()
    where
    T: Hasher + Sized
    method
    radix_rust::rust::prelude::Box::seek_relative
    &mut Box<S>, i64 -> Result<(), Error>
    where
    S: Seek + Sized
    method
    radix_rust::rust::prelude::Box::read_buf_exact
    &mut Box<R>, BorrowedCursor -> Result<(), Error>
    where
    R: Read + Sized
    method
    radix_rust::rust::prelude::Rc::get_mut_unchecked
    &mut Rc<T, A> -> &mut T
    where
    T: Sized
    Returns a mutable reference into the given Rc, without any …
    method
    radix_rust::rust::prelude::Arc::get_mut_unchecked
    &mut Arc<T, A> -> &mut T
    where
    T: Sized
    Returns a mutable reference into the given Arc, without …
    method
    radix_rust::rust::prelude::Box::write_length_prefix
    &mut Box<T, A>, usize -> ()
    where
    T: Hasher + Sized
    method
    radix_rust::rust::prelude::Rc::ptr_eq
    &Rc<T, A>, &Rc<T, A> -> bool
    where
    T: Sized
    Returns true if the two Rcs point to the same allocation …
    method
    radix_rust::rust::prelude::Arc::ptr_eq
    &Arc<T, A>, &Arc<T, A> -> bool
    where
    T: Sized
    Returns true if the two Arcs point to the same allocation …
    method
    radix_rust::rust::prelude::Rc::get_mut
    &mut Rc<T, A> -> Option<&mut T>
    where
    T: Sized
    Returns a mutable reference into the given Rc, if there are
    method
    radix_rust::rust::prelude::Arc::get_mut
    &mut Arc<T, A> -> Option<&mut T>
    where
    T: Sized
    Returns a mutable reference into the given Arc, if there …
    method
    radix_rust::rust::prelude::Box::call_mut
    &mut Box<F, A>, Args ->
    where
    F: FnMut (Args) + Sized
    method
    radix_rust::rust::ops::Range::contains
    &Range<Idx>, &U -> bool
    where
    U: PartialOrd + Sized
    Returns true if item is contained in the range.
    method
    radix_rust::rust::ops::RangeFrom::contains
    &RangeFrom<Idx>, &U -> bool
    where
    U: PartialOrd + Sized
    Returns true if item is contained in the range.
    method
    radix_rust::rust::ops::RangeTo::contains
    &RangeTo<Idx>, &U -> bool
    where
    U: PartialOrd + Sized
    Returns true if item is contained in the range.
    method
    radix_rust::rust::ops::RangeInclusive::contains
    &RangeInclusive<Idx>, &U -> bool
    where
    U: PartialOrd + Sized
    Returns true if item is contained in the range.
    method
    radix_rust::rust::ops::RangeToInclusive::contains
    &RangeToInclusive<Idx>, &U -> bool
    where
    U: PartialOrd + Sized
    Returns true if item is contained in the range.
    method
    radix_rust::rust::prelude::Box::fill_buf
    &mut Box<B> -> Result<&[u8], Error>
    where
    B: BufRead + Sized
    trait method
    radix_rust::rust::slice::SliceIndex::index_mut
    SliceIndex, &mut T -> &mut SliceIndex::Output
    where
    T: Sized
    Returns a mutable reference to the output at this …
    method
    radix_rust::rust::prelude::Box::write_str
    &mut Box<T, A>, &str -> ()
    where
    T: Hasher + Sized
    method
    radix_rust::rust::prelude::Box::async_call_mut
    &mut Box<F, A>, Args ->
    where
    F: AsyncFnMut<Args> + Sized
    method
    radix_rust::rust::prelude::Rc::eq
    &Rc<T, A>, &Rc<T, A> -> bool
    where
    T: PartialEq + Sized
    Equality for two Rcs.
    method
    radix_rust::rust::prelude::Arc::eq
    &Arc<T, A>, &Arc<T, A> -> bool
    where
    T: PartialEq + Sized
    Equality for two Arcs.
    method
    radix_rust::rust::prelude::Box::eq
    &Box<T, A>, &Box<T, A> -> bool
    where
    T: PartialEq + Sized
    method
    radix_rust::rust::prelude::Rc::ge
    &Rc<T, A>, &Rc<T, A> -> bool
    where
    T: PartialOrd + Sized
    ‘Greater than or equal to’ comparison for two Rcs.
    method
    radix_rust::rust::prelude::Arc::ge
    &Arc<T, A>, &Arc<T, A> -> bool
    where
    T: PartialOrd + Sized
    ‘Greater than or equal to’ comparison for two Arcs.
    method
    radix_rust::rust::prelude::Box::ge
    &Box<T, A>, &Box<T, A> -> bool
    where
    T: PartialOrd + Sized
    method
    radix_rust::rust::prelude::Rc::gt
    &Rc<T, A>, &Rc<T, A> -> bool
    where
    T: PartialOrd + Sized
    Greater-than comparison for two Rcs.
    method
    radix_rust::rust::prelude::Arc::gt
    &Arc<T, A>, &Arc<T, A> -> bool
    where
    T: PartialOrd + Sized
    Greater-than comparison for two Arcs.
    method
    radix_rust::rust::prelude::Box::gt
    &Box<T, A>, &Box<T, A> -> bool
    where
    T: PartialOrd + Sized
    method
    radix_rust::rust::prelude::Rc::le
    &Rc<T, A>, &Rc<T, A> -> bool
    where
    T: PartialOrd + Sized
    ‘Less than or equal to’ comparison for two Rcs.
    method
    radix_rust::rust::prelude::Arc::le
    &Arc<T, A>, &Arc<T, A> -> bool
    where
    T: PartialOrd + Sized
    ‘Less than or equal to’ comparison for two Arcs.
    method
    radix_rust::rust::prelude::Box::le
    &Box<T, A>, &Box<T, A> -> bool
    where
    T: PartialOrd + Sized
    method
    radix_rust::rust::prelude::Rc::lt
    &Rc<T, A>, &Rc<T, A> -> bool
    where
    T: PartialOrd + Sized
    Less-than comparison for two Rcs.
    method
    radix_rust::rust::prelude::Arc::lt
    &Arc<T, A>, &Arc<T, A> -> bool
    where
    T: PartialOrd + Sized
    Less-than comparison for two Arcs.
    method
    radix_rust::rust::prelude::Box::lt
    &Box<T, A>, &Box<T, A> -> bool
    where
    T: PartialOrd + Sized
    method
    radix_rust::rust::prelude::Rc::ne
    &Rc<T, A>, &Rc<T, A> -> bool
    where
    T: PartialEq + Sized
    Inequality for two Rcs.
    method
    radix_rust::rust::prelude::Arc::ne
    &Arc<T, A>, &Arc<T, A> -> bool
    where
    T: PartialEq + Sized
    Inequality for two Arcs.
    method
    radix_rust::rust::prelude::Box::ne
    &Box<T, A>, &Box<T, A> -> bool
    where
    T: PartialEq + Sized
    method
    radix_rust::rust::prelude::Rc::cmp
    &Rc<T, A>, &Rc<T, A> -> Ordering
    where
    T: Ord + Sized
    Comparison for two Rcs.
    method
    radix_rust::rust::prelude::Arc::cmp
    &Arc<T, A>, &Arc<T, A> -> Ordering
    where
    T: Ord + Sized
    Comparison for two Arcs.
    method
    radix_rust::rust::prelude::Box::cmp
    &Box<T, A>, &Box<T, A> -> Ordering
    where
    T: Ord + Sized
    method
    radix_rust::rust::prelude::Box::fmt
    &Box<T, A>, &mut Formatter -> Result<(), Error>
    where
    T: Sized
    method
    radix_rust::rust::prelude::Rc::fmt
    &Rc<T, A>, &mut Formatter -> Result<(), Error>
    where
    T: Sized
    method
    radix_rust::rust::prelude::Arc::fmt
    &Arc<T, A>, &mut Formatter -> Result<(), Error>
    where
    T: Sized
    method
    radix_rust::rust::prelude::Box::hash
    &Box<T, A>, &mut H -> ()
    where
    T: Hash + Sized
    method
    radix_rust::rust::prelude::Rc::hash
    &Rc<T, A>, &mut H -> ()
    where
    T: Hash + Sized
    method
    radix_rust::rust::prelude::Arc::hash
    &Arc<T, A>, &mut H -> ()
    where
    T: Hash + Sized
    method
    radix_rust::rust::prelude::Box::write
    &mut Box<T, A>, &[u8] -> ()
    where
    T: Hasher + Sized
    trait method
    radix_rust::rust::slice::SliceIndex::get_mut
    SliceIndex, &mut T -> Option<&mut SliceIndex::Output>
    where
    T: Sized
    Returns a mutable reference to the output at this …
    method
    radix_rust::rust::prelude::Rc::make_mut
    &mut Rc<T, A> -> &mut T
    where
    T: CloneToUninit + Sized
    Makes a mutable reference into the given Rc.
    method
    radix_rust::rust::prelude::Arc::make_mut
    &mut Arc<T, A> -> &mut T
    where
    T: CloneToUninit + Sized
    Makes a mutable reference into the given Arc.
    method
    radix_rust::rust::prelude::Box::read_line
    &mut Box<B>, &mut String -> Result<usize, Error>
    where
    B: BufRead + Sized
    method
    radix_rust::rust::prelude::Box::write_all
    &mut Box<W>, &[u8] -> Result<(), Error>
    where
    W: Write + Sized
    method
    radix_rust::rust::prelude::Box::read_to_string
    &mut Box<R>, &mut String -> Result<usize, Error>
    where
    R: Read + Sized
    method
    radix_rust::rust::prelude::Box::write_vectored
    &mut Box<W>, &[IoSlice] -> Result<usize, Error>
    where
    W: Write + Sized
    method
    radix_rust::rust::prelude::Box::read
    &mut Box<R>, &mut [u8] -> Result<usize, Error>
    where
    R: Read + Sized
    method
    radix_rust::rust::prelude::Box::read_exact
    &mut Box<R>, &mut [u8] -> Result<(), Error>
    where
    R: Read + Sized
    method
    radix_rust::rust::prelude::Rc::partial_cmp
    &Rc<T, A>, &Rc<T, A> -> Option<Ordering>
    where
    T: PartialOrd + Sized
    Partial comparison for two Rcs.
    method
    radix_rust::rust::prelude::Arc::partial_cmp
    &Arc<T, A>, &Arc<T, A> -> Option<Ordering>
    where
    T: PartialOrd + Sized
    Partial comparison for two Arcs.
    method
    radix_rust::rust::prelude::Box::partial_cmp
    &Box<T, A>, &Box<T, A> -> Option<Ordering>
    where
    T: PartialOrd + Sized
    method
    radix_rust::rust::prelude::Box::read_to_end
    &mut Box<R>, &mut Vec<u8> -> Result<usize, Error>
    where
    R: Read + Sized
    method
    radix_rust::rust::prelude::Box::read_vectored
    &mut Box<R>, &mut [IoSliceMut] -> Result<usize, Error>
    where
    R: Read + Sized
    method
    radix_rust::rust::prelude::Box::write_all_vectored
    &mut Box<W>, &mut [IoSlice] -> Result<(), Error>
    where
    W: Write + Sized
    method
    radix_rust::rust::collections::BTreeSet::contains
    &BTreeSet<T, A>, &Q -> bool
    where
    Q: Ord + Sized
    Returns true if the set contains an element equal to the …
    method
    radix_rust::rust::prelude::Box::read_until
    &mut Box<B>, u8, &mut Vec<u8> -> Result<usize, Error>
    where
    B: BufRead + Sized
    method
    radix_rust::rust::collections::non_iter_map::NonIterMap::contains_key
    &NonIterMap<K, V>, &Q -> bool
    where
    Q: Hash + Eq + Sized
    Returns true if the map contains a value for the specified …
    method
    radix_rust::rust::collections::BTreeSet::remove
    &mut BTreeSet<T, A>, &Q -> bool
    where
    Q: Ord + Sized
    If the set contains an element equal to the value, removes …
    method
    radix_rust::rust::collections::hash_set::ext_HashSet::contains
    &ext_HashSet<T, S>, &Q -> bool
    where
    Q: Hash + Eq + Sized
    Returns true if the set contains a value.
    method
    radix_rust::rust::collections::BTreeMap::contains_key
    &BTreeMap<K, V, A>, &Q -> bool
    where
    Q: Ord + Sized
    Returns true if the map contains a value for the specified …
    method
    radix_rust::rust::collections::BTreeSet::get
    &BTreeSet<T, A>, &Q -> Option<&T>
    where
    Q: Ord + Sized
    Returns a reference to the element in the set, if any, …
    method
    radix_rust::rust::collections::non_iter_map::NonIterMap::get
    &NonIterMap<K, V>, &Q -> Option<&V>
    where
    Q: Hash + Eq + Sized
    Returns a reference to the value corresponding to the key.
    method
    radix_rust::rust::collections::BTreeSet::take
    &mut BTreeSet<T, A>, &Q -> Option<T>
    where
    Q: Ord + Sized
    Removes and returns the element in the set, if any, that …
    method
    radix_rust::rust::collections::BTreeMap::index
    &BTreeMap<K, V, A>, &Q -> &V
    where
    Q: Ord + Sized
    Returns a reference to the value corresponding to the …
    method
    radix_rust::rust::collections::hash_set::ext_HashSet::remove
    &mut ext_HashSet<T, S>, &Q -> bool
    where
    Q: Hash + Eq + Sized
    Removes a value from the set. Returns whether the value was
    method
    radix_rust::rust::collections::non_iter_map::NonIterMap::remove
    &mut NonIterMap<K, V>, &Q -> Option<V>
    where
    Q: Hash + Eq + Sized
    Removes a key from the map, returning the value at the key …
    method
    radix_rust::rust::collections::hash_map::ext_HashMap::contains_key
    &ext_HashMap<K, V, S>, &Q -> bool
    where
    Q: Hash + Eq + Sized
    Returns true if the map contains a value for the specified …
    method
    radix_rust::rust::collections::BTreeMap::get
    &BTreeMap<K, V, A>, &Q -> Option<&V>
    where
    Q: Ord + Sized
    Returns a reference to the value corresponding to the key.
    method
    radix_rust::rust::collections::hash_set::ext_HashSet::get
    &ext_HashSet<T, S>, &Q -> Option<&T>
    where
    Q: Hash + Eq + Sized
    Returns a reference to the value in the set, if any, that …
    method
    radix_rust::rust::collections::hash_set::ext_HashSet::take
    &mut ext_HashSet<T, S>, &Q -> Option<T>
    where
    Q: Hash + Eq + Sized
    Removes and returns the value in the set, if any, that is …
    method
    radix_rust::rust::collections::hash_map::ext_HashMap::index
    &ext_HashMap<K, V, S>, &Q -> &V
    where
    Q: Eq + Hash + Sized
    Returns a reference to the value corresponding to the …
    method
    radix_rust::rust::collections::BTreeMap::remove
    &mut BTreeMap<K, V, A>, &Q -> Option<V>
    where
    Q: Ord + Sized
    Removes a key from the map, returning the value at the key …
    method
    radix_rust::rust::collections::hash_map::ext_HashMap::get
    &ext_HashMap<K, V, S>, &Q -> Option<&V>
    where
    Q: Hash + Eq + Sized
    Returns a reference to the value corresponding to the key.
    method
    radix_rust::rust::collections::hash_map::ext_HashMap::remove
    &mut ext_HashMap<K, V, S>, &Q -> Option<V>
    where
    Q: Hash + Eq + Sized
    Removes a key from the map, returning the value at the key …
    method
    radix_rust::rust::collections::non_iter_map::NonIterMap::get_mut
    &mut NonIterMap<K, V>, &Q -> Option<&mut V>
    where
    Q: Hash + Eq + Sized
    Returns a mutable reference to the value corresponding to …
    method
    radix_rust::rust::prelude::Box::from_raw
    -> Box<T>
    where
    T: Sized
    Constructs a box from a raw pointer.
    method
    radix_rust::rust::prelude::Rc::from_raw
    -> Rc<T>
    where
    T: Sized
    Constructs an Rc<T> from a raw pointer.
    method
    radix_rust::rust::prelude::Arc::from_raw
    -> Arc<T>
    where
    T: Sized
    Constructs an Arc<T> from a raw pointer.
    method
    radix_rust::rust::ptr::NonNull::read
    NonNull<T> -> T
    where
    T: Sized
    Reads the value from self without moving it. This leaves …
    method
    radix_rust::rust::ptr::NonNull::read_volatile
    NonNull<T> -> T
    where
    T: Sized
    Performs a volatile read of the value from self without …
    method
    radix_rust::rust::ptr::NonNull::read_unaligned
    NonNull<T> -> T
    where
    T: Sized
    Reads the value from self without moving it. This leaves …
    method
    radix_rust::rust::prelude::Ref::leak
    Ref<T> -> &T
    where
    T: Sized
    Converts into a reference to the underlying data.
    trait method
    radix_rust::rust::ops::OneSidedRange::bound
    OneSidedRange -> (OneSidedRangeBound, T)
    where
    T: Sized
    An internal-only helper function for split_off and …
    trait method
    radix_rust::rust::prelude::AsRef::as_ref
    &AsRef -> &T
    where
    T: Sized
    Converts this type into a shared reference of the (usually …
    trait method
    radix_rust::rust::borrow::Borrow::borrow
    &Borrow -> &Borrowed
    where
    Borrowed: Sized
    Immutably borrows from an owned value.
    method
    radix_rust::rust::prelude::Box::from_non_null
    NonNull<T> -> Box<T>
    where
    T: Sized
    Constructs a box from a NonNull pointer.
    trait method
    radix_rust::rust::slice::SliceIndex::get_unchecked
    SliceIndex -> SliceIndex::Output
    where
    SliceIndex::Output: Sized
    Returns a pointer to the output at this location, without …
    trait method
    radix_rust::rust::slice::SliceIndex::get_unchecked_mut
    SliceIndex -> SliceIndex::Output
    where
    SliceIndex::Output: Sized
    Returns a mutable pointer to the output at this location, …
    method
    radix_rust::rust::prelude::Rc::from
    Cow<B> -> Rc<B>
    where
    B: ToOwned + Sized
    Creates a reference-counted pointer from a clone-on-write …
    method
    radix_rust::rust::prelude::Arc::from
    Cow<B> -> Arc<B>
    where
    B: ToOwned + Sized
    Creates an atomically reference-counted pointer from a …
    method
    radix_rust::rust::prelude::RefMut::leak
    RefMut<T> -> &mut T
    where
    T: Sized
    Converts into a mutable reference to the underlying data.
    method
    radix_rust::rust::boxed::ThinBox::deref
    &ThinBox<T> -> &T
    where
    T: Sized
    method
    radix_rust::rust::mem::ManuallyDrop::deref
    &ManuallyDrop<T> -> &T
    where
    T: Sized
    method
    radix_rust::rust::prelude::Ref::deref
    &Ref<T> -> &T
    where
    T: Sized
    method
    radix_rust::rust::prelude::RefMut::deref
    &RefMut<T> -> &T
    where
    T: Sized
    method
    radix_rust::rust::sync::ReentrantLockGuard::deref
    &ReentrantLockGuard<T> -> &T
    where
    T: Sized
    method
    radix_rust::rust::sync::MutexGuard::deref
    &MutexGuard<T> -> &T
    where
    T: Sized
    method
    radix_rust::rust::sync::MappedMutexGuard::deref
    &MappedMutexGuard<T> -> &T
    where
    T: Sized
    method
    radix_rust::rust::sync::RwLockReadGuard::deref
    &RwLockReadGuard<T> -> &T
    where
    T: Sized
    method
    radix_rust::rust::sync::RwLockWriteGuard::deref
    &RwLockWriteGuard<T> -> &T
    where
    T: Sized
    method
    radix_rust::rust::sync::MappedRwLockReadGuard::deref
    &MappedRwLockReadGuard<T> -> &T
    where
    T: Sized
    method
    radix_rust::rust::sync::MappedRwLockWriteGuard::deref
    &MappedRwLockWriteGuard<T> -> &T
    where
    T: Sized
    method
    radix_rust::rust::ptr::NonNull::as_ref
    &NonNull<T> -> &T
    where
    T: Sized
    Returns a shared reference to the value. If the value may …
    method
    radix_rust::rust::prelude::Box::from_raw_in
    A -> Box<T, A>
    where
    T: Sized
    Constructs a box from a raw pointer in the given allocator.
    method
    radix_rust::rust::prelude::Rc::from_raw_in
    A -> Rc<T, A>
    where
    T: Sized
    Constructs an Rc<T, A> from a raw pointer in the provided …
    method
    radix_rust::rust::prelude::Arc::from_raw_in
    A -> Arc<T, A>
    where
    T: Sized
    Constructs an Arc<T, A> from a raw pointer.
    method
    radix_rust::rust::prelude::UnsafeCell::as_ref_unchecked
    &UnsafeCell<T> -> &T
    where
    T: Sized
    Get a shared reference to the value within the UnsafeCell.
    trait method
    radix_rust::rust::ops::Deref::deref
    &Deref -> &Deref::Target
    where
    Deref::Target: Sized
    Dereferences the value.
    method
    radix_rust::rust::prelude::Cow::deref
    &Cow<B> -> &B
    where
    B: ToOwned + Sized
    trait method
    radix_rust::rust::prelude::AsMut::as_mut
    &mut AsMut -> &mut T
    where
    T: Sized
    Converts this type into a mutable reference of the …
    method
    radix_rust::rust::prelude::Cow::as_ref
    &Cow<T> -> &T
    where
    T: ToOwned + Sized
    method
    radix_rust::rust::prelude::Cow::borrow
    &Cow<B> -> &B
    where
    B: ToOwned + Sized
    trait method
    radix_rust::rust::borrow::BorrowMut::borrow_mut
    &mut BorrowMut -> &mut Borrowed
    where
    Borrowed: Sized
    Mutably borrows from an owned value.
    method
    radix_rust::rust::sync::Mutex::into_inner
    Mutex<T> -> Result<T, PoisonError<T>>
    where
    T: Sized
    Consumes this mutex, returning the underlying data.
    method
    radix_rust::rust::sync::RwLock::into_inner
    RwLock<T> -> Result<T, PoisonError<T>>
    where
    T: Sized
    Consumes this RwLock, returning the underlying data.
    method
    radix_rust::rust::prelude::UnsafeCell::as_mut_unchecked
    &UnsafeCell<T> -> &mut T
    where
    T: Sized
    Get an exclusive reference to the value within the …
    method
    radix_rust::rust::rc::UniqueRc::deref
    &UniqueRc<T, A> -> &T
    where
    T: Sized
    method
    radix_rust::rust::sync::UniqueArc::deref
    &UniqueArc<T, A> -> &T
    where
    T: Sized
    method
    radix_rust::rust::ptr::NonNull::as_mut
    &mut NonNull<T> -> &mut T
    where
    T: Sized
    Returns a unique reference to the value. If the value may …
    method
    radix_rust::rust::rc::UniqueRc::as_ref
    &UniqueRc<T, A> -> &T
    where
    T: Sized
    method
    radix_rust::rust::sync::UniqueArc::as_ref
    &UniqueArc<T, A> -> &T
    where
    T: Sized
    method
    radix_rust::rust::rc::UniqueRc::borrow
    &UniqueRc<T, A> -> &T
    where
    T: Sized
    method
    radix_rust::rust::sync::UniqueArc::borrow
    &UniqueArc<T, A> -> &T
    where
    T: Sized
    method
    radix_rust::rust::prelude::Cell::get_mut
    &mut Cell<T> -> &mut T
    where
    T: Sized
    Returns a mutable reference to the underlying data.
    method
    radix_rust::rust::prelude::RefCell::get_mut
    &mut RefCell<T> -> &mut T
    where
    T: Sized
    Returns a mutable reference to the underlying data.
    method
    radix_rust::rust::prelude::UnsafeCell::get_mut
    &mut UnsafeCell<T> -> &mut T
    where
    T: Sized
    Returns a mutable reference to the underlying data.
    method
    radix_rust::rust::prelude::SyncUnsafeCell::get_mut
    &mut SyncUnsafeCell<T> -> &mut T
    where
    T: Sized
    Returns a mutable reference to the underlying data.
    method
    radix_rust::rust::sync::ReentrantLock::get_mut
    &mut ReentrantLock<T> -> &mut T
    where
    T: Sized
    Returns a mutable reference to the underlying data.
    method
    radix_rust::rust::sync::Exclusive::get_mut
    &mut Exclusive<T> -> &mut T
    where
    T: Sized
    Gets exclusive access to the underlying value.
    method
    radix_rust::rust::rc::UniqueRc::into_rc
    UniqueRc<T, A> -> Rc<T, A>
    where
    T: Sized
    Converts the UniqueRc into a regular Rc.
    method
    radix_rust::rust::sync::UniqueArc::into_arc
    UniqueArc<T, A> -> Arc<T, A>
    where
    T: Sized
    Converts the UniqueArc into a regular Arc.
    method
    radix_rust::rust::boxed::ThinBox::deref_mut
    &mut ThinBox<T> -> &mut T
    where
    T: Sized
    method
    radix_rust::rust::mem::ManuallyDrop::deref_mut
    &mut ManuallyDrop<T> -> &mut T
    where
    T: Sized
    method
    radix_rust::rust::prelude::RefMut::deref_mut
    &mut RefMut<T> -> &mut T
    where
    T: Sized
    method
    radix_rust::rust::sync::MutexGuard::deref_mut
    &mut MutexGuard<T> -> &mut T
    where
    T: Sized
    method
    radix_rust::rust::sync::MappedMutexGuard::deref_mut
    &mut MappedMutexGuard<T> -> &mut T
    where
    T: Sized
    method
    radix_rust::rust::sync::RwLockWriteGuard::deref_mut
    &mut RwLockWriteGuard<T> -> &mut T
    where
    T: Sized
    method
    radix_rust::rust::sync::MappedRwLockWriteGuard::deref_mut
    &mut MappedRwLockWriteGuard<T> -> &mut T
    where
    T: Sized
    method
    radix_rust::rust::prelude::RefCell::undo_leak
    &mut RefCell<T> -> &mut T
    where
    T: Sized
    Undo the effect of leaked guards on the borrow state of …
    method
    radix_rust::rust::prelude::Box::from_non_null_in
    NonNull<T>, A -> Box<T, A>
    where
    T: Sized
    Constructs a box from a NonNull pointer in the given …
    method
    radix_rust::rust::prelude::RefCell::try_borrow_unguarded
    &RefCell<T> -> Result<&T, BorrowError>
    where
    T: Sized
    Immutably borrows the wrapped value, returning an error if …
    method
    radix_rust::rust::rc::UniqueRc::as_mut
    &mut UniqueRc<T, A> -> &mut T
    where
    T: Sized
    method
    radix_rust::rust::sync::UniqueArc::as_mut
    &mut UniqueArc<T, A> -> &mut T
    where
    T: Sized
    method
    radix_rust::rust::rc::UniqueRc::deref_mut
    &mut UniqueRc<T, A> -> &mut T
    where
    T: Sized
    method
    radix_rust::rust::sync::UniqueArc::deref_mut
    &mut UniqueArc<T, A> -> &mut T
    where
    T: Sized
    method
    radix_rust::rust::rc::UniqueRc::borrow_mut
    &mut UniqueRc<T, A> -> &mut T
    where
    T: Sized
    method
    radix_rust::rust::sync::UniqueArc::borrow_mut
    &mut UniqueArc<T, A> -> &mut T
    where
    T: Sized
    method
    radix_rust::rust::rc::Weak::upgrade
    &Weak<T, A> -> Option<Rc<T, A>>
    where
    T: Sized
    Attempts to upgrade the Weak pointer to an Rc, delaying …
    method
    radix_rust::rust::sync::Weak::upgrade
    &Weak<T, A> -> Option<Arc<T, A>>
    where
    T: Sized
    Attempts to upgrade the Weak pointer to an Arc, delaying …
    method
    radix_rust::rust::sync::Mutex::get_mut
    &mut Mutex<T> -> Result<&mut T, PoisonError<&mut T>>
    where
    T: Sized
    Returns a mutable reference to the underlying data.
    method
    radix_rust::rust::sync::RwLock::get_mut
    &mut RwLock<T> -> Result<&mut T, PoisonError<&mut T>>
    where
    T: Sized
    Returns a mutable reference to the underlying data.
    method
    radix_rust::rust::ptr::NonNull::replace
    NonNull<T>, T -> T
    where
    T: Sized
    Replaces the value at self with src, returning the old …
    method
    radix_rust::rust::prelude::Box::leak
    Box<T, A> -> &mut T
    where
    T: Sized
    Consumes and leaks the Box, returning a mutable reference, …
    method
    radix_rust::rust::prelude::Box::deref
    &Box<T, A> -> &T
    where
    T: Sized
    method
    radix_rust::rust::prelude::Rc::deref
    &Rc<T, A> -> &T
    where
    T: Sized
    method
    radix_rust::rust::prelude::Arc::deref
    &Arc<T, A> -> &T
    where
    T: Sized
    method
    radix_rust::rust::prelude::Box::as_ref
    &Box<T, A> -> &T
    where
    T: Sized
    method
    radix_rust::rust::prelude::Rc::as_ref
    &Rc<T, A> -> &T
    where
    T: Sized
    method
    radix_rust::rust::prelude::Arc::as_ref
    &Arc<T, A> -> &T
    where
    T: Sized
    method
    radix_rust::rust::prelude::Box::borrow
    &Box<T, A> -> &T
    where
    T: Sized
    method
    radix_rust::rust::prelude::Rc::borrow
    &Rc<T, A> -> &T
    where
    T: Sized
    method
    radix_rust::rust::prelude::Arc::borrow
    &Arc<T, A> -> &T
    where
    T: Sized
    trait method
    radix_rust::rust::ops::Index::index
    &Index, Idx -> &Index::Output
    where
    Index::Output: Sized
    Performs the indexing (container[index]) operation.
    trait method
    radix_rust::rust::slice::SliceIndex::index
    SliceIndex, &T -> &SliceIndex::Output
    where
    SliceIndex::Output: Sized
    Returns a shared reference to the output at this location, …
    trait method
    radix_rust::rust::slice::SliceIndex::get
    SliceIndex, &T -> Option<&SliceIndex::Output>
    where
    SliceIndex::Output: Sized
    Returns a shared reference to the output at this location, …
    method
    radix_rust::rust::prelude::Rc::clone
    &Rc<T, A> -> Rc<T, A>
    where
    T: Sized
    Makes a clone of the Rc pointer.
    method
    radix_rust::rust::prelude::Arc::clone
    &Arc<T, A> -> Arc<T, A>
    where
    T: Sized
    Makes a clone of the Arc pointer.
    method
    radix_rust::rust::prelude::Box::as_mut
    &mut Box<T, A> -> &mut T
    where
    T: Sized
    method
    radix_rust::rust::prelude::Box::deref_mut
    &mut Box<T, A> -> &mut T
    where
    T: Sized
    method
    radix_rust::rust::prelude::Box::borrow_mut
    &mut Box<T, A> -> &mut T
    where
    T: Sized
    method
    radix_rust::rust::prelude::Rc::get_mut_unchecked
    &mut Rc<T, A> -> &mut T
    where
    T: Sized
    Returns a mutable reference into the given Rc, without any …
    method
    radix_rust::rust::prelude::Arc::get_mut_unchecked
    &mut Arc<T, A> -> &mut T
    where
    T: Sized
    Returns a mutable reference into the given Arc, without …
    method
    radix_rust::rust::prelude::Rc::get_mut
    &mut Rc<T, A> -> Option<&mut T>
    where
    T: Sized
    Returns a mutable reference into the given Rc, if there are
    method
    radix_rust::rust::prelude::Arc::get_mut
    &mut Arc<T, A> -> Option<&mut T>
    where
    T: Sized
    Returns a mutable reference into the given Arc, if there …
    trait method
    radix_rust::rust::slice::SliceIndex::index_mut
    SliceIndex, &mut T -> &mut SliceIndex::Output
    where
    SliceIndex::Output: Sized
    Returns a mutable reference to the output at this …
    trait method
    radix_rust::rust::slice::SliceIndex::get_mut
    SliceIndex, &mut T -> Option<&mut SliceIndex::Output>
    where
    SliceIndex::Output: Sized
    Returns a mutable reference to the output at this …
    method
    radix_rust::rust::prelude::Rc::make_mut
    &mut Rc<T, A> -> &mut T
    where
    T: CloneToUninit + Sized
    Makes a mutable reference into the given Rc.
    method
    radix_rust::rust::prelude::Arc::make_mut
    &mut Arc<T, A> -> &mut T
    where
    T: CloneToUninit + Sized
    Makes a mutable reference into the given Arc.