Comment by Zenny Chen (JIRA)

There're two overloaded filter methods here and both have the same parameter list but different return types. So, you should specify the definite type of the method you want to invoke.

The following code is OK:

        let dict = [
            "Key1": "ABCDEFG",
            "Key2": "HIJKLMN",
            "Key3": "OPQRSTU",
            "Key4": "VWXYZ"
        ]
        
        // Here, use `as` to specify the right method to invoke
        let count = (dict.values.filter as ((String) -> Bool) -> LazyFilterCollection<LazyMapCollection<[String:String], String>>)() { $0.hasPrefix("ABC") }.count
        
        print("count = \(count)")

It works though the type using `as` to specify is too complicated... 🙂

Interestingly it only happens when accessing count. Using filter() alone or even something else like map() or first works fine.
How does it choose an overload in one of these other cases?

Comment by Zenny Chen (JIRA)

Without accessing the property `count`, the method `filter` doesn't need the result and it may choose an either method. Because there is no return value and no other side effects, either of these methods is OK. I suppose it is an optimization.

There's another easy way to work around this problem:

        let values = [String](dict.values)
        let count = values.filter() {
            return $0.hasPrefix("ABC")
        }.count

Convert the LazyMapCollection type to an array, and that'll be simpler.

Yea. This is one of the workarounds I mentioned.

Comment by Zenny Chen (JIRA)

What's weird, the following code has no problem:

        let tmp = dict.values.filter() {
            return $0.hasPrefix("ABC")
        }

According to the debugger, the type of `tmp` is LazyFilterCollection.
We'll wait for the core Swift developers or experts to explain.

Yep. That's exactly what I meant before. Since it's able to choose an implementation in this case, it should also be able to choose an implementation in case I call count.

@gribozavr, @moiseev, there was another one like this recently, right?

I can't find it, but yes, we have lots of similar issues, that are caused by the same root issue.

https://bugs.swift.org/browse/SR-461 and https://bugs.swift.org/browse/SR-1856 and https://bugs.swift.org/browse/SR-851 are believed to be caused by the same overload resolution behavior.

There's no error in Swift 4 anymore. Has this been fixed?

@ffried The type of `Dictionary.Values` is different between Swift 3 and Swift 4. See https://github.com/apple/swift/blob/master/stdlib/public/core/HashedCollections.swift.gyb#L2406 and https://github.com/apple/swift/blob/master/stdlib/public/core/HashedCollections.swift.gyb#L2449

The described problem arises whenever you're calling .filter { ... }.count on a lazy sequence/collection. In Swift 4 `Dictionary.Values` is no longer lazy.

Thanks for the info, @moiseev. Didn't notice this change.

So, is there an issue tracking this particular version of the issue (.filter { ... }.count on a lazy sequence / collection)? Otherwise I'd update this report to better reflect the actual issue.

These few lines are enough to reproduce it:

let arr = ["A", "B", "C"]
let lazy: LazyMapCollection = arr.lazy.map { $0 }
lazy.filter { $0 > "A" }.count // <- Error: Ambiguous use of 'filter'

@ffried I don't know of a JIRA that this can be duped to, so I'd leave it as is. Please update the description with a shorter reproduction case. Thanks!

Comment by Chris Aljoudi (JIRA)

This also occurs, similarly, when accessing `.first`

See realm/realm-swift#5319

This is resolved by #12520 going to prefer LazyFilterCollection over Array for `filter` call. @ffried please verify and resolve. I'm going to add test-case to the suite as well to make sure this doesn't regress.

@xedin I've just downloaded the latest development snapshot from https://swift.org/download/#snapshots (created on Nov 21th) but it still gives me an ambiguous use of filter for the simplified reproduction case:

let arr = ["A", "B", "C"]
let lazy: LazyMapCollection = arr.lazy.map { $0 }
lazy.filter { $0 > "A" }.count // <- Error: Ambiguous use of 'filter'

Two candidates are found: one in LazyCollectionProtocol and one in Sequence.

Am I missing something?

@ffried You should try with "Trunk Snapshot", here is what I get:

Welcome to Apple Swift version 4.1-dev (LLVM fe49d8f2ca, Clang 839070845c, Swift c0c04864db). Type :help for assistance.
  1> let arr = ["A", "B", "C"]
  2. let lazy: LazyMapCollection = arr.lazy.map { $0 }
  3. lazy.filter { $0 > "A" }.count
$R0: Int = 2
arr: [String] = 3 values {
  [0] = "A"
  [1] = "B"
  [2] = "C"
}
lazy: LazyMapCollection<[String], String> = {
  _base = 3 values {
    [0] = "A"
    [1] = "B"
    [2] = "C"
  }
  _transform = 0x00000001017224d0 $__lldb_expr2`partial apply forwarder for reabstraction thunk helper from @escaping @callee_guaranteed (@owned Swift.String) -> (@owned Swift.String) to @escaping @callee_guaranteed (@in Swift.String) -> (@out Swift.String) at repl1-b88c27..swift
}
  4>

@xedin Yep, you're right. Seems like I used a Swift 4.1 Snapshot.

Works fine now - fix confirmed