[SR-16075] `map(foo)` and `map{ foo($0) } ` return different results

[swift-ci]

Previous ID	SR-16075
Radar	None
Original Reporter	OMGHunter (JIRA User)
Type	Bug

Environment

Xcode 13.3 (13E113)

Additional Detail from JIRA

Votes	0
Component/s	swift
Labels	Bug
Assignee	None
Priority	Medium

md5: 383ad533155d7b964df61e4e1f582e7d

Issue Description:

For the following code snippet, res1 and res2 surprisingly have different values:

func test() {
    let a: String? = nil
    let b: String? = nil


    let foo: (String?) -> Int = { $0 == nil ? 0 : 1}


    let res1 = [a, b].compactMap { $0 }.map(foo)
    let res2 = [a, b].compactMap { $0 }.map { foo($0) }


    print("res1: ", res1)
    print("res2: ", res2)
}

test()
// res1:  [0, 0]
// res2:  []

According to the comment on StackOverflow (https://stackoverflow.com/a/71669873/4770353) it's a result of how the compiler selects the types of [a, b].compactMap based on the downstream operation.

[itaiferber]

To add some details from the StackOverflow answer locally:

1. Printing the intermediate types of [a, b] and [a, b].compactMap { $0 } shows that

*

• • In the case of res1, it appears that the compiler prefers to bind the input type of map(foo) to be String?, and so seems to propagate upcasts through the chain of types such that the type of [a, b] is [String??]

  • In the case of res2, the explicit parameter to map allows the type of $0 to be upcast locally inside the closure from String to String?, preventing any further upcasting propagation such that the type of [a, b] is [String?]

1. Turning the compactMap closure into a multi-line closure appears to propagate types in the same way as the res1 case: compactMap { _ = 1 + 1; return $0 } yields [0, 0] in both cases

2. Changing the input type of foo from String? to String resolves any ambiguity

Some additional, possibly-obvious points:

1. As expected, moving foo from inside of test to outside has no effect

2. Removing the map operation altogether yields related behavior:

   • let res1 = [a, b].compactMap { $0 } // => []

   • let res1 = [a, b].compactMap { _ = 1 + 1; return $0 } // => generic parameter 'ElementOfResult' could not be inferred

[AnthonyLatsis]

Here‘s a simplistic example:

let f: (Int??) -> Int?? = { $0 }

let x: Int? = nil
[x].compactMap(f) // [nil]

Apparently, the solver favors an implicit optional promotion (x) over an implicit function conversion (f), which can take by surprise across a more complex expression as in the original example.

@xedin Are we assuming too much with this inference?