Swift Language Generics The Basics of Generics
Example
Generics are placeholders for types, allowing you to write flexible code that can be applied across multiple types. The advantage of using generics over Any is that they still allow the compiler to enforce strong type-safety.
A generic placeholder is defined within angle brackets <>.
Generic Functions
For functions, this placeholder is placed after the function name:
/// Picks one of the inputs at random, and returns it
func pickRandom<T>(_ a:T, _ b:T) -> T {
return arc4random_uniform(2) == 0 ? a : b
}In this case, the generic placeholder is T. When you come to call the function, Swift can infer the type of T for you (as it simply acts as a placeholder for an actual type).
let randomOutput = pickRandom(5, 7) // returns an Int (that's either 5 or 7)
Here we’re passing two integers to the function. Therefore Swift is inferring T == Int – thus the function signature is inferred to be (Int, Int) -> Int.
Because of the strong type safety that generics offer – both the arguments and return of the function must be the same type. Therefore the following will not compile:
struct Foo {}
let foo = Foo()
let randomOutput = pickRandom(foo, 5) // error: cannot convert value of type 'Int' to expected argument type 'Foo'
Generic Types
In order to use generics with classes, structs or enums, you can define the generic placeholder after the type name.
class Bar<T> {
var baz : T
init(baz:T) {
self.baz = baz
}
}This generic placeholder will require a type when you come to use the class Bar. In this case, it can be inferred from the initialiser init(baz:T).
let bar = Bar(baz: "a string") // bar's type is Bar<String>
Here the generic placeholder T is inferred to be of type String, thus creating a Bar<String> instance. You can also specify the type explicitly:
let bar = Bar<String>(baz: "a string")When used with a type, the given generic placeholder will keep its type for the entire lifetime of the given instance, and cannot be changed after initialisation. Therefore when you access the property baz, it will always be of type String for this given instance.
let str = bar.baz // of type String
Passing Around Generic Types
When you come to pass around generic types, in most cases you have to be explicit about the generic placeholder type you expect. For example, as a function input:
func takeABarInt(bar:Bar<Int>) {
...
}This function will only accept a Bar<Int>. Attempting to pass in a Bar instance where the generic placeholder type is not Int will result in a compiler error.
Generic Placeholder Naming
Generic placeholder names are not just limited to single letters. If a given placeholder represents a meaningful concept, you should give it a descriptive name. For example, Swift’s Array has a generic placeholder called Element, which defines the element type of a given Array instance.
public struct Array<Element> : RandomAccessCollection, MutableCollection {
...
}
