[swift-evolution] Generic types—covariance/contravariance

[Braeden Profile]

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.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://lists.swift.org/pipermail/swift-evolution/attachments/20161208/7beb0840/attachment.html>