How can I extend typed Arrays in Swift?

How can I extend Swift's Array<T> or T[] type with custom functional utils?

Browsing around Swift's API docs shows that Array methods are an extension of the T[], e.g:

extension T[] : ArrayType {
    //...
    init()

    var count: Int { get }

    var capacity: Int { get }

    var isEmpty: Bool { get }

    func copy() -> T[]
}

When copying and pasting the same source and trying any variations like:

extension T[] : ArrayType {
    func foo(){}
}

extension T[] {
    func foo(){}
}

It fails to build with the error:

Nominal type T[] can't be extended

Using the full type definition fails with Use of undefined type 'T', i.e:

extension Array<T> {
    func foo(){}
}

And it also fails with Array<T : Any> and Array<String>.

Curiously Swift lets me extend an untyped array with:

extension Array {
    func each(fn: (Any) -> ()) {
        for i in self {
            fn(i)
        }
    }
}

Which it lets me call with:

[1,2,3].each(println)

But I can't create a proper generic type extension as the type seems to be lost when it flows through the method, e.g trying to replace Swift's built-in filter with:

extension Array {
    func find<T>(fn: (T) -> Bool) -> T[] {
        var to = T[]()
        for x in self {
            let t = x as T
            if fn(t) {
                to += t
            }
        }
        return to
    }
}

But the compiler treats it as untyped where it still allows calling the extension with:

["A","B","C"].find { $0 > "A" }

And when stepped-thru with a debugger indicates the type is Swift.String but it's a build error to try access it like a String without casting it to String first, i.e:

["A","B","C"].find { ($0 as String).compare("A") > 0 }

Does anyone know what's the proper way to create a typed extension method that acts like the built-in extensions?

Solution 1:

For extending typed arrays with classes, the below works for me (Swift 2.2). For example, sorting a typed array:

class HighScoreEntry {
    let score:Int
}

extension Array where Element == HighScoreEntry {
    func sort() -> [HighScoreEntry] {
      return sort { $0.score < $1.score }
    }
}

Trying to do this with a struct or typealias will give an error:

Type 'Element' constrained to a non-protocol type 'HighScoreEntry'

Update:

To extend typed arrays with non-classes use the following approach:

typealias HighScoreEntry = (Int)

extension SequenceType where Generator.Element == HighScoreEntry {
    func sort() -> [HighScoreEntry] {
      return sort { $0 < $1 }
    }
}

In Swift 3 some types have been renamed:

extension Sequence where Iterator.Element == HighScoreEntry 
{
    // ...
}

Solution 2:

After a while trying different things the solution seems to remove the <T> from the signature like:

extension Array {
    func find(fn: (T) -> Bool) -> [T] {
        var to = [T]()
        for x in self {
            let t = x as T;
            if fn(t) {
                to += t
            }
        }
        return to
    }
}

Which now works as intended without build errors:

["A","B","C"].find { $0.compare("A") > 0 }

Solution 3:

Extend all types:

extension Array where Element: Any {
    // ...
}

Extend Comparable types:

extension Array where Element: Comparable {
    // ...
}

Extend some types:

extension Array where Element: Comparable & Hashable {
    // ...
}

Extend a particular type:

extension Array where Element == Int {
    // ...
}