Tap seems limited since you cannot halt execution on failure

Tap is very useful in that you can use it to return the passed in result and do multiple operations on a single result object. For example.

return getMyResult()
    .Tap(x => DoWork1(x))
    .Tap(x => DoWork2(x))
    .Tap(x => DoWork3(x));

However, sometimes you would like to return the result and still depend on whether the DoWork() method failed. If you could assume that Funcs passed to DoWork all returned the same result type as the “parent” result, that would be useful.

I find myself writing extensions methods like the following:

public static async Task<Result<T>> Tap<T>(this Task<Result<T>> resultTask, Func<T, Task<Result<T>>> func)
{
	var result = await resultTask.ConfigureAwait(Result.DefaultConfigureAwait);
	if (!result.IsSuccess) return result;
	var tapResult = await func(result.Value).ConfigureAwait(Result.DefaultConfigureAwait);
	return tapResult.IsFailure
		? tapResult
		: result;
}

In this case, the flow would be identical, except that execution would stop when a tap Func returns a failed result.

What is the reasoning behind having the result of a Tap operation be ignored in the railway flow?

[benprime]

Addressed as part of PR #192

[space-alien]

I do it this way:

return GetCustomer()
    .Bind(customer => UpdateCustomer(customer)
        .Map(_ => customer))
    .Bind(customer => DoWork(customer)
        .Map(() => customer));

UpdateCustomer() returns a Result<T> containing a value that we aren’t interested in. DoWork() returns a Result with no value.