Расширять типы массивов, используя предложение where в Swift

Я хотел бы использовать фреймворк Accelerate для расширения [Float] и [Double], но для каждого из них требуется другая реализация.

Я пробовал очевидное:

extension Array<Float> {
}

и получите эту ошибку:

"Ограниченное расширение должно быть объявлено на неспециализированном родовом type 'Array' с ограничениями, указанными в предложении 'where'

Можно ли таким образом распространять общие типы в Swift 2?

У меня теперь работает код, как ожидалось. Здесь приведен пример суммирования с использованием ракурса Accelerate.

extension _ArrayType where Generator.Element == Float {

    func quickSum() -> Float {
        var result: Float = 0
        if var x = self as? [Float] {
            vDSP_sve(&x, 1, &result, vDSP_Length(x.count))
        }
        return result
    }
}

extension _ArrayType where Generator.Element == Double {

    func quickSum() -> Double {
        var result: Double = 0
        if var x = self as? [Double] {
            vDSP_sveD(&x, 1, &result, vDSP_Length(x.count))
        }
        return result
    }
}

Ответы

Ответ 1

Если вы хотите расширить только массив с определенным типом. Вы должны расширить протокол _ArrayType.

extension _ArrayType where Generator.Element == Int {

   func doSomething() {
       ... 
   }
}

Если вы расширяете Array, вы можете только убедиться, что ваш элемент соответствует другому протоколу. то есть:

extension Array where Element: Equatable {

   func doSomething() {
       ... 
   }
}

Обновлено: С Swift 3.1 https://github.com/apple/swift/blob/master/CHANGELOG.md

extension Array where Element == Int {

   func doSomething() {
       ... 
   }
}

Ответ 2

Свифт 3 на помощь!

extension Collection where Iterator.Element == Int {
    // `Collection` can be `Sequence`, etc
}

Ответ 3

Как насчет

extension CollectionType where Generator.Element == Double {

}

Или Если вы хотите немного больше:

protocol ArithmeticType {
    func +(lhs: Self, rhs: Self) -> Self
    func -(lhs: Self, rhs: Self) -> Self
    func *(lhs: Self, rhs: Self) -> Self
    func /(lhs: Self, rhs: Self) -> Self
}

extension Double : ArithmeticType {}
extension Float : ArithmeticType {}

extension SequenceType where Generator.Element : protocol<FloatLiteralConvertible, ArithmeticType> {
    var sum : Generator.Element {
        return reduce(0.0, combine: +)
    }

    var product : Generator.Element {
        return reduce(1.0, combine: *)
    }
}


stride(from: 1.0, through: 10.0, by: 1.0).sum   // 55
[1.5, 2.0, 3.5, 4.0, 5.5].product               // 231

Работает с Double и Float или любым другим типом, который соответствует протоколам ArithmeticType и FloatLiteralConvertible. Если вам нужно получить доступ к определенным индексам вашего массива, измените SequenceType на CollectionType, поскольку вы не можете сделать это с помощью последовательности.

Ответ 4

Итак, я не правильно прочитал вопрос. FloatingPointType - это существующий протокол, который реализуется Double, Float и CGFloat, поэтому

Да. Я сделал это только вчера, чтобы добавить функцию в SequenceType, где элементы должны были быть Equatable. Это модификация для ограничения элементов на Float

Вам нужно использовать предложение where. Это моя функция ниже.

public extension SequenceType where Self.Generator.Element: FloatingPointType
{
    public func splitAt(separator: Generator.Element) -> [[Generator.Element]]
    {
        var ret: [[Generator.Element]] = []
        var thisPart: [Generator.Element] = []

        for element in self
        {
            if element == separator
            {
                ret.append(thisPart)
                thisPart = []
            }
            else
            {
                thisPart.append(element)
            }
        }
        ret.append(thisPart)
        return ret
    }
}

[Float(1), Float(2), Float(3), Float(4)].splitAt(Float(2))
// returns [[1],[3, 4]]
[Double(1), Double(2), Double(3), Double(4)].splitAt(Double(3))
// returns [[1, 2],[4]]

NB Я не мог выполнить эту работу для массива, но SequenceType является более общим в любом случае.

Ответ 5

Если вы хотите расширить только Array, вам необходимо использовать протокол для каждого типа:

protocol DoubleValue {
    var value: Double { get }
}
extension Double: DoubleValue {
    var value: Double { return self }
}
extension Array where Element: DoubleValue {
    // use the value property
}

// the same for Float
protocol FloatValue {
    var value: Float { get }
}

extension Float: FloatValue {
    var value: Float { return self }
}
extension Array where Element: FloatValue {
    // use the value property
}

Ответ 6

Swift 3 на Xcode 8.2

Просто нужно расширить протокол Sequence и предоставить оператор where.

let someString = "1, 2, 3, 4, 5, 6, 7, 8"

extension String {        
  func toArrayOfElements() -> [String] {
    return self.components(separatedBy: ", ")
  }        
}

extension Sequence where Iterator.Element == String {        
  func toInt() -> [Int] {            
    return self.map {
      Int($0)!
    }
  }        
}

let arrayOfStrings = someString.toArrayOfElements()    
print(arrayOfStrings)

let arrayOfInts = arrayOfStrings.toInt()    
print(arrayOfInts)