Swift：将泛型类型转换为相同的泛型类型，但具有关联类型的子类

Consider these classes:

考虑这些类:

struct OrderedSet<T: Hashable> {}

class Exercise: Hashable {}

class StrengthExercise: Exercise {}

class CardioExercise: Exercise {}

I'd like to do the following:

我想做以下事情:

var displayedExercises = OrderedSet<Exercise>() {
    didSet {
        self.tableView.reloadData()
    }
}
var cardioExercises = OrderedSet<CardioExercise>()
var strengthExercises = OrderedSet<StrengthExercise>()


@IBAction func segmentControlChanged(segmentControl: UISegmentedControl) {
    switch segmentControl.selectedSegmentIndex {
    case 0:     self.displayedExercises = self.strengthExercises
    case 1:     self.displayedExercises = self.cardioExercises
    default:    break
    }
}

But I get this error:

但我得到这个错误:

Cannot assign value of type 'OrderedSet<StrengthExercise>' to type 'OrderedSet<Exercise>

I don't quite get this, since StrengthExercise is a subclass of Exercise and will have everything that OrderedSet<Exercise> expects.

我不太明白,因为StrengthExercise是Exercise的子类,并且将包含OrderedSet 所期望的所有内容。

The question(s)

• Why is this error necessary?

为什么这个错误是必要的?

• How to I write something that achieves the functionality I'm going for?

如何写一些能实现我想要的功能的东西?

Radar filed
rdar://23608799

雷达提交rdar:// 23608799

Blog post on covariance and contravariance
https://www.mikeash.com/pyblog/friday-qa-2015-11-20-covariance-and-contravariance.html

关于协方差和逆变的博客文章https://www.mikeash.com/pyblog/friday-qa-2015-11-20-covariance-and-contravariance.html

3 个解决方案

#1

I am afraid this is not currently possible as of Swift 2.1. Only the following conversions are supported

我担心Swift 2.1目前无法实现这一目标。仅支持以下转换

• Built in collections types are covariant on their element type.

内置集合类型的元素类型是协变的。

• Conversions between function types are supported, exhibiting covariance in function result types and contravariance in function parameter types. (Cf. Xcode 7.1 Release Notes)

支持函数类型之间的转换,表现出函数结果类型的协方差和函数参数类型的逆变。 (参见Xcode 7.1发行说明)

As Objective-C's generics support type variance, and given the progress made on function type conversions in Swift 2.1, I believe there is reason to believe type variance support will be added to Swift in the future. In the mean time, remember to file a radar, like jlieske has.

作为Objective-C的泛型支持类型方差,并且考虑到Swift 2.1中函数类型转换的进展,我相信有理由相信将来会向Swift添加类型差异支持。与此同时,请记得提交雷达,就像jlieske一样。

In the mean time you will have to copy the collection or use one of the builtin collection types.

与此同时,您必须复制集合或使用其中一种内置集合类型。

Update since Swift become open source: I believe the Complete generics section of Swift 3.0 Dev Roadmap indicates type variance will be addressed in 3.0. While type variance is not specifically called out, special cased exceptions in the standard library (which includes type variance) are.

自Swift成为开源以来的更新:我相信Swift 3.0开发路线图的完整泛型部分表明类型差异将在3.0中解决。虽然没有特别指出类型方差,但标准库中的特殊外壳异常(包括类型方差)是。

#2

As the OrderedSet<StrengthExercise> is of that specific type it cannot be assigned to the more general OrderedSet<Exercise>. Think about what would happen if you tried to append a Cardio exercise to that OrderedSet after assigning it.

由于OrderedSet 属于该特定类型,因此无法将其分配给更通用的OrderedSet 。想想如果你在分配后将Cardio练习附加到OrderedSet会发生什么。

The answer might be to modify append the contents of the strength exercises set to the exercise set rather than assign the whole typed set.

答案可能是修改将力量练习集的内容附加到练习集而不是分配整个类型集。

#3

this should work

这应该工作

class Base {}
class A: Base {}
class B: Base {}

var arrBase: Array<Base> = []

var arrA: Array<A> = []
arrA.append(A())

var arrB: Array<B> = []
arrB.append(B())

arrBase = arrA   // no error
arrBase = arrB   // no error

... your trouble seems to be somewhere else in your code. can you show us your generic struct OrderedSet implementation ?? it seems like you are trying to do something like

...你的麻烦似乎在你的代码中的其他地方。你能告诉我们你的通用结构OrderedSet实现吗?看起来你正在尝试做类似的事情

class Base {}
class A: Base {}

let base = Base()
let a = A()

struct S<T:Base> {
    var t: T
}
var s = S(t: base)
let sa = S(t: a)
//s = sa  // error: cannot assign value of type 'S<A>' to type 'S<Base>'
let sb = S(t: a as Base)
s = sb

... this works

......这很有效

protocol P {
    func whoAmI()->Void
}
class Base:P {
    func whoAmI() {
        print("I am Base")
    }
}
class A: Base {
    override func whoAmI() {
        print("I am A")
    }
}

let base = Base()
let a = A()

struct S<T: Base> {
    var t: Base
}
var s = S(t: base)
let sa = S(t: a)
s = sa

s.t.whoAmI() // I am A

.... guys, build-in type or not

....伙计们,内置类型与否

import Foundation
// Int and Double conforms to Hashable protocol
var a: Set<Int> = []
var b: Set<Double> = []
a = b   // IMPOSSIBLE eventhough Set<T:Hashable> is build-in Swift type

... how to deal with OrderedSet

...如何处理OrderedSet

import Foundation

class Exercise: Hashable {
    var name: String = ""
    var hashValue: Int {
        return name.hashValue
    }
}
func ==(lhs: Exercise, rhs: Exercise) -> Bool {
    return lhs.name == rhs.name
}
class StrengthExercise: Exercise {}
class CardioExercise: Exercise {}
var displayedExercises = Set<Exercise>()
let strengthExercises = Set<StrengthExercise>()
let cardioExercises = Set<CardioExercise>()
displayedExercises = strengthExercises

// OK, the question is how to implement OrderedSet<T:Hashable>
// ------------------------------------------------------------------------------------------
//
//  OrderedSet.swift
//  Weebly
//
//  Created by James Richard on 10/22/14.
//  Copyright (c) 2014 Weebly. All rights reserved.
//
//  Slightly modified by user3441734 on 11/18/15
//  
//  original code OrderedSet is available under the MIT license


/// An ordered, unique collection of objects.
public struct OrderedSet<T: Hashable> {
    private var contents = [T: Index]() // Needs to have a value of Index instead of Void for fast removals
    private var sequencedContents = Array<UnsafeMutablePointer<T>>()

    /**
     Inititalizes an empty ordered set.

     :return: An empty ordered set.
     */
    public init() { }

    /**
     Initializes a new ordered set with the order and contents
     of sequence.

     If an object appears more than once in the sequence it will only appear
     once in the ordered set, at the position of its first occurance.

     :param: sequence The sequence to initialize the ordered set with.
     :return: An initialized ordered set with the contents of sequence.
     */
    public init<S: SequenceType where S.Generator.Element == T>(sequence: S) {
        // FIXME: For some reason, Swift gives the error "Cannot convert the expression's type 'S' to type 'S'" with a regular for-in, so this is a hack to fix that.
        var gen = sequence.generate()
        while let object: T = gen.next() {
            if contents[object] == nil {
                contents[object] = contents.count

                let pointer = UnsafeMutablePointer<T>.alloc(1)
                pointer.initialize(object)
                sequencedContents.append(pointer)
            }
        }
    }

    /**
     Replace, remove, or retrieve an object in the ordered set.

     When setting an index to nil the object will be removed. If
     it is not the last object in the set, all subsequent objects
     will be shifted down one position.

     When setting an index to another object, the existing object
     at that index will be removed. If you attempt to set an index
     that does not currently have an object, this is a no-op.

     :param:     index   The index to retrieve or set.
     :return:   On get operations, the object at the specified index, or nil
     if no object exists at that index.
     */
    public subscript(index: Index) -> T {
        get {
            return sequencedContents[index].memory
        }

        set {
            contents[sequencedContents[index].memory] = nil
            contents[newValue] = index
            sequencedContents[index].memory = newValue
        }
    }


    /**
     Locate the index of an object in the ordered set.

     It is preferable to use this method over the global find() for performance reasons.

     :param:     object      The object to find the index for.
     :return:    The index of the object, or nil if the object is not in the ordered set.
     */
    public func indexOfObject(object: T) -> Index? {
        if let index = contents[object] {
            return index
        }

        return nil
    }

    /// The number of objects contained in the ordered set.
    public var count: Int {
        return contents.count
    }

    /// Whether the ordered set has any objects or not.
    public var isEmpty: Bool {
        return count == 0
    }

    /**
     Tests if the ordered set contains an object or not.

     :param:     object  The object to search for.
     :return:    true if the object exists in the ordered set, otherwise false.
     */
    public func contains(object: T) -> Bool {
        return contents[object] != nil
    }

    /**
     Appends an object to the end of the ordered set.

     :param:     object  The object to be appended.
     */
    mutating public func append(object: T) {
        if contents[object] != nil {
            return
        }

        contents[object] = contents.count

        let pointer = UnsafeMutablePointer<T>.alloc(1)
        pointer.initialize(object)
        sequencedContents.append(pointer)
    }

    /**
     Appends a sequence of objects to the end of the ordered set.

     :param:     objects  The objects to be appended.
     */
    mutating public func appendObjects<S: SequenceType where S.Generator.Element == T>(objects: S) {
        var gen = objects.generate()
        while let object: T = gen.next() {
            append(object)
        }
    }

    /**
     Removes an object from the ordered set.

     If the object exists in the ordered set, it will be removed.
     If it is not the last object in the ordered set, subsequent
     objects will be shifted down one position.

     :param:     object  The object to be removed.
     */
    mutating public func remove(object: T) {
        if let index = contents[object] {
            contents[object] = nil
            sequencedContents[index].dealloc(1)
            sequencedContents.removeAtIndex(index)

            for (object, i) in contents {
                if i < index {
                    continue
                }

                contents[object] = i - 1
            }
        }
    }

    /**
     Removes the given objects from the ordered set.

     :param:     objects     The objects to be removed.
     */
    mutating public func removeObjects<S: SequenceType where S.Generator.Element == T>(objects: S) {
        var gen = objects.generate()
        while let object: T = gen.next() {
            remove(object)
        }
    }

    /**
     Removes an object at a given index.

     This method will cause a fatal error if you attempt to move an object to an index that is out of bounds.

     :param:     index       The index of the object to be removed.
     */
    mutating public func removeObjectAtIndex(index: Index) {
        if index < 0 || index >= count {
            fatalError("Attempting to remove an object at an index that does not exist")
        }

        remove(sequencedContents[index].memory)
    }

    /**
     Removes all objects in the ordered set.
     */
    mutating public func removeAllObjects() {
        contents.removeAll()
        sequencedContents.removeAll()
    }

    /**
     Return an OrderedSet containing the results of calling
     `transform(x)` on each element `x` of `self`

     :param:     transform   A closure that is called for each element in the ordered set.
     The result of the closure is appended to the new ordered set.
     :result:     An ordered set containing the result of `transform(x)` on each element.
     */
    public func map<U: Hashable>(transform: (T) -> U) -> OrderedSet<U> {
        var result = OrderedSet<U>()

        for object in self {
            result.append(transform(object))
        }

        return result
    }

    /// The first object in the ordered set, or nil if it is empty.
    public var first: T? {
        return count > 0 ? self[0] : nil
    }

    /// The last object in the ordered set, or nil if it is empty.
    public var last: T? {
        return count > 0 ? self[count - 1] : nil
    }

    /**
     Swaps two objects contained within the ordered set.

     Both objects must exist within the set, or the swap will not occur.

     :param:     first   The first object to be swapped.
     :param:     second  The second object to be swapped.
     */
    mutating public func swapObject(first: T, withObject second: T) {
        if let firstPosition = contents[first] {
            if let secondPosition = contents[second] {
                contents[first] = secondPosition
                contents[second] = firstPosition

                sequencedContents[firstPosition].memory = second
                sequencedContents[secondPosition].memory = first
            }
        }
    }

    /**
     Tests if the ordered set contains any objects within a sequence.

     :param:     sequence    The sequence to look for the intersection in.
     :return:    Returns true if the sequence and set contain any equal objects, otherwise false.
     */
    public func intersectsSequence<S: SequenceType where S.Generator.Element == T>(sequence: S) -> Bool {
        var gen = sequence.generate()
        while let object: T = gen.next() {
            if contains(object) {
                return true
            }
        }

        return false
    }

    /**
     Tests if a the ordered set is a subset of another sequence.

     :param:     sequence    The sequence to check.
     :return:    true if the sequence contains all objects contained in the receiver, otherwise false.
     */
    public func isSubsetOfSequence<S: SequenceType where S.Generator.Element == T>(sequence: S) -> Bool {
        for (object, _) in contents {
            if !sequence.contains(object) {
                return false
            }
        }

        return true
    }

    /**
     Moves an object to a different index, shifting all objects in between the movement.

     This method is a no-op if the object doesn't exist in the set or the index is the
     same that the object is currently at.

     This method will cause a fatal error if you attempt to move an object to an index that is out of bounds.

     :param:     object  The object to be moved
     :param:     index   The index that the object should be moved to.
     */
    mutating public func moveObject(object: T, toIndex index: Index) {
        if index < 0 || index >= count {
            fatalError("Attempting to move an object at an index that does not exist")
        }

        if let position = contents[object] {
            // Return if the client attempted to move to the current index
            if position == index {
                return
            }

            let adjustment = position < index ? -1 : 1
            let range = index < position ? index..<position : position..<index
            for (object, i) in contents {
                // Skip items not within the range of movement
                if i < range.startIndex || i > range.endIndex || i == position {
                    continue
                }

                let originalIndex = contents[object]!
                let newIndex = i + adjustment

                let firstObject = sequencedContents[originalIndex].memory
                let secondObject = sequencedContents[newIndex].memory

                sequencedContents[originalIndex].memory = secondObject
                sequencedContents[newIndex].memory = firstObject

                contents[object] = newIndex
            }

            contents[object] = index
        }
    }

    /**
     Moves an object from one index to a different index, shifting all objects in between the movement.

     This method is a no-op if the index is the same that the object is currently at.

     This method will cause a fatal error if you attempt to move an object fro man index that is out of bounds
     or to an index that is out of bounds.

     :param:     index   The index of the object to be moved.
     :param:     toIndex   The index that the object should be moved to.
     */
    mutating public func moveObjectAtIndex(index: Index, toIndex: Index) {
        if ((index < 0 || index >= count) || (toIndex < 0 || toIndex >= count)) {
            fatalError("Attempting to move an object at or to an index that does not exist")
        }

        moveObject(self[index], toIndex: toIndex)
    }

    /**
     Inserts an object at a given index, shifting all objects above it up one.

     This method will cause a fatal error if you attempt to insert the object out of bounds.

     If the object already exists in the OrderedSet, this operation is a no-op.

     :param:     object      The object to be inserted.
     :param:     atIndex     The index to be inserted at.
     */
    mutating public func insertObject(object: T, atIndex index: Index) {
        if index > count || index < 0 {
            fatalError("Attempting to insert an object at an index that does not exist")
        }

        if contents[object] != nil {
            return
        }

        // Append our object, then swap them until its at the end.
        append(object)

        for i in Range(start: index, end: count-1) {
            swapObject(self[i], withObject: self[i+1])
        }
    }

    /**
     Inserts objects at a given index, shifting all objects above it up one.

     This method will cause a fatal error if you attempt to insert the objects out of bounds.

     If an object in objects already exists in the OrderedSet it will not be added. Objects that occur twice
     in the sequence will only be added once.

     :param:     objects      The objects to be inserted.
     :param:     atIndex      The index to be inserted at.
     */
    mutating public func insertObjects<S: SequenceType where S.Generator.Element == T>(objects: S, atIndex index: Index) {
        if index > count || index < 0 {
            fatalError("Attempting to insert an object at an index that does not exist")
        }

        var addedObjectCount = 0
        // FIXME: For some reason, Swift gives the error "Cannot convert the expression's type 'S' to type 'S'" with a regular for-in, so this is a hack to fix that.
        var gen = objects.generate()

        // This loop will make use of our sequncedContents array to update the contents dictionary's
        // values. During this loop there will be duplicate values in the dictionary.
        while let object: T = gen.next() {
            if contents[object] == nil {
                let seqIdx = index + addedObjectCount
                let element = UnsafeMutablePointer<T>.alloc(1)
                element.initialize(object)
                sequencedContents.insert(element, atIndex: seqIdx)
                contents[object] = seqIdx
                addedObjectCount++
            }
        }

        // Now we'll remove duplicates and update the shifted objects position in the contents
        // dictionary.
        for i in index + addedObjectCount..<count {
            contents[sequencedContents[i].memory] = i
        }
    }
}

extension OrderedSet: MutableCollectionType {
    public typealias Index = Int
    public typealias _Element = T
    public typealias Generator = OrderedSetGenerator<T>

    public func generate() -> Generator {
        return OrderedSetGenerator(set: self)
    }

    public var startIndex: Int {
        return 0
    }

    public var endIndex: Int {
        return count
    }
}

public struct OrderedSetGenerator<T: Hashable>: GeneratorType {
    public typealias Element = T
    private var generator: IndexingGenerator<Array<UnsafeMutablePointer<T>>>

    public init(set: OrderedSet<T>) {
        generator = set.sequencedContents.generate()
    }

    mutating public func next() -> Element? {
        return generator.next()?.memory
    }
}



public func +<T: Hashable, S: SequenceType where S.Generator.Element == T> (lhs: OrderedSet<T>, rhs: S) -> OrderedSet<T> {
    var joinedSet = lhs
    joinedSet.appendObjects(rhs)

    return joinedSet
}

public func +=<T: Hashable, S: SequenceType where S.Generator.Element == T> (inout lhs: OrderedSet<T>, rhs: S) {
    lhs.appendObjects(rhs)
}

public func -<T: Hashable, S: SequenceType where S.Generator.Element == T> (lhs: OrderedSet<T>, rhs: S) -> OrderedSet<T> {
    var purgedSet = lhs
    purgedSet.removeObjects(rhs)

    return purgedSet
}

public func -=<T: Hashable, S: SequenceType where S.Generator.Element == T> (inout lhs: OrderedSet<T>, rhs: S) {
    lhs.removeObjects(rhs)
}

extension OrderedSet: Equatable { }

public func ==<T: Hashable> (lhs: OrderedSet<T>, rhs: OrderedSet<T>) -> Bool {
    if lhs.count != rhs.count {
        return false
    }

    for object in lhs {
        if lhs.contents[object] != rhs.contents[object] {
            return false
        }
    }

    return true
}
// ------------------------------------------------------------------------------------------


// finaly what do you want

var displayedExercises1 = OrderedSet<Exercise>()
let strengthExercises1 = OrderedSet<StrengthExercise>()
let cardioExercises1 = OrderedSet<CardioExercise>()
displayedExercises = strengthExercises