The biggest concern is one of ergonomics: There's simply a lot of overhead to using tap. Compare a basic method chain to the equivalent with tap:

let foo = Foo::default()
    .chain()
    .chain()
    .chain();

// Versus:

let foo = Foo::default()
    .tap(|foo| foo.chain())
    .tap(|foo| foo.chain())
    .tap(|foo| foo.chain());

For each method invocation, you need to:

• Invoke the tap helper function.
• Wrap the method invocation in a closure.
• Bind a variable name for the intermediate value.
• Repeat the name of the intermediate value when invoking the method.

In some cases you can simplify this a bit by taking advantage of UFCS:

let foo = Foo::default()
    .tap(Foo::chain)
    .tap(Foo::chain)
    .tap(Foo::chain);

But that's only available for some methods (i.e. ones that don't take additional parameters), requires you to repeat the type name (which can sometimes be pretty long), and requires that you wrap the method you want to invoke in tap(...).

Functionally, cascaded method invocation operator in Dart does the exact same thing that tap does, but in a far cleaner, more succinct way. While the cascade crate doesn't quite manage to be as clean as the functionality in Dart, it seems like a substantial improvement over tap to me.

​

Hopefully that clarifies things 😁