Suffix-Position Pipeline Behavior
This crate provides extension methods on all types that allow transparent, temporary, inspection/mutation (tapping), transformation (piping), or type conversion. These methods make it convenient for you to insert debugging or modification points into an expression without requiring you to change any other portions of your code.
You can tap inside a method-chain expression for logging without requiring a rebind. For instance, you may write a complex expression without any intermediate debugging steps, and only later decide that you want them. Ordinarily, this transform would look like this:
extern crate reqwest; extern crate tracing; // old let body = get? .text?; debug!; // new, with debugging let resp = get?; debug!; let body = resp.text?; debug!;
while with tapping, you can plug the logging statement directly into the overall expression, without making any other changes:
extern crate reqwest; extern crate tracing; let body = get? // The only change is the insertion of this line .tap .text?; debug!;
Some APIs are written to require mutable borrows, rather than value-to-value transformations, which can require temporary rebinding in order to create mutability in an otherwise-immutable context. For example, collecting data into a vector, sorting the vector, and then freezing it, might look like this:
let mut collection = stream.; collection.sort; // potential error site: inserting other mutations here let collection = collection; // now immutable
But with a mutable tap, you can avoid the duplicate binding and guard against future errors due to the presence of a mutable binding:
let collection = stream. .tap_mut;
.tap_mut() and related methods provide a mutable borrow to their argument,
and allow the final binding site to choose their own level of mutability without
exposing the intermediate permission.
In addition to transparent inspection or modification points, you may also wish
to use suffix calls for subsequent operations. For example, the standard library
offers the free function
fs::read to convert
Path-like objects into
Vec<u8> of their filesystem contents. Ordinarily, free functions require use
use fs; let mut path = get_base_path; path.push; path.push; let contents = read?;
whereäs use of tapping (for path modification) and piping (for
be expressed like this:
use fs; let contents = get_base_path .tap_mut .tap_mut .pipe?;
As a clearer example, consider the syntax required to apply multiple free
let-bindings looks like this:
let val = last;
which requires reading the expression in alternating, inside-out, order, to understand the full sequence of evaluation. With suffix calls, even free functions can be written in a point-free style that maintains a clear temporal and syntactic order:
let val = original_value .pipe .pipe .pipe .pipe;
As piping is an ordinary method, not a syntax transformation, it still requires that you write function-call expressions when using a function with multiple arguments in the pipeline.
conv module is the simplest: it provides two traits,
which are sibling traits to
TryInto<T>. Their methods,
TryConv::try_conv::<T>, call the corresponding
trait implementation, and allow you to use
non-terminal method calls of an expression.
let bytes = "hello".into.into_bytes;
does not compile, because Rust cannot decide the type of
Instead of rewriting the expression to use an intermediate
let binding, you
can write it as
let bytes = "hello"..into_bytes;
Pipe traits both provide a large number of methods, which use
different parts of the Rust language’s facilities for well-typed value access.
Rather than repeat the API documentation here, you should view the module items
in the documentation.
As a summary, these traits provide methods that, upon receipt of a value,
- apply no transformation
- apply an
- apply a
- apply the
before executing their effect argument.
In addition, each
.tap_x has a sibling method
performs the same work, but only in debug builds; in release builds, the method
call is stripped. This allows you to leave debugging taps in your source code,
without affecting your project’s performance in true usage.
tap module also has traits
run taps on the variants of
Result enums, respectively, and do
nothing when the variant does not match the method name.
has no effect when called on a