Swift 2.0中的泛型

Question

I have been through the Swift tutorials on the Apple developer site, but I do not understand the concepts of Generics. Is anyone able to explain it in a simple way? For example:

func swapTwoValues<T>(inout a: T, inout b: T) {
    let temporaryA = a
    a = b
    b = temporaryA
}

Answer 1

Without using generics in the example you gave, you'd have to overload swapTwoValues for every type you wanted to swap. For example:

func swapTwoValues(inout a: Int, inout b: Int) {
    let temp = a
    a = b
    b = temp
}

func swapTwoValues(inout a: String, inout b: String) {
    let temp = a
    a = b
    b = temp
} 

// Many more swapTwoValues functions...

The only thing that's different between the functions above is the type they accept; the code inside each is exactly the same. Therefore, it's better to write one generic function which can take any type.

It's important to note you can't substitute T with Any . There would be no guarantee a and b would be the same type - you couldn't swap an Int and a String , for example.

Answer 2

In your example T represents a Type. And once set that type is consistent for the whole of the function.

func swapTwoValues<T>(inout a: T, inout b: T) {
    let temporaryA = a
    a = b
    b = temporaryA
}

If T is an Int in the case of parameter a, then it will also have to be an Int in the case of parameter b. As demonstrated in this use of the function:

var valueA = 2
var valueB = 4
swapTwoValues(&valueA, b: &valueB)

valueA // 4
valueB // 2

We could not swap a String for an Int for example or even an Int for a Double, but as long as Types are the same then this generic method will take any Type, because it is unrestrained in all other respects.

var valueA = "Hello"
var valueB = "Swift"
swapTwoValues(&valueA, b: &valueB)

valueA // "Swift"
valueB // "Hello"

This does not mean multiple types are excluded from generic functions, however. You simply need to assign a different letter to represent the different types (the letter used is irrelevant, T is simply used because it is the first letter of Type but there is no reason it could not be replaced with Q, for example, or any other letter):

func swapTwoValues<T,S>(inout a: T, inout b: T, inout c: S, inout d: S) {
    let temporaryA = a
    a = b
    b = temporaryA

    let temporaryC = c
    c = d
    d = temporaryC
}

var valueA = 2
var valueB = 4

var valueC = "Hello"
var valueD = "Swift"
swapTwoValues(&valueA, b: &valueB, c:&valueC, d:&valueD)

valueA  // 4
valueB // 2

valueC // "Swift"
valueD // "Hello"

Note: we still cannot swap a T for an S, because Swift is a strongly typed language and we have no reassurance they are the same.

It becomes more interesting when protocols are involved to constrain the generic types. Here I do so with the UnsignedIntegerType:

func swapTwoValues<T: UnsignedIntegerType>(inout a: T, inout b: T) {
    let temporaryA = a
    a = b
    b = temporaryA
}

var valueA:UInt = 10
var valueB:UInt = 11

swapTwoValues(&valueA, b: &valueB)

Now only types such as UInt, UInt8, UInt32, etc are acceptable and all other values will be rejected and create an error.

Note: The reason for constraining types using protocols is so that certain methods can be guaranteed to work. For example if a generic function is required to create a new type instance, then it must adopt a protocol with an init method. (You can check protocol adoption for each type in Apple's docs.)

We can go further and use the where keyword to determine the types contained within a generic collection:

func swapTwoValues<T: CollectionType where T.Generator.Element: UnsignedIntegerType>(inout a: T, inout b: T) {
    let temporaryA = a
    a = b
    b = temporaryA
}

var valueA:[UInt] = [10,12,4]
var valueB:[UInt] = [11,45,67]

swapTwoValues(&valueA, b: &valueB)

valueA  // [11, 45, 67]
valueB // [10, 12, 4]

Or do things like check that a second type is equivalent to the type of Elements in a collection using == :

func swapTwoValues<T: CollectionType, S where S == T.Generator.Element>(inout a: T, inout b: T, inout c: S, inout d: S) {
    let temporaryA = a
    a = b
    b = temporaryA

    let temporaryC = c
    c =  d
    d = temporaryC
}

Further reading: Things get even more interesting with protocol extensions in Swift 2 because now generic functions can take on the characteristics of Type methods, which makes them far more discoverable.

Answer 3

Essentially, it just means that it is not type specific. You use T and just write one function instead of writing many functions for each type Int , Double , Float , String etc.