Swift: typecast output array in Collection where Iterator.Element == Foo - arrays

Question

I have the following function, it iterates over an array of Foo, and creates a new array using the items in the original array, but with different colors:
extension Collection where Iterator.Element == Foo {
public func color(colors: [NSColor]) -> [Foo] {
var result: [Foo] = []
for item in self {
for color in colors {
let newItem = Foo(name: item.name, color: color)
result.append(newItem)
}
}
return result
}
}
This works, but if I use it on a subclass Bar of Foo, it still returns [Foo], not [Bar].
I could do something like this:
let colors: [NSColor] = // set colors
let colorArray = array.color(colors).map{ Bar($0.name, $.color)
But then I need to remember to do that every time I call it for a subclass of Foo.
So how can I adjust the function to make it work on subclasses of Foo as well?
EDIT
Based on the comment below, I tried a generic function:
public func color<T>(colors: [NSColor]) -> [T] {
var result: [T] = []
for item in self {
for color in colors {
let newItem = T(name: item.name, color: color)
result.append(newItem)
}
}
return result
}
That gives me the error:
Non-nominal type 'T' does not support explicit initialization
So I searched for that, and found I need to use init:
let newItem = T.init(name: item.name, color: color)
Now I get this error:
Type 'T' has no member 'init'
Foo and Bar have an init, but that doesn't help here. Am I on the right track?
EDIT 2:
Martin's answer below made me realize an error in my code: where Iterator.Element == Foo should have been where Iterator.Element: Foo

Answer 1

You can replace the “same-type constraint” by a “subclass constraint” and use the collections Element type instead of Foo in the implementation:
extension Collection where Element: Foo {
func color(colors: [NSColor]) -> [Element] {
var result: [Element] = []
for item in self {
for color in colors {
let newItem = Element(name: item.name, color: color)
result.append(newItem)
}
}
return result
}
}
Note that this requires Foo (and its subclasses) to have a “required init” method:
required init(name: String, color: NSColor)
Another option is to define a protocol
protocol P {
var name: String { get }
init(name: String, color: NSColor)
}
to which Foo (and its subclasses) conform, and use the constraint
extension Collection where Element: P
for the extension method.
In any case, a more concise implementation would be
extension Collection where Element: Foo {
func color(colors: [NSColor]) -> [Element] {
return self.flatMap { item in
colors.map { Element(name: item.name, color: $0) }
}
}
}
Re your edit: As a free generic method (instead of an extension method) it would be something like
func color<T: P>(items: [T], with colors: [NSColor]) -> [T] {
return items.flatMap { item in
colors.map { T(name: item.name, color: $0) }
}
}
using the protocol defined above. The compiler needs to know that an instance of T can be created from an item name and a color.