# [swift-users] Experimenting with conditional conformances

Antonino Ficarra antonino.ficarra at gmail.com
Wed Nov 29 00:08:54 CST 2017

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

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>
```