Multiline closure is not inferring the return type

karthikkeyan.balan · September 3, 2020, 10:16pm

Hi Guys,
I noticed a strange behaviour in the complier. It seems like the compiler is not able to infer the return type if the closure contains multiple lines of code.

Heres my class and methods looks like,

public class SnapshotWorkItem<V> where V: UIResponder {
    let content: () -> V
    private(set) var visible: (V -> Void)?

    public init(_ content: @escaping () -> V) {
        self.content = content
    }

    public func onVisible(_ visible: @escaping (V) -> Void) -> Self {
        self.visible = visible
        return self
    }
}

// Snapshot base class
extension BaseTestCase {
    func snapshot<C>(_ item: () -> SnapshotWorkItem<C>) where C: UIResponder {
        // create snapshot
    }
}

I am using the above in my unite test like below,

func testDetailsView() {
    snapshot {
        SnapshotWorkItem {
            let view = DetailedAnnouncementView(frame: frame)
            view.configure(model)
            return view
        }.onVisible  { view in
            🛑 // ERROR: Value of type 'UIResponder' has no member 'announcementScrollView'
            print(view.announcementScrollView.frame)
        }
    }
}

The above code throws a compiler error on .onVisible { }, as it is not able to infer the return type.

However, the compiler seems to be happy if I use implicit return in the first closer, something like this,

func testDetailsView() {
    snapshot {
        SnapshotWorkItem {
            DetailedAnnouncementView(frame: frame)
        }.onVisible  { view in
             ✅ // Works fine
            print(view.announcementScrollView.frame)
        }
    }
}

It looks like the compiler is not able to infer the return type from multiline closures. I don't know if i am doing something wrong, can some please help with this . Thanks in advance.

karthikkeyan.balan · September 3, 2020, 10:24pm

To add to that,

I have created a helper method the chain the mutation of my view's properties,

// Helper method
extension DetailedAnnouncementView {
    func setModel(_ model: AnnouncementModel) -> Self {
        self.configure(model)
        return self
    }
}

// Updated Test
func testDetailsView() {
    snapshot {
        SnapshotWorkItem {
            DetailedAnnouncementView(frame: frame)
                .setModel(model)
        }.onVisible  { view in
             ✅ // Works fine
            print(view.announcementScrollView.frame)
        }
    }
}

This seems to be working fine. This compiler seems to be happy.

xwu · September 3, 2020, 10:46pm

That is correct; you are doing nothing wrong. This may change in a future version of Swift. See here for more details:

github.com

apple/swift/blob/main/userdocs/diagnostics/complex-closure-inference.md

# Inferring Closure Types
If a closure contains a single expression, Swift will consider its body in addition to its signature and the surrounding context when performing type inference. For example, in the following code the type of `doubler` is inferred to be `(Int) -> Int` using only its body:

```swift
let doubler = {
  $0 * 2
}
```

If a closure body is not a single expression, it will not be considered when inferring the closure type. This is consistent with how type inference works in other parts of the language, where it proceeds one statement at a time. For example, in the following code an error will be reported because the type of `evenDoubler` cannot be inferred from its surrounding context and no signature was provided:

```swift
// error: cannot infer return type for closure with multiple statements; add explicit type to disambiguate
let evenDoubler = { x in
  if x.isMultiple(of: 2) {
    return x * 2
  } else {
    return x
  }
}

This file has been truncated. show original

karthikkeyan.balan · September 3, 2020, 11:02pm

Hi Xiaodi Wu,
Thanks for the response. Good to know that I am not doing something wrong. I might go with "chaining helper method" approach which I mentioned in my second comment.

Also it is good to know that, "giving the closure an explicit signature" works too.

Martin · September 4, 2020, 9:42am

There is also some information in this older discussion: Streamlining closures, e.g. from Jordan Rose:

Swift's type inference is currently statement-oriented, so there's no easy way to do this inference. This is at least partly a compilation-time concern: Swift's type system allows many more possible conversions than, say, Haskell or OCaml, so solving the types for an entire multi-statement function is not a trivial problem, possibly not a tractable problem.