Elaborate more about "Swift coalescing operator" about functional-swift HOT 6 CLOSED

@onmyway133 I've rewritten the explanation below. Is this better?

There is one problem with this definition: the defaultValue may be evaluated, regardless of whether or not the optional is nil. This is usually undesirable behavior: an if-then-else statement should only execute one of its branches, depending on whether or not the associated condition is true. Similarly, the ?? operator should only evaluate the defaultValue argument when the optional argument is nil. For example, if we were to call ?? as follows:

optional ?? defaultValue

We really do not want to evaluate defaultValue if the optional variable is non-nil -- it could be a very expensive computation that we only want to run if it is absolutely necessary. We can resolve this issue as follows:

func ??<T>(optional: T?, defaultValue: () -> T) -> T {
    if let x = optional {
        return x
    } else {
        return defaultValue()
    }
}

from functional-swift.

it could be a very expensive computation that we only want to run if it is absolutely necessary

But in this case, it just returns defaultValue, so this is not a very expensive computation ?

from functional-swift.

I haven't said what defaultValue is. It could still be a huge
computation. To make it even more concrete:

5 ?? aVerySlowFunction(17)

In this example, you do not want to run aVerySlowFunction, but directly
return 5.

On 23 October 2014 21:04, Khoa Pham [email protected] wrote:

it could be a very expensive computation that we only want to run if it is
absolutely necessary

But in this case, it just returns defaultValue, so this is not a very
expensive computation ?

—
Reply to this email directly or view it on GitHub
#27 (comment)
.

from functional-swift.

Maybe another way to think of this is that we want to have the same behavior as || (the or operator) in most languages. The || operator only evaluates it's right operand if the left operand is not true. For example, in Objective-C, we might say:

NSUInteger count = myArray.count || [self computeComplicatedCount];

In case myArray.count returns a non-zero number, we don't want computeComplicatedCount to be called...

And we want to have the same behavior for ??. I think this has been some really good feedback, we will see how we can incorporate this...

from functional-swift.

A bit late to the party here, but maybe you want to say that in the original, the expression passed to defaultValue will be evaluated before ?? is even called. "may be evaluated" is pretty ambiguous. It will definitely be evaluated.

The expensive operation occurs before ??, and we're passed a value or reference, returning that value is not expensive, so that's why @onmyway133 is reasonably confused.

defaultValue: T is a value, not a computation (huge or otherwise). You want to change it to accept a computation instead of a value, so that you can decide internally whether or not to execute it.

from functional-swift.

Thanks, this has been really good feedback. We've changed the wording and will update this in the next version of the book.

from functional-swift.