Struct jlrs::call::WithKeywords
source · pub struct WithKeywords<'scope, 'data> { /* private fields */ }Expand description
A function and its keyword arguments.
Implementations§
Trait Implementations§
source§impl<'data> Call<'data> for WithKeywords<'_, 'data>
impl<'data> Call<'data> for WithKeywords<'_, 'data>
source§unsafe fn call0<'target, T>(self, target: T) -> ValueResult<'target, 'data, T>where
T: Target<'target>,
unsafe fn call0<'target, T>(self, target: T) -> ValueResult<'target, 'data, T>where
T: Target<'target>,
Call a function with no arguments. Read more
source§unsafe fn call1<'target, T>(
self,
target: T,
arg0: Value<'_, 'data>
) -> ValueResult<'target, 'data, T>where
T: Target<'target>,
unsafe fn call1<'target, T>(
self,
target: T,
arg0: Value<'_, 'data>
) -> ValueResult<'target, 'data, T>where
T: Target<'target>,
Call a function with one argument. Read more
source§unsafe fn call2<'target, T>(
self,
target: T,
arg0: Value<'_, 'data>,
arg1: Value<'_, 'data>
) -> ValueResult<'target, 'data, T>where
T: Target<'target>,
unsafe fn call2<'target, T>(
self,
target: T,
arg0: Value<'_, 'data>,
arg1: Value<'_, 'data>
) -> ValueResult<'target, 'data, T>where
T: Target<'target>,
Call a function with two arguments. Read more
source§unsafe fn call3<'target, T>(
self,
target: T,
arg0: Value<'_, 'data>,
arg1: Value<'_, 'data>,
arg2: Value<'_, 'data>
) -> ValueResult<'target, 'data, T>where
T: Target<'target>,
unsafe fn call3<'target, T>(
self,
target: T,
arg0: Value<'_, 'data>,
arg1: Value<'_, 'data>,
arg2: Value<'_, 'data>
) -> ValueResult<'target, 'data, T>where
T: Target<'target>,
Call a function with three arguments. Read more
source§unsafe fn call<'target, 'value, V, T, const N: usize>(
self,
target: T,
args: V
) -> ValueResult<'target, 'data, T>
unsafe fn call<'target, 'value, V, T, const N: usize>( self, target: T, args: V ) -> ValueResult<'target, 'data, T>
Call a function with an arbitrary number arguments. Read more
unsafe fn call_unchecked<'target, 'value, V, T, const N: usize>( self, target: T, args: V ) -> ValueData<'target, 'data, T>
source§unsafe fn call_tracked<'target, 'value, V, T>(
self,
target: T,
args: V
) -> JlrsResult<ValueResult<'target, 'data, T>>
unsafe fn call_tracked<'target, 'value, V, T>( self, target: T, args: V ) -> JlrsResult<ValueResult<'target, 'data, T>>
Call a function with an arbitrary number arguments. Read more
source§impl<'data> CallAsync<'data> for WithKeywords<'_, 'data>
impl<'data> CallAsync<'data> for WithKeywords<'_, 'data>
source§unsafe fn call_async<'target, 'value, 'life0, 'async_trait, V, const N: usize>(
self,
frame: &'life0 mut AsyncGcFrame<'target>,
args: V
) -> Pin<Box<dyn Future<Output = JuliaResult<'target, 'data>> + 'async_trait>>where
V: Values<'value, 'data, N> + 'async_trait,
Self: 'async_trait,
'target: 'async_trait,
'value: 'async_trait,
'life0: 'async_trait,
unsafe fn call_async<'target, 'value, 'life0, 'async_trait, V, const N: usize>(
self,
frame: &'life0 mut AsyncGcFrame<'target>,
args: V
) -> Pin<Box<dyn Future<Output = JuliaResult<'target, 'data>> + 'async_trait>>where
V: Values<'value, 'data, N> + 'async_trait,
Self: 'async_trait,
'target: 'async_trait,
'value: 'async_trait,
'life0: 'async_trait,
Creates and schedules a new task with
Base.Threads.@spawn, and returns a future
that resolves when this task is finished. Read moresource§unsafe fn call_async_interactive<'target, 'value, 'life0, 'async_trait, V, const N: usize>(
self,
frame: &'life0 mut AsyncGcFrame<'target>,
args: V
) -> Pin<Box<dyn Future<Output = JuliaResult<'target, 'data>> + 'async_trait>>where
V: Values<'value, 'data, N> + 'async_trait,
Self: 'async_trait,
'target: 'async_trait,
'value: 'async_trait,
'life0: 'async_trait,
unsafe fn call_async_interactive<'target, 'value, 'life0, 'async_trait, V, const N: usize>(
self,
frame: &'life0 mut AsyncGcFrame<'target>,
args: V
) -> Pin<Box<dyn Future<Output = JuliaResult<'target, 'data>> + 'async_trait>>where
V: Values<'value, 'data, N> + 'async_trait,
Self: 'async_trait,
'target: 'async_trait,
'value: 'async_trait,
'life0: 'async_trait,
Call a function on another thread with the given arguments. This method uses
Base.Threads.@spawn to call the given function on another thread but return immediately.
While awaiting the result the async runtime can work on other tasks, the current task
resumes after the function call on the other thread completes. Read moresource§unsafe fn schedule_async_interactive<'target, 'value, V, const N: usize>(
self,
frame: &mut AsyncGcFrame<'target>,
args: V
) -> JuliaResult<'target, 'data, Task<'target>>where
V: Values<'value, 'data, N>,
unsafe fn schedule_async_interactive<'target, 'value, V, const N: usize>(
self,
frame: &mut AsyncGcFrame<'target>,
args: V
) -> JuliaResult<'target, 'data, Task<'target>>where
V: Values<'value, 'data, N>,
Does the same thing as
CallAsync::call_async, but the task is returned rather than an
awaitable Future. This method should only be called in PersistentTask::init,
otherwise it’s not guaranteed this task can make progress. Read moresource§unsafe fn schedule_async<'target, 'value, V, const N: usize>(
self,
frame: &mut AsyncGcFrame<'target>,
args: V
) -> JuliaResult<'target, 'data, Task<'target>>where
V: Values<'value, 'data, N>,
unsafe fn schedule_async<'target, 'value, V, const N: usize>(
self,
frame: &mut AsyncGcFrame<'target>,
args: V
) -> JuliaResult<'target, 'data, Task<'target>>where
V: Values<'value, 'data, N>,
Does the same thing as
CallAsync::call_async, but the task is returned rather than an
awaitable Future. This method should only be called in PersistentTask::init,
otherwise it’s not guaranteed this task can make progress. Read moresource§unsafe fn call_async_local<'target, 'value, 'life0, 'async_trait, V, const N: usize>(
self,
frame: &'life0 mut AsyncGcFrame<'target>,
args: V
) -> Pin<Box<dyn Future<Output = JuliaResult<'target, 'data>> + 'async_trait>>where
V: Values<'value, 'data, N> + 'async_trait,
Self: 'async_trait,
'target: 'async_trait,
'value: 'async_trait,
'life0: 'async_trait,
unsafe fn call_async_local<'target, 'value, 'life0, 'async_trait, V, const N: usize>(
self,
frame: &'life0 mut AsyncGcFrame<'target>,
args: V
) -> Pin<Box<dyn Future<Output = JuliaResult<'target, 'data>> + 'async_trait>>where
V: Values<'value, 'data, N> + 'async_trait,
Self: 'async_trait,
'target: 'async_trait,
'value: 'async_trait,
'life0: 'async_trait,
Call a function with the given arguments in an
@async block. Like call_async, the
function is not called on the main thread, but on a separate thread that handles all
tasks created by this method. This method should only be used with functions that do very
little computational work but mostly spend their time waiting on IO. Read moresource§unsafe fn schedule_async_local<'target, 'value, V, const N: usize>(
self,
frame: &mut AsyncGcFrame<'target>,
args: V
) -> JuliaResult<'target, 'data, Task<'target>>where
V: Values<'value, 'data, N>,
unsafe fn schedule_async_local<'target, 'value, V, const N: usize>(
self,
frame: &mut AsyncGcFrame<'target>,
args: V
) -> JuliaResult<'target, 'data, Task<'target>>where
V: Values<'value, 'data, N>,
Does the same thing as
CallAsync::call_async_local, but the task is returned rather
than an awaitable Future. This method should only be called in PersistentTask::init,
otherwise it’s not guaranteed this task can make progress. Read moresource§unsafe fn call_async_main<'target, 'value, 'life0, 'async_trait, V, const N: usize>(
self,
frame: &'life0 mut AsyncGcFrame<'target>,
args: V
) -> Pin<Box<dyn Future<Output = JuliaResult<'target, 'data>> + 'async_trait>>where
V: Values<'value, 'data, N> + 'async_trait,
Self: 'async_trait,
'target: 'async_trait,
'value: 'async_trait,
'life0: 'async_trait,
unsafe fn call_async_main<'target, 'value, 'life0, 'async_trait, V, const N: usize>(
self,
frame: &'life0 mut AsyncGcFrame<'target>,
args: V
) -> Pin<Box<dyn Future<Output = JuliaResult<'target, 'data>> + 'async_trait>>where
V: Values<'value, 'data, N> + 'async_trait,
Self: 'async_trait,
'target: 'async_trait,
'value: 'async_trait,
'life0: 'async_trait,
Call a function with the given arguments in an
@async block. The task is scheduled on
the main thread. This method should only be used with functions that must run on the main
thread. The runtime is blocked while this task is active. Read moresource§unsafe fn schedule_async_main<'target, 'value, V, const N: usize>(
self,
frame: &mut AsyncGcFrame<'target>,
args: V
) -> JuliaResult<'target, 'data, Task<'target>>where
V: Values<'value, 'data, N>,
unsafe fn schedule_async_main<'target, 'value, V, const N: usize>(
self,
frame: &mut AsyncGcFrame<'target>,
args: V
) -> JuliaResult<'target, 'data, Task<'target>>where
V: Values<'value, 'data, N>,
Does the same thing as
CallAsync::call_async_main, but the task is returned rather
than an awaitable Future. This method should only be called in PersistentTask::init,
otherwise it’s not guaranteed this task can make progress. Read moresource§unsafe fn call_async_tracked<'target, 'value, 'life0, 'async_trait, V, const N: usize>(
self,
frame: &'life0 mut AsyncGcFrame<'target>,
args: V
) -> Pin<Box<dyn Future<Output = JlrsResult<JuliaResult<'target, 'data>>> + 'async_trait>>where
V: Values<'value, 'data, N> + 'async_trait,
Self: 'async_trait,
'target: 'async_trait,
'value: 'async_trait,
'life0: 'async_trait,
unsafe fn call_async_tracked<'target, 'value, 'life0, 'async_trait, V, const N: usize>(
self,
frame: &'life0 mut AsyncGcFrame<'target>,
args: V
) -> Pin<Box<dyn Future<Output = JlrsResult<JuliaResult<'target, 'data>>> + 'async_trait>>where
V: Values<'value, 'data, N> + 'async_trait,
Self: 'async_trait,
'target: 'async_trait,
'value: 'async_trait,
'life0: 'async_trait,
Creates and schedules a new task with
Base.Threads.@spawn, and returns a future
that resolves when this task is finished. Read moresource§unsafe fn schedule_async_tracked<'target, 'value, V, T, const N: usize>(
self,
frame: &mut AsyncGcFrame<'target>,
args: V
) -> JlrsResult<JuliaResult<'target, 'data, Task<'target>>>
unsafe fn schedule_async_tracked<'target, 'value, V, T, const N: usize>( self, frame: &mut AsyncGcFrame<'target>, args: V ) -> JlrsResult<JuliaResult<'target, 'data, Task<'target>>>
Does the same thing as
CallAsync::call_async, but the task is returned rather than an
awaitable Future. This method should only be called in PersistentTask::init,
otherwise it’s not guaranteed this task can make progress. Read moresource§unsafe fn call_async_interactive_tracked<'target, 'value, 'life0, 'async_trait, V, const N: usize>(
self,
frame: &'life0 mut AsyncGcFrame<'target>,
args: V
) -> Pin<Box<dyn Future<Output = JlrsResult<JuliaResult<'target, 'data>>> + 'async_trait>>where
V: Values<'value, 'data, N> + 'async_trait,
Self: 'async_trait,
'target: 'async_trait,
'value: 'async_trait,
'life0: 'async_trait,
unsafe fn call_async_interactive_tracked<'target, 'value, 'life0, 'async_trait, V, const N: usize>(
self,
frame: &'life0 mut AsyncGcFrame<'target>,
args: V
) -> Pin<Box<dyn Future<Output = JlrsResult<JuliaResult<'target, 'data>>> + 'async_trait>>where
V: Values<'value, 'data, N> + 'async_trait,
Self: 'async_trait,
'target: 'async_trait,
'value: 'async_trait,
'life0: 'async_trait,
Call a function on another thread with the given arguments. This method uses
Base.Threads.@spawn to call the given function on another thread but return immediately.
While awaiting the result the async runtime can work on other tasks, the current task
resumes after the function call on the other thread completes. Read moresource§unsafe fn schedule_async_interactive_tracked<'target, 'value, V, T, const N: usize>(
self,
frame: &mut AsyncGcFrame<'target>,
args: V
) -> JlrsResult<JuliaResult<'target, 'data, Task<'target>>>
unsafe fn schedule_async_interactive_tracked<'target, 'value, V, T, const N: usize>( self, frame: &mut AsyncGcFrame<'target>, args: V ) -> JlrsResult<JuliaResult<'target, 'data, Task<'target>>>
Does the same thing as
CallAsync::call_async, but the task is returned rather than an
awaitable Future. This method should only be called in PersistentTask::init,
otherwise it’s not guaranteed this task can make progress. Read moresource§unsafe fn call_async_local_tracked<'target, 'value, 'life0, 'async_trait, V, const N: usize>(
self,
frame: &'life0 mut AsyncGcFrame<'target>,
args: V
) -> Pin<Box<dyn Future<Output = JlrsResult<JuliaResult<'target, 'data>>> + 'async_trait>>where
V: Values<'value, 'data, N> + 'async_trait,
Self: 'async_trait,
'target: 'async_trait,
'value: 'async_trait,
'life0: 'async_trait,
unsafe fn call_async_local_tracked<'target, 'value, 'life0, 'async_trait, V, const N: usize>(
self,
frame: &'life0 mut AsyncGcFrame<'target>,
args: V
) -> Pin<Box<dyn Future<Output = JlrsResult<JuliaResult<'target, 'data>>> + 'async_trait>>where
V: Values<'value, 'data, N> + 'async_trait,
Self: 'async_trait,
'target: 'async_trait,
'value: 'async_trait,
'life0: 'async_trait,
Call a function with the given arguments in an
@async block. Like call_async, the
function is not called on the main thread, but on a separate thread that handles all
tasks created by this method. This method should only be used with functions that do very
little computational work but mostly spend their time waiting on IO. Read moresource§unsafe fn schedule_async_local_tracked<'target, 'value, V, T, const N: usize>(
self,
frame: &mut AsyncGcFrame<'target>,
args: V
) -> JlrsResult<JuliaResult<'target, 'data, Task<'target>>>
unsafe fn schedule_async_local_tracked<'target, 'value, V, T, const N: usize>( self, frame: &mut AsyncGcFrame<'target>, args: V ) -> JlrsResult<JuliaResult<'target, 'data, Task<'target>>>
Does the same thing as
CallAsync::call_async_local, but the task is returned rather
than an awaitable Future. This method should only be called in PersistentTask::init,
otherwise it’s not guaranteed this task can make progress. Read moresource§unsafe fn call_async_main_tracked<'target, 'value, 'life0, 'async_trait, V, const N: usize>(
self,
frame: &'life0 mut AsyncGcFrame<'target>,
args: V
) -> Pin<Box<dyn Future<Output = JlrsResult<JuliaResult<'target, 'data>>> + 'async_trait>>where
V: Values<'value, 'data, N> + 'async_trait,
Self: 'async_trait,
'target: 'async_trait,
'value: 'async_trait,
'life0: 'async_trait,
unsafe fn call_async_main_tracked<'target, 'value, 'life0, 'async_trait, V, const N: usize>(
self,
frame: &'life0 mut AsyncGcFrame<'target>,
args: V
) -> Pin<Box<dyn Future<Output = JlrsResult<JuliaResult<'target, 'data>>> + 'async_trait>>where
V: Values<'value, 'data, N> + 'async_trait,
Self: 'async_trait,
'target: 'async_trait,
'value: 'async_trait,
'life0: 'async_trait,
Call a function with the given arguments in an
@async block. The task is scheduled on
the main thread. This method should only be used with functions that must run on the main
thread. The runtime is blocked while this task is active. Read moresource§unsafe fn schedule_async_main_tracked<'target, 'value, V, T, const N: usize>(
self,
frame: &mut AsyncGcFrame<'target>,
args: V
) -> JlrsResult<JuliaResult<'target, 'data, Task<'target>>>
unsafe fn schedule_async_main_tracked<'target, 'value, V, T, const N: usize>( self, frame: &mut AsyncGcFrame<'target>, args: V ) -> JlrsResult<JuliaResult<'target, 'data, Task<'target>>>
Does the same thing as
CallAsync::call_async_main, but the task is returned rather
than an awaitable Future. This method should only be called in PersistentTask::init,
otherwise it’s not guaranteed this task can make progress. Read moreAuto Trait Implementations§
impl<'scope, 'data> RefUnwindSafe for WithKeywords<'scope, 'data>
impl<'scope, 'data> !Send for WithKeywords<'scope, 'data>
impl<'scope, 'data> !Sync for WithKeywords<'scope, 'data>
impl<'scope, 'data> Unpin for WithKeywords<'scope, 'data>
impl<'scope, 'data> !UnwindSafe for WithKeywords<'scope, 'data>
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> Conv for T
impl<T> Conv for T
§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.§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.§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.§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.§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.§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.§fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
Formats each item in a sequence. Read more
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> Pipe for Twhere
T: ?Sized,
impl<T> Pipe for Twhere
T: ?Sized,
§fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
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) -> Rwhere
R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
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) -> Rwhere
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
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
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
§fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R
fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R ) -> R
§fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
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
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
Mutably borrows
self, then passes self.as_mut() into the pipe
function.§fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
Borrows
self, then passes self.deref() into the pipe function.§impl<T> Tap for T
impl<T> Tap for T
§fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
Immutable access to the
Borrow<B> of a value. Read more§fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
Mutable access to the
BorrowMut<B> of a value. Read more§fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
Immutable access to the
AsRef<R> view of a value. Read more§fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
Mutable access to the
AsMut<R> view of a value. Read more§fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
Immutable access to the
Deref::Target of a value. Read more§fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
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.§fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
Calls
.tap_borrow() only in debug builds, and is erased in release
builds.§fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
Calls
.tap_borrow_mut() only in debug builds, and is erased in release
builds.§fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
Calls
.tap_ref() only in debug builds, and is erased in release
builds.§fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
Calls
.tap_ref_mut() only in debug builds, and is erased in release
builds.§fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
Calls
.tap_deref() only in debug builds, and is erased in release
builds.