Can you extend a generic class (eg Array) with specific constraints?

Question

I would like to extend the Array class, but only for elements which conform to the SequenceType protocol.

The code I would like to write / the code I think would be sensible is:

extension Array {
    func flatten<T: SequenceType>() -> [T.Generator.Element] {
        var result = [T.Generator.Element]() // *** [2]

        for seq: T in self { // *** [1]
            for elem in seq {
                result += [elem]
            }
        }

        return result
    }
}

However, Swift seems to create two versions of T. I assume one comes from the normal Array declaration, and the other from the attempted constraint on my method.

In particular, this means that line [1] gives the lovely error 'T' is not convertible to 'T'.

Similarly, the line at [2] fails, because in that context Swift does not recognise T as having a .Generator member (although the return type annotation in the declaration is valid).

I've tried a number of other formulations (including using, eg, T where T: SequenceType), but I can't seem to find a way to express this constraint. Is this possible, or am I barking up the wrong tree?

An alternative would be func flatten<T: SequenceType>(array: [T]) -> [T.Generator.Element] {... — jtbandes
– jtbandes, Commented Aug 8, 2014 at 0:17
@jtbandes - I actually thought the same, but trying for a generic version of that function crashes my compiler >< (stackoverflow.com/questions/25194210/…) — sapi
– sapi, Commented Aug 8, 2014 at 0:18

Gregory Higley · Accepted Answer · 2014-12-21 20:02:36Z

2

The answer to this, as commenters to your question have already stated, is no. However, it's pretty clear from the organization of the Swift standard library that writing a specialized generic function as a method is discouraged. (I suspect that will change as Swift's type system evolves.) For instance, notice that there is no contains method of Swift's native array type. Instead, it is implemented as a global function, because of the requirement that elements be Equatable. This is precisely because of the limitation you encountered: It is not possible to specialize a generic type parameter of the enclosing class in a method, whether it's an extension or not. (This is, in my opinion, a truly unfortunate limitation.)

So, as Swift currently stands, I would "implement" flatten by just using join, e.g., join([], arrayOfArrays).

edited Dec 21, 2014 at 20:02

answered Dec 21, 2014 at 17:41

Gregory Higley

16.7k9 gold badges71 silver badges102 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

sapi Over a year ago

Yeah, that's a fair point from an architectural standpoint. They seem to have made the decision to go for consistency (aka Python) rather than ease of use/reading (Ruby), which is fair enough.

Jake Brownson · Accepted Answer · 2015-06-19 19:19:22Z

2

With Swift 2 this is now possible:

extension SequenceType where Generator.Element : SequenceType {
    func flatten() -> [Generator.Element.Generator.Element] {
        var result: [Generator.Element.Generator.Element] = []
        for seq in self {
            result += seq
        }
        return result
    }
}

[[1,2,3],[],[2,4,5]].flatten() // [1, 2, 3, 2, 4, 5]

Note though that this specific function isn't so important now that we have flatMap in the library.

answered Jun 19, 2015 at 19:19

Jake Brownson

4892 silver badges11 bronze badges

Collectives™ on Stack Overflow

Can you extend a generic class (eg Array) with specific constraints?

2 Answers 2

1 Comment

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related