Has the core team or the community considered the possibility of implementing
covariant/contravariant generic types? It would really be appreciated.
I know with Array, vague-ifying or specific-ifying the type ([Int] to [Any])
has help from the compiler—and we can use `map` if all else fails—but that only
lessens the impact of the missing functionality. This is my exact use case
here, using SceneKit to identify the first-hit Controller object:
class ControllerNode<Controller: AnyObject>: SCNNode
{
let controller: Controller
}
// Ordered front to back, returns the first Controller object.
for hit in hitTest
{
// Determine if this node is part of a controller.
let ancestrySequence = sequence(first: hit.node, next: { $0.parent })
let lastControllerNode: ControllerNode<AnyObject>? =
ancestrySequence.reduce(nil)
{ ($1 as? ControllerNode) ?? $0 }
if let cabinet = lastControllerNode?.controller as? CabinetController
{ return cabinet }
if let wall = lastControllerNode?.controller as? WallController
{ return wall }
}
This compiles, but unfortunately, this will never work. The `reduce` algorithm
always ends up trying to convert things like `ControllerNode<WallController> as
ControllerNode<AnyObject>`, which—unintuitively—always fails. Without compiler
help, so would things like `myIntArray as [Any]` or `Optional<Boy>(Boy()) as
Optional<Human>`.
If Swift is supposed to welcome generic programming, this would be a great
thing to have._______________________________________________
swift-evolution mailing list
[email protected]
https://lists.swift.org/mailman/listinfo/swift-evolution
