swift - Are there any possible explicit uses of instances (values) of empty tuples (), i.e., of instances of typealias 'Void'?

Question

Question:

• Are there any possible explicit uses for the empty tuple (), as a value (and not as a type) in Swift 2.x?

I know that these empty tuples can be used in the standard sense to define void functions. When I mistakenly defined a variable with a empty tuple value var a = () (of type ()), I started wondering if these empty tuple values can be used in some context. Does anyone know of such an application?

---

Example: possible application with array and optionals?

As an example, we can create an optional array of empty tuples that, naturally, can only hold either nil or ():

/* Optionals */
var foo: ()? = ()
print(foo.dynamicType) // Optional<()>

var arr : [()?] = [foo]
for i in 2...8 {
    if i%2 == 0 {
        arr.append(nil)
    }
    else {
        arr.append(foo)
    }
}
print(arr) // [Optional(()), nil, Optional(()), ... ]

With the small memory footprint of empty tuple, this could seem neat for micro-memory-management for a "boolean nil/not nil", but since type Bool have the same small footprint, I can't really see any direct use here, even in the (unlike) scenario that we really need to go bit-low optimization on our operations.

---

Perhaps I'm just chasing my own tail with some narrow unusable applications, but anyway: are there any possible explicit uses for these void () beings (as instances, not types)?

Answer 1

Suppose you have two functions overloading the same name:

func foo()
func foo() -> Int

The first doesn't return anything, the second returns some kind of value. Attempting to call either of these will in most cases get you a compiler error about ambiguity.

foo()
let a = foo()

You'd think that the compiler would know that the first call unambiguously refers to the first function, because it assumes no return value. But in actuality, the return type of a function with no declared return type is Void, or (). So the first call is actually more like this:

let _ = foo()

And absent a type annotation for the discarded lvalue, the compiler can't infer which foo to call. You can use explicit type annotations to disambiguate:

let b: Void = foo()
let c: Int = foo() 

Okay, it's not a very great or common use case for Void, because it's a situation you'd tend to avoid getting into in the first place. But you asked for a use... and it is a use of () as a value and not just a type, because you can retrieve it from b after assignment (for all the good that does you).

Just beware, when you look deeply into the Void, the Void also looks into you. Or something like that.