Passing an implicitly unwrapped variable into inout parameter doesn't compile - swift

Question

func someFunc<T>(obj: T, inout arr: [T])
{
}
var arr: [String]!
someFunc("a", &arr)
Upon calling someFunc("a", &arr), I get an error:
[String]! is not identical to [T]
arr is implicitly unwrapped, so shouldn't it be treated as an unwrapped value, and thus able to be passed into the function? What then would be the correct way to write this, considering I want to keep the arr declaration the same (keep it implicitly unwrapped)?

Answer 1

Conceptually you are correct that you should be able to use it this way, but the reality is that the value you are passing in is a different type than the array. This is important because you are taking the reference of that value which cannot be forwarded to the internal array.
An implicitly unwrapped optional is really just an optional that automatically unwraps itself when it is referenced. So you can illustrate why this wouldn't work in your case with a regular optional:
var arr: [String]? = ["Hello", "World"]
someFunc("a", &(arr!))
This also does not compile. The problem is that it is trying to pass in a reference to the value stored within the Optional enum. A method cannot interact with that reference independent of the enum that actually owns it.
I think your best bet is to return a copy of the array from someFunc instead of using an inout parameter:
func someFunc<T>(obj: T, arr: [T]) -> [T]
{
}

Answer 2

For me in XCode 6.1 (6A1052d), this kind of thing compiles, but just silently fails to modify the value passed in. It would be better if it failed to compile - would have saved me some head-scratching.

Answer 3

You can pass an implicitly-unwrapped optional as an inout parameter. You have two options: change your function to explicitly accept an implicitly-unwrapped optional, or populate the implicitly unwrapped optional with a sentinel value, and then explicitly unwrap it.
// Compiled with Xcode Version 6.2 (6C131e)
var foo: [String]!
func testImplicitlyUnwrappedOptionalInout() {
// doesn't compile: '[String]!' is not identical to '[T]'
// someFunc("bar", arr: &foo)
// crashes at runtime: EXC_BAD_INSTRUCTION (code=EXC_i286_INVOP, subcode=0x0)
// someFunc("bar", arr: &foo!)
// must populate foo before unwrapping it.
foo = []
someFunc("bar", arr: &foo!)
if let foo = foo {
XCTAssertEqual(foo, ["bar"])
} else {
XCTFail("foo wasn't populated")
}
// or you must change your function to accept an implicitly unwrapped optional inout:
foo = .None
someFuncImplcitlyUnwrapped("bar", arr: &foo)
if let foo = foo {
XCTAssertEqual(foo, ["bar"])
} else {
XCTFail("foo wasn't populated")
}
}
func someFunc<T>(obj: T, inout arr: [T]) {
arr.append(obj)
}
func someFuncImplcitlyUnwrapped<T>(obj: T, inout arr: [T]!) {
if arr == nil {
arr = []
}
arr.append(obj)
}
Thanks to Joe Groff for the hint.