pub struct ServeDir<F = DefaultServeDirFallback> { /* private fields */ }
Expand description
Service that serves files from a given directory and all its sub directories.
The Content-Type
will be guessed from the file extension.
An empty response with status 404 Not Found
will be returned if:
- The file doesn’t exist
- Any segment of the path contains
..
- Any segment of the path contains a backslash
- On unix, any segment of the path referenced as directory is actually an
existing file (
/file.html/something
) - We don’t have necessary permissions to read the file
§Example
use rama_http_backend::server::HttpServer;
use rama_http::service::fs::{ServeDir, ServeFile};
use rama_core::{
rt::Executor,
Layer, layer::TraceErrLayer,
};
use rama_tcp::server::TcpListener;
#[tokio::main]
async fn main() {
let exec = Executor::default();
let listener = TcpListener::bind("127.0.0.1:8080")
.await
.expect("bind TCP Listener");
// This will serve files in the "assets" directory and
// its subdirectories
let http_fs_server = HttpServer::auto(exec).service(ServeDir::new("assets"));
// Serve the HTTP server over TCP
listener
.serve(TraceErrLayer::new().layer(http_fs_server))
.await;
}
Implementations§
§impl<F> ServeDir<F>
impl<F> ServeDir<F>
pub fn append_index_html_on_directories(self, append: bool) -> ServeDir<F>
pub fn append_index_html_on_directories(self, append: bool) -> ServeDir<F>
If the requested path is a directory append index.html
.
This is useful for static sites.
Defaults to true
.
pub fn set_append_index_html_on_directories(
&mut self,
append: bool,
) -> &mut ServeDir<F>
pub fn set_append_index_html_on_directories( &mut self, append: bool, ) -> &mut ServeDir<F>
If the requested path is a directory append index.html
.
This is useful for static sites.
Defaults to true
.
pub fn with_buf_chunk_size(self, chunk_size: usize) -> ServeDir<F>
pub fn with_buf_chunk_size(self, chunk_size: usize) -> ServeDir<F>
Set a specific read buffer chunk size.
The default capacity is 64kb.
pub fn set_buf_chunk_size(&mut self, chunk_size: usize) -> &mut ServeDir<F>
pub fn set_buf_chunk_size(&mut self, chunk_size: usize) -> &mut ServeDir<F>
Set a specific read buffer chunk size.
The default capacity is 64kb.
pub fn precompressed_gzip(self) -> ServeDir<F>
pub fn precompressed_gzip(self) -> ServeDir<F>
Informs the service that it should also look for a precompressed gzip version of any file in the directory.
Assuming the dir
directory is being served and dir/foo.txt
is requested,
a client with an Accept-Encoding
header that allows the gzip encoding
will receive the file dir/foo.txt.gz
instead of dir/foo.txt
.
If the precompressed file is not available, or the client doesn’t support it,
the uncompressed version will be served instead.
Both the precompressed version and the uncompressed version are expected
to be present in the directory. Different precompressed variants can be combined.
pub fn set_precompressed_gzip(&mut self) -> &mut ServeDir<F>
pub fn set_precompressed_gzip(&mut self) -> &mut ServeDir<F>
Informs the service that it should also look for a precompressed gzip version of any file in the directory.
Assuming the dir
directory is being served and dir/foo.txt
is requested,
a client with an Accept-Encoding
header that allows the gzip encoding
will receive the file dir/foo.txt.gz
instead of dir/foo.txt
.
If the precompressed file is not available, or the client doesn’t support it,
the uncompressed version will be served instead.
Both the precompressed version and the uncompressed version are expected
to be present in the directory. Different precompressed variants can be combined.
pub fn precompressed_br(self) -> ServeDir<F>
pub fn precompressed_br(self) -> ServeDir<F>
Informs the service that it should also look for a precompressed brotli version of any file in the directory.
Assuming the dir
directory is being served and dir/foo.txt
is requested,
a client with an Accept-Encoding
header that allows the brotli encoding
will receive the file dir/foo.txt.br
instead of dir/foo.txt
.
If the precompressed file is not available, or the client doesn’t support it,
the uncompressed version will be served instead.
Both the precompressed version and the uncompressed version are expected
to be present in the directory. Different precompressed variants can be combined.
pub fn set_precompressed_br(&mut self) -> &mut ServeDir<F>
pub fn set_precompressed_br(&mut self) -> &mut ServeDir<F>
Informs the service that it should also look for a precompressed brotli version of any file in the directory.
Assuming the dir
directory is being served and dir/foo.txt
is requested,
a client with an Accept-Encoding
header that allows the brotli encoding
will receive the file dir/foo.txt.br
instead of dir/foo.txt
.
If the precompressed file is not available, or the client doesn’t support it,
the uncompressed version will be served instead.
Both the precompressed version and the uncompressed version are expected
to be present in the directory. Different precompressed variants can be combined.
pub fn precompressed_deflate(self) -> ServeDir<F>
pub fn precompressed_deflate(self) -> ServeDir<F>
Informs the service that it should also look for a precompressed deflate version of any file in the directory.
Assuming the dir
directory is being served and dir/foo.txt
is requested,
a client with an Accept-Encoding
header that allows the deflate encoding
will receive the file dir/foo.txt.zz
instead of dir/foo.txt
.
If the precompressed file is not available, or the client doesn’t support it,
the uncompressed version will be served instead.
Both the precompressed version and the uncompressed version are expected
to be present in the directory. Different precompressed variants can be combined.
pub fn set_precompressed_deflate(&mut self) -> &mut ServeDir<F>
pub fn set_precompressed_deflate(&mut self) -> &mut ServeDir<F>
Informs the service that it should also look for a precompressed deflate version of any file in the directory.
Assuming the dir
directory is being served and dir/foo.txt
is requested,
a client with an Accept-Encoding
header that allows the deflate encoding
will receive the file dir/foo.txt.zz
instead of dir/foo.txt
.
If the precompressed file is not available, or the client doesn’t support it,
the uncompressed version will be served instead.
Both the precompressed version and the uncompressed version are expected
to be present in the directory. Different precompressed variants can be combined.
pub fn precompressed_zstd(self) -> ServeDir<F>
pub fn precompressed_zstd(self) -> ServeDir<F>
Informs the service that it should also look for a precompressed zstd version of any file in the directory.
Assuming the dir
directory is being served and dir/foo.txt
is requested,
a client with an Accept-Encoding
header that allows the zstd encoding
will receive the file dir/foo.txt.zst
instead of dir/foo.txt
.
If the precompressed file is not available, or the client doesn’t support it,
the uncompressed version will be served instead.
Both the precompressed version and the uncompressed version are expected
to be present in the directory. Different precompressed variants can be combined.
pub fn set_precompressed_zstd(&mut self) -> &mut ServeDir<F>
pub fn set_precompressed_zstd(&mut self) -> &mut ServeDir<F>
Informs the service that it should also look for a precompressed zstd version of any file in the directory.
Assuming the dir
directory is being served and dir/foo.txt
is requested,
a client with an Accept-Encoding
header that allows the zstd encoding
will receive the file dir/foo.txt.zst
instead of dir/foo.txt
.
If the precompressed file is not available, or the client doesn’t support it,
the uncompressed version will be served instead.
Both the precompressed version and the uncompressed version are expected
to be present in the directory. Different precompressed variants can be combined.
pub fn fallback<F2>(self, new_fallback: F2) -> ServeDir<F2>
pub fn fallback<F2>(self, new_fallback: F2) -> ServeDir<F2>
Set the fallback service.
This service will be called if there is no file at the path of the request.
The status code returned by the fallback will not be altered. Use
ServeDir::not_found_service
to set a fallback and always respond with 404 Not Found
.
§Example
This can be used to respond with a different file:
use rama_core::{
rt::Executor,
Layer, layer::TraceErrLayer,
};
use rama_tcp::server::TcpListener;
use rama_http_backend::server::HttpServer;
use rama_http::service::fs::{ServeDir, ServeFile};
#[tokio::main]
async fn main() {
let exec = Executor::default();
let listener = TcpListener::bind("127.0.0.1:8080")
.await
.expect("bind TCP Listener");
// This will serve files in the "assets" directory and
// its subdirectories, and use assets/not_found.html as the fallback page
let fs_server = ServeDir::new("assets").fallback(ServeFile::new("assets/not_found.html"));
let http_fs_server = HttpServer::auto(exec).service(fs_server);
// Serve the HTTP server over TCP
listener
.serve(TraceErrLayer::new().layer(http_fs_server))
.await;
}
pub fn not_found_service<F2>(self, new_fallback: F2) -> ServeDir<SetStatus<F2>>
pub fn not_found_service<F2>(self, new_fallback: F2) -> ServeDir<SetStatus<F2>>
Set the fallback service and override the fallback’s status code to 404 Not Found
.
This service will be called if there is no file at the path of the request.
§Example
This can be used to respond with a different file:
use rama_core::{
rt::Executor,
layer::TraceErrLayer,
Layer,
};
use rama_tcp::server::TcpListener;
use rama_http_backend::server::HttpServer;
use rama_http::service::fs::{ServeDir, ServeFile};
#[tokio::main]
async fn main() {
let exec = Executor::default();
let listener = TcpListener::bind("127.0.0.1:8080")
.await
.expect("bind TCP Listener");
// This will serve files in the "assets" directory and
// its subdirectories, and use assets/not_found.html as the not_found page
let fs_server = ServeDir::new("assets").not_found_service(ServeFile::new("assets/not_found.html"));
let http_fs_server = HttpServer::auto(exec).service(fs_server);
// Serve the HTTP server over TCP
listener
.serve(TraceErrLayer::new().layer(http_fs_server))
.await;
}
Setups like this are often found in single page applications.
pub fn call_fallback_on_method_not_allowed(
self,
call_fallback: bool,
) -> ServeDir<F>
pub fn call_fallback_on_method_not_allowed( self, call_fallback: bool, ) -> ServeDir<F>
Customize whether or not to call the fallback for requests that aren’t GET
or HEAD
.
Defaults to not calling the fallback and instead returning 405 Method Not Allowed
.
pub fn set_call_fallback_on_method_not_allowed(
&mut self,
call_fallback: bool,
) -> &mut ServeDir<F>
pub fn set_call_fallback_on_method_not_allowed( &mut self, call_fallback: bool, ) -> &mut ServeDir<F>
Customize whether or not to call the fallback for requests that aren’t GET
or HEAD
.
Defaults to not calling the fallback and instead returning 405 Method Not Allowed
.
pub async fn try_call<State, ReqBody, FResBody>(
&self,
ctx: Context<State>,
req: Request<ReqBody>,
) -> Result<Response<Body>, Error>
pub async fn try_call<State, ReqBody, FResBody>( &self, ctx: Context<State>, req: Request<ReqBody>, ) -> Result<Response<Body>, Error>
Call the service and get a future that contains any std::io::Error
that might have
happened.
By default <ServeDir as Service<_>>::call
will handle IO errors and convert them into
responses. It does that by converting std::io::ErrorKind::NotFound
and
std::io::ErrorKind::PermissionDenied
to 404 Not Found
and any other error to 500 Internal Server Error
. The error will also be logged with tracing
.
If you want to manually control how the error response is generated you can make a new
service that wraps a ServeDir
and calls try_call
instead of call
.
§Example
use rama_core::{
rt::Executor,
service::service_fn,
layer::TraceErrLayer,
Context, Layer,
};
use rama_tcp::server::TcpListener;
use rama_http_backend::server::HttpServer;
use rama_http::service::fs::ServeDir;
use rama_http::{Body, Request, Response, StatusCode};
use std::convert::Infallible;
#[tokio::main]
async fn main() {
let exec = Executor::default();
let listener = TcpListener::bind("127.0.0.1:8080")
.await
.expect("bind TCP Listener");
// This will serve files in the "assets" directory and
// its subdirectories, and use assets/not_found.html as the fallback page
let http_fs_server = HttpServer::auto(exec).service(service_fn(serve_dir));
// Serve the HTTP server over TCP
listener
.serve(TraceErrLayer::new().layer(http_fs_server))
.await;
}
async fn serve_dir<State>(
ctx: Context<State>,
request: Request,
) -> Result<Response<Body>, Infallible>
where
State: Send + Sync + 'static,
{
let service = ServeDir::new("assets");
match service.try_call(ctx, request).await {
Ok(response) => Ok(response),
Err(_) => {
let body = Body::from("Something went wrong...");
let response = Response::builder()
.status(StatusCode::INTERNAL_SERVER_ERROR)
.body(body)
.unwrap();
Ok(response)
}
}
}
Trait Implementations§
§impl<State, ReqBody, F, FResBody> Service<State, Request<ReqBody>> for ServeDir<F>
impl<State, ReqBody, F, FResBody> Service<State, Request<ReqBody>> for ServeDir<F>
§type Error = Infallible
type Error = Infallible
§async fn serve(
&self,
ctx: Context<State>,
req: Request<ReqBody>,
) -> Result<<ServeDir<F> as Service<State, Request<ReqBody>>>::Response, <ServeDir<F> as Service<State, Request<ReqBody>>>::Error>
async fn serve( &self, ctx: Context<State>, req: Request<ReqBody>, ) -> Result<<ServeDir<F> as Service<State, Request<ReqBody>>>::Response, <ServeDir<F> as Service<State, Request<ReqBody>>>::Error>
§fn boxed(self) -> BoxService<S, Request, Self::Response, Self::Error>
fn boxed(self) -> BoxService<S, Request, Self::Response, Self::Error>
Auto Trait Implementations§
impl<F = DefaultServeDirFallback> !Freeze for ServeDir<F>
impl<F> RefUnwindSafe for ServeDir<F>where
F: RefUnwindSafe,
impl<F> Send for ServeDir<F>where
F: Send,
impl<F> Sync for ServeDir<F>where
F: Sync,
impl<F> Unpin for ServeDir<F>where
F: Unpin,
impl<F> UnwindSafe for ServeDir<F>where
F: UnwindSafe,
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
source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
source§default unsafe fn clone_to_uninit(&self, dst: *mut T)
default unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)§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,
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,
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,
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,
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,
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,
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,
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,
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,
§impl<T> FutureExt for T
impl<T> FutureExt for T
§fn with_context(self, otel_cx: Context) -> WithContext<Self> ⓘ
fn with_context(self, otel_cx: Context) -> WithContext<Self> ⓘ
§fn with_current_context(self) -> WithContext<Self> ⓘ
fn with_current_context(self) -> WithContext<Self> ⓘ
§impl<State, S, Body> HttpClientExt<State> for S
impl<State, S, Body> HttpClientExt<State> for S
§type ExecuteResponse = Response<Body>
type ExecuteResponse = Response<Body>
execute
method.§type ExecuteError = <S as Service<State, Request<Body>>>::Error
type ExecuteError = <S as Service<State, Request<Body>>>::Error
execute
method.§fn get(
&self,
url: impl IntoUrl,
) -> RequestBuilder<'_, S, State, <S as HttpClientExt<State>>::ExecuteResponse>
fn get( &self, url: impl IntoUrl, ) -> RequestBuilder<'_, S, State, <S as HttpClientExt<State>>::ExecuteResponse>
GET
request to a URL. Read more§fn post(
&self,
url: impl IntoUrl,
) -> RequestBuilder<'_, S, State, <S as HttpClientExt<State>>::ExecuteResponse>
fn post( &self, url: impl IntoUrl, ) -> RequestBuilder<'_, S, State, <S as HttpClientExt<State>>::ExecuteResponse>
POST
request to a URL. Read more§fn put(
&self,
url: impl IntoUrl,
) -> RequestBuilder<'_, S, State, <S as HttpClientExt<State>>::ExecuteResponse>
fn put( &self, url: impl IntoUrl, ) -> RequestBuilder<'_, S, State, <S as HttpClientExt<State>>::ExecuteResponse>
PUT
request to a URL. Read more§fn patch(
&self,
url: impl IntoUrl,
) -> RequestBuilder<'_, S, State, <S as HttpClientExt<State>>::ExecuteResponse>
fn patch( &self, url: impl IntoUrl, ) -> RequestBuilder<'_, S, State, <S as HttpClientExt<State>>::ExecuteResponse>
PATCH
request to a URL. Read more§fn delete(
&self,
url: impl IntoUrl,
) -> RequestBuilder<'_, S, State, <S as HttpClientExt<State>>::ExecuteResponse>
fn delete( &self, url: impl IntoUrl, ) -> RequestBuilder<'_, S, State, <S as HttpClientExt<State>>::ExecuteResponse>
DELETE
request to a URL. Read more§fn head(
&self,
url: impl IntoUrl,
) -> RequestBuilder<'_, S, State, <S as HttpClientExt<State>>::ExecuteResponse>
fn head( &self, url: impl IntoUrl, ) -> RequestBuilder<'_, S, State, <S as HttpClientExt<State>>::ExecuteResponse>
HEAD
request to a URL. Read more§fn request(
&self,
method: Method,
url: impl IntoUrl,
) -> RequestBuilder<'_, S, State, <S as HttpClientExt<State>>::ExecuteResponse>
fn request( &self, method: Method, url: impl IntoUrl, ) -> RequestBuilder<'_, S, State, <S as HttpClientExt<State>>::ExecuteResponse>
§fn execute(
&self,
ctx: Context<State>,
request: Request<Body>,
) -> impl Future<Output = Result<<S as HttpClientExt<State>>::ExecuteResponse, <S as HttpClientExt<State>>::ExecuteError>>
fn execute( &self, ctx: Context<State>, request: Request<Body>, ) -> impl Future<Output = Result<<S as HttpClientExt<State>>::ExecuteResponse, <S as HttpClientExt<State>>::ExecuteError>>
Request
. 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<State, S, R> IntoEndpointService<State, (State, R)> for Swhere
State: Send + Sync + 'static,
S: Service<State, Request<Body>, Response = R, Error = Infallible>,
R: IntoResponse + Send + Sync + 'static,
impl<State, S, R> IntoEndpointService<State, (State, R)> for Swhere
State: Send + Sync + 'static,
S: Service<State, Request<Body>, Response = R, Error = Infallible>,
R: IntoResponse + Send + Sync + 'static,
§fn into_endpoint_service(
self,
) -> impl Service<State, Request<Body>, Response = Response<Body>, Error = Infallible>
fn into_endpoint_service( self, ) -> impl Service<State, Request<Body>, Response = Response<Body>, Error = Infallible>
rama_core::Service
.§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,
§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,
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,
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
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
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
self
, then passes self.deref()
into the pipe function.§impl<T> PolicyExt for Twhere
T: ?Sized,
impl<T> PolicyExt for Twhere
T: ?Sized,
§fn and<S, P, B, E>(self, other: P) -> And<T, P>
fn and<S, P, B, E>(self, other: P) -> And<T, P>
Policy
that returns Action::Follow
only if self
and other
return
Action::Follow
. Read more§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
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
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
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
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
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
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
.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
.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
.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
.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
.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
.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
.tap_deref()
only in debug builds, and is erased in release
builds.