Why Does Swift Require a Type Annotation for Inferred Function Types with a Ternary Operator?

The behavior you’re seeing is not so much that the language has fundamentally changed, but rather that recent versions of Swift (as seen in Xcode 16.2) have a slightly different type‐inference behavior when it comes to conditional expressions involving function references. In your original snippet

SWIFTCopied
func stepForward(_ input: Int) -> Int {
    return input + 1
}
func stepBackward(_ input: Int) -> Int {
    return input - 1
}
func chooseStepFunction(backward: Bool) -> (Int) -> Int {
    return backward ? stepBackward : stepForward
}

the compiler has trouble “merging” the two function references into the expected type of (Int) -> Int when used in the ternary operator. Even though both functions share the same signature, Swift’s inference engine in this particular context finds it ambiguous.

Using explicit type annotations (as in your modified code)

SWIFTCopied
let forwardFunc: (Int) -> Int = stepForward
let backwardFunc: (Int) -> Int = stepBackward

@MainActor
func chooseStepFunction(backward: Bool) -> (Int) -> Int {
    return backward ? backwardFunc : forwardFunc
}

resolves the ambiguity by fixing the type of both optional branches. There isn’t a documented language change that invalidates the example in the book; rather, it’s an edge (or limitation) of the compiler’s inference in some contexts.

In short:

• No fundamental change to the language mandates that you must add annotations.
• In your specific context (especially in Playgrounds with the given Swift version), the inference engine can’t resolve the function type from the conditional operator without an explicit hint.
• While the official documentation doesn’t mention this requirement, providing the annotation is a good workaround to help the type checker.

This issue is one of those subtle quirks where more explicit hints to the compiler can improve clarity and type-checker performance.