Общее расширение для массива в Swift

Как упоминалось в комментариях, один из способов добиться этого — создать собственный протокол, который будут использовать типы, которые вы хотите охватить (в комментариях кто-то назвал его Content, использованный ниже для этого примера) (от первый источник):

protocol Content {
    var hash: String { get }
}
extension Array where Element : Content {

    func filterWithId(id : String) -> [Element] {
        return self.filter { (item) -> Bool in
            return item.id == id
        }
    }
}

Однако кажется, что исходный вопрос в основном касается общих расширений для массивов, которые, как говорится в одном комментарии, невозможны, но 100% возможны в Swift (на самом деле это большая функция Swift) (от второй источник).

Например, если вы хотите определить конкретный метод расширения только для Ints, вы можете сделать это:

extension Sequence where Iterator.Element == Int {
    var sum: Int {
        return reduce(0, +)
    }
}

Похоже, что первоначальные требования вопроса - это методы расширения, которые могут не зависеть от типа данных и, следовательно, должны быть общими. Если я правильно понимаю, кажется, что эти типы данных в целом имеют некоторое соответствие Equatable и/или Hashable, что является минимальным требованием для работы такого рода универсальных вещей. Однако с этим соответствием элемента это возможно как таковое:

extension Sequence where Iterator.Element is Equatable {
    func extensionMethodName<T: Equatable>(_ input: [T], singleElement: T) -> [T] {
        // T is now a generic array of equatable items. You can implement whatever extension logic you need with these. 
        // I added different ways of passing in and returning this generic type, but the only thing that is likely going to be consistent is the `<T: Equatable>` which is Swift standard syntax for declaring generic type parameters for a method.
    }
}

Синтаксис Swift быстро меняется, и то, что здесь есть, может быстро устареть, но это руководство постоянно обновляется Apple и показывает самый последний синтаксис для Generics, использованного выше ^.

Мой ответ основан на паре StackOverflow вопросов/ответов, использованных для примера/синтаксиса выше ^. Источник: (источник SO) (источник SO 2)

Таким образом, все вышеперечисленные методы могут быть объединены для полностью индивидуального решения расширения, которое имеет как общие функции/переменные для всех ваших Array типов, так и при этом имеет переопределения расширения для конкретного типа.

В предложении where вы указываете «Если тип элемента имеет эти правила, рассмотрите это расширение».

Вам не нужно реализовывать все методы во всех расширениях.

Например:

• Вы хотите расширить Array<Element>, чтобы он обычно имел метод foo(_:Element):

  extension Array {
      func foo(bar: Element) { /*your code goes here */ }
  }
  

• Вы хотите расширить Array<Element> там, где Element реализовал Equatable (включая Int, Double и... или любые структуры/классы, которые вы пометили как Equatable):

  extension Array where Element: Equatable {
      func find(value: Element) -> Bool { 
          return index(of: value) != nil
      }
  }
  

• Вы хотите расширить Sequence в случаях, когда Element равно Numeric, иметь переменную sum только для чтения:

  extension Sequence where Element: Numeric {
      var sum: Element { 
          return reduce(0, +)
      }
  }
  

• Вы хотите расширить Collection<Collection<Element: Equatable>>, чтобы иметь метод для сравнения с 2D-коллекциями:

  extension Collection
      where Iterator.Element: Collection, 
      Iterator.Element.Iterator.Element: Equatable {
  
      func compare(to: Self) -> Bool {
          let flattenSelf = self.reduce([], +)
          let flattenTo = to.reduce([], +)
  
          return flattenSelf.count == flattenTo.count &&
              zip(flattenSelf, flattenTo).reduce(true) { $0 && $1.0 == $1.1 }
      }
  }
  

Вам не нужно расширять массив или коллекцию, чтобы иметь такие методы, как sort, find и т. д. Большинство этих методов уже расширены внутри компилятора, если ваш Element: Equatable или Element: Comparable. используя map, filter и reduce, вы можете создавать более сложные структуры с небольшим количеством кода.