CODEWITHSUNDEEP
swift
user6902806
user6902806

Reputation: 280

overloading methods where only difference is optional vs. non-optional type

I was under the impression that swift can have overloaded methods that differ only in the type of object that the methods return. I would think that I could have two funcs with the same signature yet they differ in return type.

import Foundation

// ambiguous use of 'IsTextEmpty(text:)'
func IsTextEmpty(text : String?) -> Bool? {
  return text?.isEmpty
}

func IsTextEmpty(text : String?) -> Bool {
   guard let text = text else {
     return true
   }

   return text.isEmpty
}

let text: String? = nil

if let empty = IsTextEmpty(text:"text") {
   print("Not Empty")
}

if IsTextEmpty(text: text) {
   print("Empty")
}

Here, both functions have the same input parameters but one func returns an optional Bool? and the other returns a Bool. In this case I get an error:

ambiguous use of 'IsTextEmpty(text:)'

If I change the name of one of the input parameters I no longer get the ambiguous error:

// Works
func IsTextEmpty(foo : String?) -> Bool? {
  return foo?.isEmpty
}

func IsTextEmpty(text : String?) -> Bool {
   guard let text = text else {
     return true
   }

   return text.isEmpty
}

let text: String? = nil

if let empty = IsTextEmpty(foo:"text") {
   print("Not Empty")
}

if IsTextEmpty(text: text) {
   print("Empty")
}

Shouldn't the compiler detect that they are two distinct methods even though their return types are different, since an optional Bool? is a different type from a non-optional Bool?

Upvotes: 3

Views: 406

Answers (1)

Martin R
Martin R

Reputation: 539965

The compiler needs some context to decide which method to call, e.g.

let e1 = IsTextEmpty(text: text) as Bool
let e2: Bool = IsTextEmpty(text: text)

to call the non-optional variant, or

let e3 = IsTextEmpty(text: text) as Bool?
let e4: Bool? = IsTextEmpty(text: text)

to call the optional variant. Now

if IsTextEmpty(text: text) {
    print("Empty")
}

compiles without problems: the if-statement requires a boolean expression, so there is no ambiguity here.

But apparently the compiler is not smart enough to figure out that in the context of an optional binding the expression on the right-hand side must be some optional and to infer the unwrapped type automatically.

You need to annotate the type of empty explicitly:

if let empty: Bool = IsTextEmpty(text: text) { ... }

or to make the return type explicit:

if let empty = (IsTextEmpty(text: text) as Bool?) { ... }

Upvotes: 1

Related Questions