#[repr(transparent)]pub struct Function<'scope, 'data> { /* private fields */ }Expand description
A Julia function.
Implementations§
Trait Implementations§
source§impl<'scope, 'data> CCallArg for Function<'scope, 'data>
impl<'scope, 'data> CCallArg for Function<'scope, 'data>
type CCallArgType = Value<'scope, 'data>
type FunctionArgType = Value<'scope, 'data>
source§impl<'data> Call<'data> for Function<'_, 'data>
impl<'data> Call<'data> for Function<'_, '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>(
self,
target: T,
args: V
) -> ValueResult<'target, 'data, T>where
V: AsRef<[Value<'value, 'data>]>,
T: Target<'target>,
unsafe fn call<'target, 'value, V, T>( self, target: T, args: V ) -> ValueResult<'target, 'data, T>where V: AsRef<[Value<'value, 'data>]>, T: Target<'target>,
Call a function with an arbitrary number arguments. Read more
source§unsafe fn call_tracked<'target, 'value, V, T>(
self,
target: T,
args: V
) -> JlrsResult<ValueResult<'target, 'data, T>>where
V: AsRef<[Value<'value, 'data>]>,
T: Target<'target>,
unsafe fn call_tracked<'target, 'value, V, T>( self, target: T, args: V ) -> JlrsResult<ValueResult<'target, 'data, T>>where V: AsRef<[Value<'value, 'data>]>, T: Target<'target>,
Call a function with an arbitrary number arguments. Read more
source§impl<'data> CallAsync<'data> for Function<'_, 'data>
impl<'data> CallAsync<'data> for Function<'_, 'data>
source§unsafe fn call_async<'target, 'value, 'life0, 'async_trait, V>(
self,
frame: &'life0 mut AsyncGcFrame<'target>,
args: V
) -> Pin<Box<dyn Future<Output = JuliaResult<'target, 'data>> + 'async_trait>>where
V: AsRef<[Value<'value, 'data>]> + 'async_trait,
Self: 'async_trait,
'target: 'async_trait,
'value: 'async_trait,
'life0: 'async_trait,
unsafe fn call_async<'target, 'value, 'life0, 'async_trait, V>( self, frame: &'life0 mut AsyncGcFrame<'target>, args: V ) -> Pin<Box<dyn Future<Output = JuliaResult<'target, 'data>> + 'async_trait>>where V: AsRef<[Value<'value, 'data>]> + '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>(
self,
frame: &'life0 mut AsyncGcFrame<'target>,
args: V
) -> Pin<Box<dyn Future<Output = JuliaResult<'target, 'data>> + 'async_trait>>where
V: AsRef<[Value<'value, 'data>]> + '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>( self, frame: &'life0 mut AsyncGcFrame<'target>, args: V ) -> Pin<Box<dyn Future<Output = JuliaResult<'target, 'data>> + 'async_trait>>where V: AsRef<[Value<'value, 'data>]> + '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>(
self,
frame: &mut AsyncGcFrame<'target>,
args: V
) -> JuliaResult<'target, 'data, Task<'target>>where
V: AsRef<[Value<'value, 'data>]>,
unsafe fn schedule_async_interactive<'target, 'value, V>( self, frame: &mut AsyncGcFrame<'target>, args: V ) -> JuliaResult<'target, 'data, Task<'target>>where V: AsRef<[Value<'value, 'data>]>,
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>(
self,
frame: &mut AsyncGcFrame<'target>,
args: V
) -> JuliaResult<'target, 'data, Task<'target>>where
V: AsRef<[Value<'value, 'data>]>,
unsafe fn schedule_async<'target, 'value, V>( self, frame: &mut AsyncGcFrame<'target>, args: V ) -> JuliaResult<'target, 'data, Task<'target>>where V: AsRef<[Value<'value, 'data>]>,
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>(
self,
frame: &'life0 mut AsyncGcFrame<'target>,
args: V
) -> Pin<Box<dyn Future<Output = JuliaResult<'target, 'data>> + 'async_trait>>where
V: AsRef<[Value<'value, 'data>]> + '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>( self, frame: &'life0 mut AsyncGcFrame<'target>, args: V ) -> Pin<Box<dyn Future<Output = JuliaResult<'target, 'data>> + 'async_trait>>where V: AsRef<[Value<'value, 'data>]> + '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>(
self,
frame: &mut AsyncGcFrame<'target>,
args: V
) -> JuliaResult<'target, 'data, Task<'target>>where
V: AsRef<[Value<'value, 'data>]>,
unsafe fn schedule_async_local<'target, 'value, V>( self, frame: &mut AsyncGcFrame<'target>, args: V ) -> JuliaResult<'target, 'data, Task<'target>>where V: AsRef<[Value<'value, 'data>]>,
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>(
self,
frame: &'life0 mut AsyncGcFrame<'target>,
args: V
) -> Pin<Box<dyn Future<Output = JuliaResult<'target, 'data>> + 'async_trait>>where
V: AsRef<[Value<'value, 'data>]> + '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>( self, frame: &'life0 mut AsyncGcFrame<'target>, args: V ) -> Pin<Box<dyn Future<Output = JuliaResult<'target, 'data>> + 'async_trait>>where V: AsRef<[Value<'value, 'data>]> + '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>(
self,
frame: &mut AsyncGcFrame<'target>,
args: V
) -> JuliaResult<'target, 'data, Task<'target>>where
V: AsRef<[Value<'value, 'data>]>,
unsafe fn schedule_async_main<'target, 'value, V>( self, frame: &mut AsyncGcFrame<'target>, args: V ) -> JuliaResult<'target, 'data, Task<'target>>where V: AsRef<[Value<'value, 'data>]>,
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>(
self,
frame: &'life0 mut AsyncGcFrame<'target>,
args: V
) -> Pin<Box<dyn Future<Output = JlrsResult<JuliaResult<'target, 'data>>> + 'async_trait>>where
V: AsRef<[Value<'value, 'data>]> + '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>( self, frame: &'life0 mut AsyncGcFrame<'target>, args: V ) -> Pin<Box<dyn Future<Output = JlrsResult<JuliaResult<'target, 'data>>> + 'async_trait>>where V: AsRef<[Value<'value, 'data>]> + '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>(
self,
frame: &mut AsyncGcFrame<'target>,
args: V
) -> JlrsResult<JuliaResult<'target, 'data, Task<'target>>>where
V: AsRef<[Value<'value, 'data>]>,
T: Target<'target>,
unsafe fn schedule_async_tracked<'target, 'value, V, T>( self, frame: &mut AsyncGcFrame<'target>, args: V ) -> JlrsResult<JuliaResult<'target, 'data, Task<'target>>>where V: AsRef<[Value<'value, 'data>]>, T: Target<'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>(
self,
frame: &'life0 mut AsyncGcFrame<'target>,
args: V
) -> Pin<Box<dyn Future<Output = JlrsResult<JuliaResult<'target, 'data>>> + 'async_trait>>where
V: AsRef<[Value<'value, 'data>]> + '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>( self, frame: &'life0 mut AsyncGcFrame<'target>, args: V ) -> Pin<Box<dyn Future<Output = JlrsResult<JuliaResult<'target, 'data>>> + 'async_trait>>where V: AsRef<[Value<'value, 'data>]> + '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>(
self,
frame: &mut AsyncGcFrame<'target>,
args: V
) -> JlrsResult<JuliaResult<'target, 'data, Task<'target>>>where
V: AsRef<[Value<'value, 'data>]>,
T: Target<'target>,
unsafe fn schedule_async_interactive_tracked<'target, 'value, V, T>( self, frame: &mut AsyncGcFrame<'target>, args: V ) -> JlrsResult<JuliaResult<'target, 'data, Task<'target>>>where V: AsRef<[Value<'value, 'data>]>, T: Target<'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>(
self,
frame: &'life0 mut AsyncGcFrame<'target>,
args: V
) -> Pin<Box<dyn Future<Output = JlrsResult<JuliaResult<'target, 'data>>> + 'async_trait>>where
V: AsRef<[Value<'value, 'data>]> + '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>( self, frame: &'life0 mut AsyncGcFrame<'target>, args: V ) -> Pin<Box<dyn Future<Output = JlrsResult<JuliaResult<'target, 'data>>> + 'async_trait>>where V: AsRef<[Value<'value, 'data>]> + '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>(
self,
frame: &mut AsyncGcFrame<'target>,
args: V
) -> JlrsResult<JuliaResult<'target, 'data, Task<'target>>>where
V: AsRef<[Value<'value, 'data>]>,
T: Target<'target>,
unsafe fn schedule_async_local_tracked<'target, 'value, V, T>( self, frame: &mut AsyncGcFrame<'target>, args: V ) -> JlrsResult<JuliaResult<'target, 'data, Task<'target>>>where V: AsRef<[Value<'value, 'data>]>, T: Target<'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>(
self,
frame: &'life0 mut AsyncGcFrame<'target>,
args: V
) -> Pin<Box<dyn Future<Output = JlrsResult<JuliaResult<'target, 'data>>> + 'async_trait>>where
V: AsRef<[Value<'value, 'data>]> + '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>( self, frame: &'life0 mut AsyncGcFrame<'target>, args: V ) -> Pin<Box<dyn Future<Output = JlrsResult<JuliaResult<'target, 'data>>> + 'async_trait>>where V: AsRef<[Value<'value, 'data>]> + '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>(
self,
frame: &mut AsyncGcFrame<'target>,
args: V
) -> JlrsResult<JuliaResult<'target, 'data, Task<'target>>>where
V: AsRef<[Value<'value, 'data>]>,
T: Target<'target>,
unsafe fn schedule_async_main_tracked<'target, 'value, V, T>( self, frame: &mut AsyncGcFrame<'target>, args: V ) -> JlrsResult<JuliaResult<'target, 'data, Task<'target>>>where V: AsRef<[Value<'value, 'data>]>, T: Target<'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 moresource§impl<'value, 'data> ProvideKeywords<'value, 'data> for Function<'value, 'data>
impl<'value, 'data> ProvideKeywords<'value, 'data> for Function<'value, 'data>
source§fn provide_keywords(
self,
kws: Value<'value, 'data>
) -> JlrsResult<WithKeywords<'value, 'data>>
fn provide_keywords( self, kws: Value<'value, 'data> ) -> JlrsResult<WithKeywords<'value, 'data>>
Provide keyword arguments to the function. The keyword arguments must be a
NamedTuple. Read moreimpl<'scope, 'data> Copy for Function<'scope, 'data>
Auto Trait Implementations§
impl<'scope, 'data> RefUnwindSafe for Function<'scope, 'data>
impl<'scope, 'data> !Send for Function<'scope, 'data>
impl<'scope, 'data> !Sync for Function<'scope, 'data>
impl<'scope, 'data> Unpin for Function<'scope, 'data>
impl<'scope, 'data> UnwindSafe for Function<'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
source§impl<'scope, 'data, W> Managed<'scope, 'data> for Wwhere
W: ManagedPriv<'scope, 'data>,
impl<'scope, 'data, W> Managed<'scope, 'data> for Wwhere W: ManagedPriv<'scope, 'data>,
§type TypeConstructor = <W as ManagedPriv<'scope, 'data>>::TypeConstructorPriv<'target, 'da>
type TypeConstructor = <W as ManagedPriv<'scope, 'data>>::TypeConstructorPriv<'target, 'da>
Self, but with arbitrary lifetimes. Used to construct the appropriate type in generic
contexts.source§fn root<'target, T>(
self,
target: T
) -> T::Data<'data, Self::TypeConstructor<'target, 'data>>where
T: Target<'target>,
fn root<'target, T>( self, target: T ) -> T::Data<'data, Self::TypeConstructor<'target, 'data>>where T: Target<'target>,
Use the target to reroot this data.
source§fn unrooted_target(self) -> Unrooted<'scope>
fn unrooted_target(self) -> Unrooted<'scope>
Returns a new
Unrooted.source§fn display_string(self) -> JlrsResult<String>
fn display_string(self) -> JlrsResult<String>
Convert the data to its display string, i.e. the string that is shown when calling
Base.show.source§fn error_string(self) -> JlrsResult<String>
fn error_string(self) -> JlrsResult<String>
Convert the data to its error string, i.e. the string that is shown when calling
Base.showerror. This string can contain ANSI color codes if this is enabled by calling
Julia::error_color or AsyncJulia::error_color.source§fn display_string_or<S: Into<String>>(self, default: S) -> String
fn display_string_or<S: Into<String>>(self, default: S) -> String
Convert the data to its display string, i.e. the string that is shown by calling
Base.display, or some default value.§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) -> Rwhere
Self: Borrow<B>,
B: 'a + ?Sized,
R: 'a,
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> Rwhere Self: Borrow<B>, B: 'a + ?Sized, R: 'a,
§fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> Rwhere
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 ) -> Rwhere Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,
§fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> Rwhere
Self: AsRef<U>,
U: 'a + ?Sized,
R: 'a,
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> Rwhere Self: AsRef<U>, U: 'a + ?Sized, R: 'a,
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) -> Rwhere
Self: AsMut<U>,
U: 'a + ?Sized,
R: 'a,
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> Rwhere Self: AsMut<U>, U: 'a + ?Sized, R: 'a,
Mutably borrows
self, then passes self.as_mut() into the pipe
function.§impl<T> Tap for T
impl<T> Tap for T
§fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Selfwhere
Self: Borrow<B>,
B: ?Sized,
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Selfwhere 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)) -> Selfwhere
Self: BorrowMut<B>,
B: ?Sized,
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Selfwhere 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)) -> Selfwhere
Self: AsRef<R>,
R: ?Sized,
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Selfwhere 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)) -> Selfwhere
Self: AsMut<R>,
R: ?Sized,
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Selfwhere 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)) -> Selfwhere
Self: Deref<Target = T>,
T: ?Sized,
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Selfwhere 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)) -> Selfwhere
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Selfwhere 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.§fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Selfwhere
Self: Borrow<B>,
B: ?Sized,
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Selfwhere Self: Borrow<B>, B: ?Sized,
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)) -> Selfwhere
Self: BorrowMut<B>,
B: ?Sized,
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Selfwhere Self: BorrowMut<B>, B: ?Sized,
Calls
.tap_borrow_mut() only in debug builds, and is erased in release
builds.§fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Selfwhere
Self: AsRef<R>,
R: ?Sized,
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Selfwhere Self: AsRef<R>, R: ?Sized,
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)) -> Selfwhere
Self: AsMut<R>,
R: ?Sized,
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Selfwhere Self: AsMut<R>, R: ?Sized,
Calls
.tap_ref_mut() only in debug builds, and is erased in release
builds.