[swift-users] Experimenting with conditional conformances

[Antonino Ficarra]

There are different algorithms for Element==CGPoint, Element==[CGPoint],  Element==[AreaPoint], etc…

Your second suggestion work:

protocol Inertial {
	func	convexHull( _ t:AffineTransform? ) -> [CGPoint]
	func	area( _ t:AffineTransform? ) -> CGFloat
	func	firstOrderMomentums( _ t:AffineTransform? ) -> (x:CGFloat,y:CGFloat)
	func	secondOrderMomentums( _ t:AffineTransform? ) -> (xx:CGFloat,xy:CGFloat,yy:CGFloat)
}

protocol InertialElement {
	static func convexHull( elements:[Self], _ t: AffineTransform?) -> [CGPoint]
	static func area( elements:[Self],_ t: AffineTransform?) -> CGFloat
	static func firstOrderMomentums( elements:[Self],_ t: AffineTransform?) -> (x: CGFloat, y: CGFloat)
	static func secondOrderMomentums( elements:[Self],_ t: AffineTransform?) -> (xx: CGFloat, xy: CGFloat, yy: CGFloat)
}

extension Array : Inertial where Element : InertialElement {
	func convexHull(_ t: AffineTransform?) -> [CGPoint] {
		return Element.convexHull(elements: self, t)
	}
	
	func area(_ t: AffineTransform?) -> CGFloat {
		return Element.area(elements: self, t)
	}
	
	func firstOrderMomentums(_ t: AffineTransform?) -> (x: CGFloat, y: CGFloat) {
		return Element.firstOrderMomentums(elements: self, t)
	}
	
	func secondOrderMomentums(_ t: AffineTransform?) -> (xx: CGFloat, xy: CGFloat, yy: CGFloat) {
		return Element.secondOrderMomentums(elements: self, t)
	}
}

and than:

extension CGPoint : InertialElement  {
	static func convexHull( elements:[CGPoint], _ t: AffineTransform?) -> [CGPoint] {
		return ConvexHull.convexHull( points:elements ).map { $0 * t }
	}
	
	static func area( elements:[CGPoint],_ t: AffineTransform?) -> CGFloat {
		return InertialUti.area( polig: elements,t )
	}
	
	static func firstOrderMomentums( elements:[CGPoint],_ t: AffineTransform?) -> (x: CGFloat, y: CGFloat) {
		return InertialUti.firstOrderMomentums( polig:elements,t )
	}
	
	static func secondOrderMomentums( elements:[CGPoint],_ t: AffineTransform?) -> (xx: CGFloat, xy: CGFloat, yy: CGFloat) {
		return InertialUti.secondOrderMomentums( polig:elements,t )
	}
}

extension Array : InertialElement where Element == CGPoint {
	...
}

extension AreaPoint : InertialElement  {
	...
}


etc...

Thanks, Slava. :-)

Antonino

> Il giorno 28 nov 2017, alle ore 23:17, Slava Pestov <spestov at apple.com> ha scritto:
> 
> Hi Antonio,
> 
> This is explicitly mentioned in the original proposal. We do not allow multiple conditional conformances to be defined for the same type. Instead, is it possible to express your conformance as follows?
> 
> extension Array : Intertial where Element : Inertial { … }
> 
> Or do you really need different algorithms for Element == CGPoint and Element == [CGPoint], with no conformance for Element == [[CGPoint]], etc?
> 
> If the latter, you could possibly have an InertialElement protocol or similar that CGPoint and [CGPoint] conform to, with a second level of dispatch to pick between the two cases.
> 
> Slava
> 

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://lists.swift.org/pipermail/swift-users/attachments/20171129/849dfa43/attachment.html>