Struct tract_pulse::internal::fmt::Formatter 1.0.0[−][src]
pub struct Formatter<'a> { /* fields omitted */ }
Expand description
Configuration for formatting.
A Formatter
represents various options related to formatting. Users do not
construct Formatter
s directly; a mutable reference to one is passed to
the fmt
method of all formatting traits, like Debug
and Display
.
To interact with a Formatter
, you’ll call various methods to change the
various options related to formatting. For examples, please see the
documentation of the methods defined on Formatter
below.
Implementations
impl<'a> Formatter<'a>
[src]
impl<'a> Formatter<'a>
[src]pub fn pad_integral(
&mut self,
is_nonnegative: bool,
prefix: &str,
buf: &str
) -> Result<(), Error>
[src]
pub fn pad_integral(
&mut self,
is_nonnegative: bool,
prefix: &str,
buf: &str
) -> Result<(), Error>
[src]Performs the correct padding for an integer which has already been emitted into a str. The str should not contain the sign for the integer, that will be added by this method.
Arguments
- is_nonnegative - whether the original integer was either positive or zero.
- prefix - if the ‘#’ character (Alternate) is provided, this is the prefix to put in front of the number.
- buf - the byte array that the number has been formatted into
This function will correctly account for the flags provided as well as the minimum width. It will not take precision into account.
Examples
use std::fmt; struct Foo { nb: i32 } impl Foo { fn new(nb: i32) -> Foo { Foo { nb, } } } impl fmt::Display for Foo { fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { // We need to remove "-" from the number output. let tmp = self.nb.abs().to_string(); formatter.pad_integral(self.nb > 0, "Foo ", &tmp) } } assert_eq!(&format!("{}", Foo::new(2)), "2"); assert_eq!(&format!("{}", Foo::new(-1)), "-1"); assert_eq!(&format!("{:#}", Foo::new(-1)), "-Foo 1"); assert_eq!(&format!("{:0>#8}", Foo::new(-1)), "00-Foo 1");
pub fn pad(&mut self, s: &str) -> Result<(), Error>
[src]
pub fn pad(&mut self, s: &str) -> Result<(), Error>
[src]This function takes a string slice and emits it to the internal buffer after applying the relevant formatting flags specified. The flags recognized for generic strings are:
- width - the minimum width of what to emit
- fill/align - what to emit and where to emit it if the string provided needs to be padded
- precision - the maximum length to emit, the string is truncated if it is longer than this length
Notably this function ignores the flag
parameters.
Examples
use std::fmt; struct Foo; impl fmt::Display for Foo { fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.pad("Foo") } } assert_eq!(&format!("{:<4}", Foo), "Foo "); assert_eq!(&format!("{:0>4}", Foo), "0Foo");
pub fn write_str(&mut self, data: &str) -> Result<(), Error>
[src]
pub fn write_str(&mut self, data: &str) -> Result<(), Error>
[src]Writes some data to the underlying buffer contained within this formatter.
Examples
use std::fmt; struct Foo; impl fmt::Display for Foo { fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("Foo") // This is equivalent to: // write!(formatter, "Foo") } } assert_eq!(&format!("{}", Foo), "Foo"); assert_eq!(&format!("{:0>8}", Foo), "Foo");
pub fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>
[src]
pub fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>
[src]Writes some formatted information into this instance.
Examples
use std::fmt; struct Foo(i32); impl fmt::Display for Foo { fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_fmt(format_args!("Foo {}", self.0)) } } assert_eq!(&format!("{}", Foo(-1)), "Foo -1"); assert_eq!(&format!("{:0>8}", Foo(2)), "Foo 2");
pub fn flags(&self) -> u32
[src]
👎 Deprecated since 1.24.0: use the sign_plus
, sign_minus
, alternate
, or sign_aware_zero_pad
methods instead
pub fn flags(&self) -> u32
[src]use the sign_plus
, sign_minus
, alternate
, or sign_aware_zero_pad
methods instead
Flags for formatting
pub fn fill(&self) -> char
1.5.0[src]
pub fn fill(&self) -> char
1.5.0[src]Character used as ‘fill’ whenever there is alignment.
Examples
use std::fmt; struct Foo; impl fmt::Display for Foo { fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { let c = formatter.fill(); if let Some(width) = formatter.width() { for _ in 0..width { write!(formatter, "{}", c)?; } Ok(()) } else { write!(formatter, "{}", c) } } } // We set alignment to the right with ">". assert_eq!(&format!("{:G>3}", Foo), "GGG"); assert_eq!(&format!("{:t>6}", Foo), "tttttt");
pub fn align(&self) -> Option<Alignment>
1.28.0[src]
pub fn align(&self) -> Option<Alignment>
1.28.0[src]Flag indicating what form of alignment was requested.
Examples
extern crate core; use std::fmt::{self, Alignment}; struct Foo; impl fmt::Display for Foo { fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { let s = if let Some(s) = formatter.align() { match s { Alignment::Left => "left", Alignment::Right => "right", Alignment::Center => "center", } } else { "into the void" }; write!(formatter, "{}", s) } } assert_eq!(&format!("{:<}", Foo), "left"); assert_eq!(&format!("{:>}", Foo), "right"); assert_eq!(&format!("{:^}", Foo), "center"); assert_eq!(&format!("{}", Foo), "into the void");
pub fn width(&self) -> Option<usize>
1.5.0[src]
pub fn width(&self) -> Option<usize>
1.5.0[src]Optionally specified integer width that the output should be.
Examples
use std::fmt; struct Foo(i32); impl fmt::Display for Foo { fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { if let Some(width) = formatter.width() { // If we received a width, we use it write!(formatter, "{:width$}", &format!("Foo({})", self.0), width = width) } else { // Otherwise we do nothing special write!(formatter, "Foo({})", self.0) } } } assert_eq!(&format!("{:10}", Foo(23)), "Foo(23) "); assert_eq!(&format!("{}", Foo(23)), "Foo(23)");
pub fn precision(&self) -> Option<usize>
1.5.0[src]
pub fn precision(&self) -> Option<usize>
1.5.0[src]Optionally specified precision for numeric types. Alternatively, the maximum width for string types.
Examples
use std::fmt; struct Foo(f32); impl fmt::Display for Foo { fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { if let Some(precision) = formatter.precision() { // If we received a precision, we use it. write!(formatter, "Foo({1:.*})", precision, self.0) } else { // Otherwise we default to 2. write!(formatter, "Foo({:.2})", self.0) } } } assert_eq!(&format!("{:.4}", Foo(23.2)), "Foo(23.2000)"); assert_eq!(&format!("{}", Foo(23.2)), "Foo(23.20)");
pub fn sign_plus(&self) -> bool
1.5.0[src]
pub fn sign_plus(&self) -> bool
1.5.0[src]Determines if the +
flag was specified.
Examples
use std::fmt; struct Foo(i32); impl fmt::Display for Foo { fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { if formatter.sign_plus() { write!(formatter, "Foo({}{})", if self.0 < 0 { '-' } else { '+' }, self.0) } else { write!(formatter, "Foo({})", self.0) } } } assert_eq!(&format!("{:+}", Foo(23)), "Foo(+23)"); assert_eq!(&format!("{}", Foo(23)), "Foo(23)");
pub fn sign_minus(&self) -> bool
1.5.0[src]
pub fn sign_minus(&self) -> bool
1.5.0[src]Determines if the -
flag was specified.
Examples
use std::fmt; struct Foo(i32); impl fmt::Display for Foo { fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { if formatter.sign_minus() { // You want a minus sign? Have one! write!(formatter, "-Foo({})", self.0) } else { write!(formatter, "Foo({})", self.0) } } } assert_eq!(&format!("{:-}", Foo(23)), "-Foo(23)"); assert_eq!(&format!("{}", Foo(23)), "Foo(23)");
pub fn alternate(&self) -> bool
1.5.0[src]
pub fn alternate(&self) -> bool
1.5.0[src]Determines if the #
flag was specified.
Examples
use std::fmt; struct Foo(i32); impl fmt::Display for Foo { fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { if formatter.alternate() { write!(formatter, "Foo({})", self.0) } else { write!(formatter, "{}", self.0) } } } assert_eq!(&format!("{:#}", Foo(23)), "Foo(23)"); assert_eq!(&format!("{}", Foo(23)), "23");
pub fn sign_aware_zero_pad(&self) -> bool
1.5.0[src]
pub fn sign_aware_zero_pad(&self) -> bool
1.5.0[src]Determines if the 0
flag was specified.
Examples
use std::fmt; struct Foo(i32); impl fmt::Display for Foo { fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { assert!(formatter.sign_aware_zero_pad()); assert_eq!(formatter.width(), Some(4)); // We ignore the formatter's options. write!(formatter, "{}", self.0) } } assert_eq!(&format!("{:04}", Foo(23)), "23");
pub fn debug_struct(&'b mut self, name: &str) -> DebugStruct<'b, 'a>
1.2.0[src]
pub fn debug_struct(&'b mut self, name: &str) -> DebugStruct<'b, 'a>
1.2.0[src]Creates a DebugStruct
builder designed to assist with creation of
fmt::Debug
implementations for structs.
Examples
use std::fmt; use std::net::Ipv4Addr; struct Foo { bar: i32, baz: String, addr: Ipv4Addr, } impl fmt::Debug for Foo { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("Foo") .field("bar", &self.bar) .field("baz", &self.baz) .field("addr", &format_args!("{}", self.addr)) .finish() } } assert_eq!( "Foo { bar: 10, baz: \"Hello World\", addr: 127.0.0.1 }", format!("{:?}", Foo { bar: 10, baz: "Hello World".to_string(), addr: Ipv4Addr::new(127, 0, 0, 1), }) );
pub fn debug_tuple(&'b mut self, name: &str) -> DebugTuple<'b, 'a>
1.2.0[src]
pub fn debug_tuple(&'b mut self, name: &str) -> DebugTuple<'b, 'a>
1.2.0[src]Creates a DebugTuple
builder designed to assist with creation of
fmt::Debug
implementations for tuple structs.
Examples
use std::fmt; use std::marker::PhantomData; struct Foo<T>(i32, String, PhantomData<T>); impl<T> fmt::Debug for Foo<T> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_tuple("Foo") .field(&self.0) .field(&self.1) .field(&format_args!("_")) .finish() } } assert_eq!( "Foo(10, \"Hello\", _)", format!("{:?}", Foo(10, "Hello".to_string(), PhantomData::<u8>)) );
pub fn debug_list(&'b mut self) -> DebugList<'b, 'a>
1.2.0[src]
pub fn debug_list(&'b mut self) -> DebugList<'b, 'a>
1.2.0[src]Creates a DebugList
builder designed to assist with creation of
fmt::Debug
implementations for list-like structures.
Examples
use std::fmt; struct Foo(Vec<i32>); impl fmt::Debug for Foo { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_list().entries(self.0.iter()).finish() } } assert_eq!(format!("{:?}", Foo(vec![10, 11])), "[10, 11]");
pub fn debug_set(&'b mut self) -> DebugSet<'b, 'a>
1.2.0[src]
pub fn debug_set(&'b mut self) -> DebugSet<'b, 'a>
1.2.0[src]Creates a DebugSet
builder designed to assist with creation of
fmt::Debug
implementations for set-like structures.
Examples
use std::fmt; struct Foo(Vec<i32>); impl fmt::Debug for Foo { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_set().entries(self.0.iter()).finish() } } assert_eq!(format!("{:?}", Foo(vec![10, 11])), "{10, 11}");
In this more complex example, we use format_args!
and .debug_set()
to build a list of match arms:
use std::fmt; struct Arm<'a, L: 'a, R: 'a>(&'a (L, R)); struct Table<'a, K: 'a, V: 'a>(&'a [(K, V)], V); impl<'a, L, R> fmt::Debug for Arm<'a, L, R> where L: 'a + fmt::Debug, R: 'a + fmt::Debug { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { L::fmt(&(self.0).0, fmt)?; fmt.write_str(" => ")?; R::fmt(&(self.0).1, fmt) } } impl<'a, K, V> fmt::Debug for Table<'a, K, V> where K: 'a + fmt::Debug, V: 'a + fmt::Debug { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_set() .entries(self.0.iter().map(Arm)) .entry(&Arm(&(format_args!("_"), &self.1))) .finish() } }
pub fn debug_map(&'b mut self) -> DebugMap<'b, 'a>
1.2.0[src]
pub fn debug_map(&'b mut self) -> DebugMap<'b, 'a>
1.2.0[src]Creates a DebugMap
builder designed to assist with creation of
fmt::Debug
implementations for map-like structures.
Examples
use std::fmt; struct Foo(Vec<(String, i32)>); impl fmt::Debug for Foo { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_map().entries(self.0.iter().map(|&(ref k, ref v)| (k, v))).finish() } } assert_eq!( format!("{:?}", Foo(vec![("A".to_string(), 10), ("B".to_string(), 11)])), r#"{"A": 10, "B": 11}"# );
Trait Implementations
Auto Trait Implementations
impl<'a> !RefUnwindSafe for Formatter<'a>
impl<'a> !Send for Formatter<'a>
impl<'a> !Sync for Formatter<'a>
impl<'a> Unpin for Formatter<'a>
impl<'a> !UnwindSafe for Formatter<'a>
Blanket Implementations
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]pub fn borrow_mut(&mut self) -> &mut T
[src]
pub fn borrow_mut(&mut self) -> &mut T
[src]Mutably borrows from an owned value. Read more
impl<T> Downcast for T where
T: Any,
[src]
impl<T> Downcast for T where
T: Any,
[src]pub fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>ⓘNotable traits for Box<R, Global>
impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
[src]
pub fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>ⓘNotable traits for Box<R, Global>
impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<F, A> Future for Box<F, A> where
A: Allocator + 'static,
F: Future + Unpin + ?Sized, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
A: Allocator,
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
[src]Convert Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
. Box<dyn Any>
can
then be further downcast
into Box<ConcreteType>
where ConcreteType
implements Trait
. Read more
pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
[src]
pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
[src]Convert Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
. Read more
pub fn as_any(&self) -> &(dyn Any + 'static)
[src]
pub fn as_any(&self) -> &(dyn Any + 'static)
[src]Convert &Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s. Read more
pub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
[src]
pub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
[src]Convert &mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s. Read more
impl<T> FmtForward for T
impl<T> FmtForward for T
fn fmt_binary(self) -> FmtBinary<Self> where
Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self> where
Self: Binary,
Causes self
to use its Binary
implementation when Debug
-formatted.
fn fmt_display(self) -> FmtDisplay<Self> where
Self: Display,
fn fmt_display(self) -> FmtDisplay<Self> where
Self: Display,
Causes self
to use its Display
implementation when
Debug
-formatted. Read more
fn fmt_lower_exp(self) -> FmtLowerExp<Self> where
Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self> where
Self: LowerExp,
Causes self
to use its LowerExp
implementation when
Debug
-formatted. Read more
fn fmt_lower_hex(self) -> FmtLowerHex<Self> where
Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self> where
Self: LowerHex,
Causes self
to use its LowerHex
implementation when
Debug
-formatted. Read more
fn fmt_octal(self) -> FmtOctal<Self> where
Self: Octal,
fn fmt_octal(self) -> FmtOctal<Self> where
Self: Octal,
Causes self
to use its Octal
implementation when Debug
-formatted.
fn fmt_pointer(self) -> FmtPointer<Self> where
Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self> where
Self: Pointer,
Causes self
to use its Pointer
implementation when
Debug
-formatted. Read more
fn fmt_upper_exp(self) -> FmtUpperExp<Self> where
Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self> where
Self: UpperExp,
Causes self
to use its UpperExp
implementation when
Debug
-formatted. Read more
fn fmt_upper_hex(self) -> FmtUpperHex<Self> where
Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self> where
Self: UpperHex,
Causes self
to use its UpperHex
implementation when
Debug
-formatted. Read more
impl<T> Pipe for T where
T: ?Sized,
impl<T> Pipe for T where
T: ?Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
Pipes by value. This is generally the method you want to use. Read more
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,
Borrows self
and passes that borrow into the pipe function. Read more
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,
Mutably borrows self
and passes that borrow into the pipe function. Read more
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where
Self: Borrow<B>,
B: 'a + ?Sized,
R: 'a,
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where
Self: Borrow<B>,
B: 'a + ?Sized,
R: 'a,
Borrows self
, then passes self.borrow()
into the pipe function. Read more
fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
B: 'a + ?Sized,
R: 'a,
fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
B: 'a + ?Sized,
R: 'a,
Mutably borrows self
, then passes self.borrow_mut()
into the pipe
function. Read more
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where
Self: AsRef<U>,
R: 'a,
U: 'a + ?Sized,
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where
Self: AsRef<U>,
R: 'a,
U: 'a + ?Sized,
Borrows self
, then passes self.as_ref()
into the pipe function.
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R where
Self: AsMut<U>,
R: 'a,
U: 'a + ?Sized,
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R where
Self: AsMut<U>,
R: 'a,
U: 'a + ?Sized,
Mutably borrows self
, then passes self.as_mut()
into the pipe
function. Read more
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Deref<Target = T>,
T: 'a + ?Sized,
R: 'a,
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Deref<Target = T>,
T: 'a + ?Sized,
R: 'a,
Borrows self
, then passes self.deref()
into the pipe function.
impl<T> PipeAsRef for T
impl<T> PipeAsRef for T
fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: AsRef<T>,
T: 'a,
R: 'a,
fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: AsRef<T>,
T: 'a,
R: 'a,
Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more
fn pipe_as_mut<'a, T, R>(&'a mut self, func: impl FnOnce(&'a mut T) -> R) -> R where
Self: AsMut<T>,
T: 'a,
R: 'a,
fn pipe_as_mut<'a, T, R>(&'a mut self, func: impl FnOnce(&'a mut T) -> R) -> R where
Self: AsMut<T>,
T: 'a,
R: 'a,
Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more
impl<T> PipeBorrow for T
impl<T> PipeBorrow for T
fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Borrow<T>,
T: 'a,
R: 'a,
fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Borrow<T>,
T: 'a,
R: 'a,
Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more
fn pipe_borrow_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
T: 'a,
R: 'a,
fn pipe_borrow_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
T: 'a,
R: 'a,
Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more
impl<T> PipeDeref for T
impl<T> PipeDeref for T
fn pipe_deref<'a, R>(&'a self, func: impl FnOnce(&'a Self::Target) -> R) -> R where
Self: Deref,
R: 'a,
fn pipe_deref<'a, R>(&'a self, func: impl FnOnce(&'a Self::Target) -> R) -> R where
Self: Deref,
R: 'a,
Pipes a dereference into a function that cannot normally be called in suffix position. Read more
fn pipe_deref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,
fn pipe_deref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,
Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more
impl<T> PipeRef for T
impl<T> PipeRef for T
impl<T> Tap for T
impl<T> Tap for T
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
Immutable access to the Borrow<B>
of a value. Read more
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
Mutable access to the BorrowMut<B>
of a value. Read more
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,
Immutable access to the AsRef<R>
view of a value. Read more
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
Mutable access to the AsMut<R>
view of a value. Read more
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self where
Self: Deref<Target = T>,
T: ?Sized,
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self where
Self: Deref<Target = T>,
T: ?Sized,
Immutable access to the Deref::Target
of a value. Read more
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self where
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self where
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
Mutable access to the Deref::Target
of a value. Read more
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
Calls .tap()
only in debug builds, and is erased in release builds.
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
Calls .tap_mut()
only in debug builds, and is erased in release
builds. Read more
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
Calls .tap_borrow()
only in debug builds, and is erased in release
builds. Read more
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
Calls .tap_borrow_mut()
only in debug builds, and is erased in release
builds. Read more
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,
Calls .tap_ref()
only in debug builds, and is erased in release
builds. Read more
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
Calls .tap_ref_mut()
only in debug builds, and is erased in release
builds. Read more
impl<T> Tap for T
impl<T> Tap for T
fn tap<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,
fn tap<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,
Provides immutable access for inspection. Read more
fn tap_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,
fn tap_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,
Calls tap
in debug builds, and does nothing in release builds.
fn tap_mut<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,
fn tap_mut<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,
Provides mutable access for modification. Read more
fn tap_mut_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,
fn tap_mut_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,
Calls tap_mut
in debug builds, and does nothing in release builds.
impl<T, U> TapAsRef<U> for T where
U: ?Sized,
impl<T, U> TapAsRef<U> for T where
U: ?Sized,
fn tap_ref<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,
fn tap_ref<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,
Provides immutable access to the reference for inspection.
fn tap_ref_dbg<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,
fn tap_ref_dbg<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,
Calls tap_ref
in debug builds, and does nothing in release builds.
fn tap_ref_mut<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
fn tap_ref_mut<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
Provides mutable access to the reference for modification.
fn tap_ref_mut_dbg<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
fn tap_ref_mut_dbg<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
Calls tap_ref_mut
in debug builds, and does nothing in release builds.
impl<T, U> TapBorrow<U> for T where
U: ?Sized,
impl<T, U> TapBorrow<U> for T where
U: ?Sized,
fn tap_borrow<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
fn tap_borrow<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
Provides immutable access to the borrow for inspection. Read more
fn tap_borrow_dbg<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
fn tap_borrow_dbg<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
Calls tap_borrow
in debug builds, and does nothing in release builds.
fn tap_borrow_mut<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
fn tap_borrow_mut<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
Provides mutable access to the borrow for modification.
fn tap_borrow_mut_dbg<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
fn tap_borrow_mut_dbg<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
Calls tap_borrow_mut
in debug builds, and does nothing in release
builds. Read more
impl<T> TapDeref for T
impl<T> TapDeref for T
fn tap_deref<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,
fn tap_deref<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,
Immutably dereferences self
for inspection.
fn tap_deref_dbg<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,
fn tap_deref_dbg<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,
Calls tap_deref
in debug builds, and does nothing in release builds.
fn tap_deref_mut<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
fn tap_deref_mut<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
Mutably dereferences self
for modification.
fn tap_deref_mut_dbg<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
fn tap_deref_mut_dbg<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
Calls tap_deref_mut
in debug builds, and does nothing in release
builds. Read more