Return explicitly "empty" MapResult (fail-fast)

[zhade]

Hi, I am trying to fail-fast and need to return "something" that 
works together with MapResult.

I came up with a solution but wanted to know if its the supposed 
way to do it.

What I learned is that the lambdas of `map` and `filter` are part 
of the return type.

Example:

```d
import std.algorithm : filter, map;
import std.typecons : tuple;

auto example_func(bool fail)
{
     if (fail)
     {
         return []; // empty result. What to return here?
                    // Error: expected return type of `void[]`, 
not `MapResult!
                    // (__lambda_L34_C15, 
FilterResult!(__lambda_L33_C18, string[]))`

         return [].map!(a => a);
         // Error: template `map` is not callable using argument 
types `!()(void[])`

         return (cast(string[])[].map!(a => tuple!("value", 
"numLetters")("", 0));
         // Error: expected return type of 
`MapResult!(__lambda_L34_C40, string[])`, not 
`MapResult!(__lambda_L41_C15, FilterResult!(__lambda_L40_C18, 
string[]))`

         return (cast(string[])[]).filter!(a => a != 
"expensive").map!(a => tuple!("value", "numLetters")("", 0));
         // Error: expected return type of 
`MapResult!(__lambda_L34_C59, FilterResult!(__lambda_L34_C43, 
string[]))`, not `MapResult!(__lambda_L41_C15, 
FilterResult!(__lambda_L40_C18, string[]))`
     }

     auto list = someExpensiveOperation();

     return list
         .filter!(a => a != "expensive")
         .map!(a => tuple!("value", "numLetters")(a, a.length));
}

string[] someExpensiveOperation()
{
     return ["some", "expensive", "operation"];
}
```

With that I gathered that there is no other way but to use 
another function which solely applies the `map` and `filter`?

This works:

```d
auto example_func(bool fail)
{
     if (fail)
     {
         return transform([]);
     }

     auto list = someExpensiveOperation();

     return transform(list);
}

auto transform(string[] input)
{
     return input
         .filter!(a => a != "expensive")
         .map!(a => tuple!("value", "numLetters")(a, a.length));
}
```

Is this the supposed way to do it?