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::fmt::Error
    The error type which is returned from formatting a message …
    assoc type
    radix_rust::rust::prelude::TryInto::Error
    The type returned in the event of a conversion error.
    assoc type
    radix_rust::rust::prelude::TryFrom::Error
    The type returned in the event of a conversion error.
    assoc type
    radix_rust::ContextualDisplay::Error
    assoc type
    radix_rust::ContextualTryFrom::Error
    assoc type
    radix_rust::ContextualTryInto::Error
    method
    radix_rust::rust::str::Utf8Error::error_len
    Provides more information about the failure:
    enum
    radix_rust::rust::num::IntErrorKind
    Enum to store the various types of errors that can cause …
    struct
    radix_rust::rust::sync::mpmc::RecvError
    An error returned from the recv function on a Receiver.
    struct
    radix_rust::rust::sync::mpmc::SendError
    An error returned from the Sender::send or SyncSender::send
    struct
    radix_rust::rust::str::Utf8Error
    Errors which can occur when attempting to interpret a …
    method
    radix_rust::rust::string::FromUtf8Error::utf8_error
    Fetch a Utf8Error to get more details about the conversion …
    struct
    radix_rust::rust::alloc::AllocError
    The AllocError error indicates an allocation failure that …
    type alias
    radix_rust::rust::string::ParseError
    A type alias for Infallible.
    struct
    radix_rust::rust::cell::BorrowError
    An error returned by RefCell::try_borrow.
    struct
    radix_rust::rust::alloc::LayoutError
    The LayoutError is returned when the parameters given to …
    struct
    radix_rust::rust::sync::PoisonError
    A type of error which can be returned whenever a lock is …
    enum
    radix_rust::rust::sync::TryLockError
    An enumeration of possible errors associated with a …
    enum
    radix_rust::rust::sync::mpmc::TryRecvError
    This enumeration is the list of the possible reasons that …
    enum
    radix_rust::rust::sync::mpmc::TrySendError
    This enumeration is the list of the possible error …
    struct
    radix_rust::rust::string::FromUtf8Error
    A possible error value when converting a String from a …
    struct
    radix_rust::rust::collections::btree_map::OccupiedError
    The error returned by try_insert when the key already …
    struct
    radix_rust::rust::collections::hash_map::OccupiedError
    The error returned by try_insert when the key already …
    struct
    radix_rust::rust::num::ParseIntError
    An error which can be returned when parsing an integer.
    function
    radix_rust::rust::alloc::set_alloc_error_hook
    Registers a custom allocation error hook, replacing any …
    struct
    radix_rust::rust::cell::BorrowMutError
    An error returned by RefCell::try_borrow_mut.
    struct
    radix_rust::rust::string::FromUtf16Error
    A possible error value when converting a String from a …
    struct
    radix_rust::rust::str::ParseBoolError
    An error returned when parsing a bool using from_str fails
    function
    radix_rust::rust::alloc::take_alloc_error_hook
    Unregisters the current allocation error hook, returning …
    struct
    radix_rust::rust::num::ParseFloatError
    An error which can be returned when parsing a float.
    struct
    radix_rust::rust::num::TryFromIntError
    The error type returned when a checked integral type …
    enum
    radix_rust::rust::sync::mpmc::RecvTimeoutError
    This enumeration is the list of possible errors that made …
    enum
    radix_rust::rust::sync::mpmc::SendTimeoutError
    An error returned from the send_timeout method.
    function
    radix_rust::rust::alloc::handle_alloc_error
    Signals a memory allocation error.
    struct
    radix_rust::rust::collections::btree_map::UnorderedKeyError
    Error type returned by CursorMut::insert_before and …
    enum
    radix_rust::rust::slice::GetDisjointMutError
    The error type returned by get_disjoint_mut.
    method
    radix_rust::rust::fmt::Error::clone
    &Error -> Error
    method
    radix_rust::rust::prelude::Box::from
    E -> Box<Error>
    where
    E: Error
    Converts a type of Error into a box of dyn Error.
    method
    radix_rust::rust::fmt::Error::description
    &Error -> &str
    method
    radix_rust::rust::fmt::Error::eq
    &Error, &Error -> bool
    method
    radix_rust::rust::fmt::Error::cmp
    &Error, &Error -> Ordering
    method
    radix_rust::rust::prelude::Box::description
    &Box<E> -> &str
    where
    E: Error
    method
    radix_rust::rust::fmt::Error::partial_cmp
    &Error, &Error -> Option<Ordering>
    method
    radix_rust::rust::fmt::Error::hash
    &Error, &mut __H -> ()
    method
    radix_rust::rust::prelude::Box::cause
    &Box<E> -> Option<&Error>
    where
    E: Error
    method
    radix_rust::rust::prelude::Box::source
    &Box<E> -> Option<&Error>
    where
    E: Error
    method
    radix_rust::rust::prelude::Arc::description
    &Arc<T> -> &str
    where
    T: Error + Sized
    method
    radix_rust::rust::fmt::Error::fmt
    &Error, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::prelude::Arc::cause
    &Arc<T> -> Option<&Error>
    where
    T: Error + Sized
    method
    radix_rust::rust::prelude::Arc::source
    &Arc<T> -> Option<&Error>
    where
    T: Error + Sized
    method
    radix_rust::rust::prelude::Box::provide
    &Box<E>, &mut Request -> ()
    where
    E: Error
    method
    radix_rust::rust::prelude::Arc::provide
    &Arc<T>, &mut Request -> ()
    where
    T: Error + Sized
    method
    radix_rust::rust::fmt::Error::default
    -> Error
    method
    radix_rust::rust::prelude::Box::from
    String -> Box<Error>
    Converts a String into a box of dyn Error + Send + Sync.
    method
    radix_rust::rust::sync::TryLockError::cause
    &TryLockError<T> -> Option<&Error>
    method
    radix_rust::rust::fmt::DebugStruct::finish
    &mut DebugStruct -> Result<(), Error>
    Finishes output and returns any error encountered.
    method
    radix_rust::rust::fmt::DebugTuple::finish
    &mut DebugTuple -> Result<(), Error>
    Finishes output and returns any error encountered.
    method
    radix_rust::rust::fmt::DebugSet::finish
    &mut DebugSet -> Result<(), Error>
    Finishes output and returns any error encountered.
    method
    radix_rust::rust::fmt::DebugList::finish
    &mut DebugList -> Result<(), Error>
    Finishes output and returns any error encountered.
    method
    radix_rust::rust::fmt::DebugMap::finish
    &mut DebugMap -> Result<(), Error>
    Finishes output and returns any error encountered.
    method
    radix_rust::rust::prelude::String::to_socket_addrs
    &String -> Result<IntoIter<SocketAddr>, Error>
    method
    radix_rust::rust::fmt::DebugStruct::finish_non_exhaustive
    &mut DebugStruct -> Result<(), Error>
    Marks the struct as non-exhaustive, indicating to the …
    method
    radix_rust::rust::fmt::DebugTuple::finish_non_exhaustive
    &mut DebugTuple -> Result<(), Error>
    Marks the tuple struct as non-exhaustive, indicating to …
    method
    radix_rust::rust::fmt::DebugSet::finish_non_exhaustive
    &mut DebugSet -> Result<(), Error>
    Marks the set as non-exhaustive, indicating to the reader …
    method
    radix_rust::rust::fmt::DebugList::finish_non_exhaustive
    &mut DebugList -> Result<(), Error>
    Marks the list as non-exhaustive, indicating to the reader …
    method
    radix_rust::rust::fmt::DebugMap::finish_non_exhaustive
    &mut DebugMap -> Result<(), Error>
    Marks the map as non-exhaustive, indicating to the reader …
    method
    radix_rust::rust::prelude::Arc::flush
    &mut Arc<File> -> Result<(), Error>
    function
    radix_rust::rust::fmt::write
    &mut Write, Arguments -> Result<(), Error>
    Takes an output stream and an Arguments struct that can be …
    method
    radix_rust::rust::fmt::Write::write_fmt
    &mut Write, Arguments -> Result<(), Error>
    Glue for usage of the write! macro with implementors of …
    method
    radix_rust::rust::fmt::Formatter::write_fmt
    &mut Formatter, Arguments -> Result<(), Error>
    Glue for usage of the write! macro with implementors of …
    method
    radix_rust::rust::prelude::Arc::stream_len
    &mut Arc<File> -> Result<u64, Error>
    method
    radix_rust::rust::fmt::Write::write_char
    &mut Write, char -> Result<(), Error>
    Writes a char into this writer, returning whether the …
    method
    radix_rust::rust::fmt::Formatter::write_char
    &mut Formatter, char -> Result<(), Error>
    method
    radix_rust::rust::prelude::String::write_char
    &mut String, char -> Result<(), Error>
    method
    radix_rust::rust::prelude::Arc::stream_position
    &mut Arc<File> -> Result<u64, Error>
    trait method
    radix_rust::rust::fmt::Octal::fmt
    &Octal, &mut Formatter -> Result<(), Error>
    Formats the value using the given formatter.
    trait method
    radix_rust::rust::fmt::Binary::fmt
    &Binary, &mut Formatter -> Result<(), Error>
    Formats the value using the given formatter.
    trait method
    radix_rust::rust::fmt::LowerHex::fmt
    &LowerHex, &mut Formatter -> Result<(), Error>
    Formats the value using the given formatter.
    trait method
    radix_rust::rust::fmt::UpperHex::fmt
    &UpperHex, &mut Formatter -> Result<(), Error>
    Formats the value using the given formatter.
    trait method
    radix_rust::rust::fmt::Pointer::fmt
    &Pointer, &mut Formatter -> Result<(), Error>
    Formats the value using the given formatter.
    trait method
    radix_rust::rust::fmt::LowerExp::fmt
    &LowerExp, &mut Formatter -> Result<(), Error>
    Formats the value using the given formatter.
    trait method
    radix_rust::rust::fmt::UpperExp::fmt
    &UpperExp, &mut Formatter -> Result<(), Error>
    Formats the value using the given formatter.
    trait method
    radix_rust::rust::prelude::Debug::fmt
    &Debug, &mut Formatter -> Result<(), Error>
    Formats the value using the given formatter.
    trait method
    radix_rust::rust::prelude::Display::fmt
    &Display, &mut Formatter -> Result<(), Error>
    Formats the value using the given formatter.
    method
    radix_rust::rust::alloc::Global::fmt
    &Global, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::alloc::System::fmt
    &System, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::alloc::Layout::fmt
    &Layout, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::alloc::LayoutError::fmt
    &LayoutError, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::alloc::AllocError::fmt
    &AllocError, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::cmp::Ordering::fmt
    &Ordering, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::collections::btree_map::UnorderedKeyError::fmt
    &UnorderedKeyError, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::collections::hash_map::RandomState::fmt
    &RandomState, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::collections::hash_map::DefaultHasher::fmt
    &DefaultHasher, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::convert::Infallible::fmt
    &Infallible, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::fmt::Alignment::fmt
    &Alignment, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::fmt::Sign::fmt
    &Sign, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::fmt::DebugAsHex::fmt
    &DebugAsHex, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::fmt::FormattingOptions::fmt
    &FormattingOptions, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::fmt::Arguments::fmt
    &Arguments, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::hash::SipHasher::fmt
    &SipHasher, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::marker::PhantomCovariantLifetime::fmt
    &PhantomCovariantLifetime, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::marker::PhantomContravariantLifetime::fmt
    &PhantomContravariantLifetime, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::marker::PhantomInvariantLifetime::fmt
    &PhantomInvariantLifetime, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::marker::PhantomPinned::fmt
    &PhantomPinned, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::mem::Assume::fmt
    &Assume, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::num::ParseFloatError::fmt
    &ParseFloatError, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::num::TryFromIntError::fmt
    &TryFromIntError, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::num::ParseIntError::fmt
    &ParseIntError, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::num::IntErrorKind::fmt
    &IntErrorKind, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::num::FpCategory::fmt
    &FpCategory, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::ops::RangeFull::fmt
    &RangeFull, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::prelude::BorrowError::fmt
    &BorrowError, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::prelude::BorrowMutError::fmt
    &BorrowMutError, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::prelude::String::fmt
    &String, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::ptr::Alignment::fmt
    &Alignment, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::slice::EscapeAscii::fmt
    &EscapeAscii, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::slice::GetDisjointMutError::fmt
    &GetDisjointMutError, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::str::Utf8Error::fmt
    &Utf8Error, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::str::ParseBoolError::fmt
    &ParseBoolError, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::str::Chars::fmt
    &Chars, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::str::CharIndices::fmt
    &CharIndices, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::str::Bytes::fmt
    &Bytes, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::str::Lines::fmt
    &Lines, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::str::LinesAny::fmt
    &LinesAny, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::str::SplitWhitespace::fmt
    &SplitWhitespace, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::str::SplitAsciiWhitespace::fmt
    &SplitAsciiWhitespace, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::str::EncodeUtf16::fmt
    &EncodeUtf16, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::str::EscapeDebug::fmt
    &EscapeDebug, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::str::EscapeDefault::fmt
    &EscapeDefault, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::str::EscapeUnicode::fmt
    &EscapeUnicode, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::str::Utf8Chunk::fmt
    &Utf8Chunk, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::str::Utf8Chunks::fmt
    &Utf8Chunks, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::str::pattern::Utf8Pattern::fmt
    &Utf8Pattern, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::str::pattern::SearchStep::fmt
    &SearchStep, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::str::pattern::CharSearcher::fmt
    &CharSearcher, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::str::pattern::CharArraySearcher::fmt
    &CharArraySearcher, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::str::pattern::CharArrayRefSearcher::fmt
    &CharArrayRefSearcher, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::str::pattern::CharSliceSearcher::fmt
    &CharSliceSearcher, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::str::pattern::StrSearcher::fmt
    &StrSearcher, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::string::Drain::fmt
    &Drain, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::string::FromUtf8Error::fmt
    &FromUtf8Error, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::string::FromUtf16Error::fmt
    &FromUtf16Error, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::string::IntoChars::fmt
    &IntoChars, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::sync::Condvar::fmt
    &Condvar, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::sync::Once::fmt
    &Once, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::sync::OnceState::fmt
    &OnceState, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::sync::Barrier::fmt
    &Barrier, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::sync::BarrierWaitResult::fmt
    &BarrierWaitResult, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::sync::WaitTimeoutResult::fmt
    &WaitTimeoutResult, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::sync::atomic::AtomicBool::fmt
    &AtomicBool, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::sync::atomic::Ordering::fmt
    &Ordering, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::sync::atomic::AtomicI8::fmt
    &AtomicI8, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::sync::atomic::AtomicU8::fmt
    &AtomicU8, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::sync::atomic::AtomicI16::fmt
    &AtomicI16, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::sync::atomic::AtomicU16::fmt
    &AtomicU16, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::sync::atomic::AtomicI32::fmt
    &AtomicI32, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::sync::atomic::AtomicU32::fmt
    &AtomicU32, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::sync::atomic::AtomicI64::fmt
    &AtomicI64, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::sync::atomic::AtomicU64::fmt
    &AtomicU64, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::sync::atomic::AtomicIsize::fmt
    &AtomicIsize, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::sync::atomic::AtomicUsize::fmt
    &AtomicUsize, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::sync::mpmc::RecvError::fmt
    &RecvError, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::sync::mpmc::TryRecvError::fmt
    &TryRecvError, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::sync::mpmc::RecvTimeoutError::fmt
    &RecvTimeoutError, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::fmt::Formatter::pad
    &mut Formatter, &str -> Result<(), Error>
    Takes a string slice and emits it to the internal buffer …
    method
    radix_rust::rust::prelude::Arc::seek
    &mut Arc<File>, SeekFrom -> Result<u64, Error>
    method
    radix_rust::rust::boxed::ThinBox::source
    &ThinBox<T> -> Option<&Error>
    method
    radix_rust::rust::prelude::Arc::read_buf
    &mut Arc<File>, BorrowedCursor -> Result<(), Error>
    trait method
    radix_rust::rust::fmt::Write::write_str
    &mut Write, &str -> Result<(), Error>
    Writes a string slice into this writer, returning whether …
    method
    radix_rust::rust::fmt::Formatter::write_str
    &mut Formatter, &str -> Result<(), Error>
    Writes some data to the underlying buffer contained within …
    method
    radix_rust::rust::prelude::String::write_str
    &mut String, &str -> Result<(), Error>
    method
    radix_rust::rust::hash::BuildHasherDefault::fmt
    &BuildHasherDefault<H>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::iter::Empty::fmt
    &Empty<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::iter::FromCoroutine::fmt
    &FromCoroutine<G>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::iter::FromFn::fmt
    &FromFn<F>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::iter::OnceWith::fmt
    &OnceWith<F>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::iter::RepeatWith::fmt
    &RepeatWith<F>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::mem::Discriminant::fmt
    &Discriminant<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::mem::MaybeUninit::fmt
    &MaybeUninit<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::sync::PoisonError::fmt
    &PoisonError<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::sync::TryLockError::fmt
    &TryLockError<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::sync::atomic::AtomicPtr::fmt
    &AtomicPtr<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::sync::mpmc::Sender::fmt
    &Sender<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::sync::mpmc::Receiver::fmt
    &Receiver<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::sync::mpmc::SendTimeoutError::fmt
    &SendTimeoutError<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::sync::mpmc::SendError::fmt
    &SendError<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::sync::mpmc::TrySendError::fmt
    &TrySendError<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::sync::mpsc::Receiver::fmt
    &Receiver<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::sync::mpsc::Sender::fmt
    &Sender<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::sync::mpsc::SyncSender::fmt
    &SyncSender<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::collections::VecDeque::flush
    &mut VecDeque<u8, A> -> Result<(), Error>
    method
    radix_rust::rust::prelude::Box::flush
    &mut Box<W> -> Result<(), Error>
    method
    radix_rust::rust::prelude::Vec::flush
    &mut Vec<u8, A> -> Result<(), Error>
    method
    radix_rust::rust::prelude::Box::rewind
    &mut Box<S> -> Result<(), Error>
    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::stream_position
    &mut Box<S> -> Result<u64, Error>
    method
    radix_rust::rust::cmp::Reverse::fmt
    &Reverse<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::collections::btree_set::Iter::fmt
    &Iter<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::collections::btree_set::SymmetricDifference::fmt
    &SymmetricDifference<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::collections::btree_set::Union::fmt
    &Union<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::collections::btree_set::Range::fmt
    &Range<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::collections::btree_set::Cursor::fmt
    &Cursor<K>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::collections::hash_set::Iter::fmt
    &Iter<K>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::collections::hash_set::IntoIter::fmt
    &IntoIter<K>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::collections::hash_set::Drain::fmt
    &Drain<K>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::iter::RepeatN::fmt
    &RepeatN<A>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::iter::ByRefSized::fmt
    &ByRefSized<I>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::iter::Cloned::fmt
    &Cloned<I>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::iter::Copied::fmt
    &Copied<I>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::iter::Cycle::fmt
    &Cycle<I>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::iter::Enumerate::fmt
    &Enumerate<I>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::iter::Fuse::fmt
    &Fuse<I>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::iter::Rev::fmt
    &Rev<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::iter::Skip::fmt
    &Skip<I>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::iter::StepBy::fmt
    &StepBy<I>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::iter::Take::fmt
    &Take<I>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::iter::Once::fmt
    &Once<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::iter::Repeat::fmt
    &Repeat<A>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::marker::PhantomCovariant::fmt
    &PhantomCovariant<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::marker::PhantomContravariant::fmt
    &PhantomContravariant<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::marker::PhantomInvariant::fmt
    &PhantomInvariant<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::num::Saturating::fmt
    &Saturating<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::num::Wrapping::fmt
    &Wrapping<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::ops::Range::fmt
    &Range<Idx>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::ops::RangeFrom::fmt
    &RangeFrom<Idx>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::ops::RangeTo::fmt
    &RangeTo<Idx>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::ops::RangeInclusive::fmt
    &RangeInclusive<Idx>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::ops::RangeToInclusive::fmt
    &RangeToInclusive<Idx>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::ops::Bound::fmt
    &Bound<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::ops::Yeet::fmt
    &Yeet<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::option::Iter::fmt
    &Iter<A>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::option::IterMut::fmt
    &IterMut<A>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::option::IntoIter::fmt
    &IntoIter<A>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::prelude::PhantomData::fmt
    &PhantomData<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::prelude::OnceCell::fmt
    &OnceCell<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::prelude::UnsafeCell::fmt
    &UnsafeCell<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::prelude::SyncUnsafeCell::fmt
    &SyncUnsafeCell<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::prelude::Option::fmt
    &Option<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::ptr::DynMetadata::fmt
    &DynMetadata<Dyn>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::ptr::NonNull::fmt
    &NonNull<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::result::Iter::fmt
    &Iter<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::result::IterMut::fmt
    &IterMut<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::result::IntoIter::fmt
    &IntoIter<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::slice::Iter::fmt
    &Iter<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::slice::IterMut::fmt
    &IterMut<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::slice::Windows::fmt
    &Windows<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::slice::Chunks::fmt
    &Chunks<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::slice::ChunksMut::fmt
    &ChunksMut<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::slice::ChunksExact::fmt
    &ChunksExact<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::slice::ChunksExactMut::fmt
    &ChunksExactMut<T>, &mut Formatter -> Result<(), Error>
    method
    radix_rust::rust::slice::ArrayWindows::fmt
    &ArrayWindows<T>, &mut Formatter -> Result<(), Error>