For a generic class, where the generic type conforms to protocol X, how to create an instance of that class with a generic protocol - swift

Question

I want to create a class Game with a generic type which conforms to Equatable. Then I want to be able to use types, which are not by default equatable, like Shape.
If I create an instance with type String, everything works aas intended.
If I create an instance with type Shape, it fails, as expected, since Shape does not conform to Equatable.
My Idea is to use a protocol EquatableShape, which conforms to both Shape and Equatable. Then use it like that:
import SwiftUI
struct Game<Content> where Content: Equatable {
}
var stringGame: Game<String> // ok
var shapeGame: Game<Shape> // obviously fails, since Shapes are not Equatable
// error message: "error: MyPlayground.playground:8:16: error: type 'any Shape' does not conform to protocol 'Equatable'
// Define a protocol EquatableShape, which is Equatable
protocol EquatableShape: Shape & Equatable { }
// Optional: provide a default implementation
extension EquatableShape {
static func == (lhs: any EquatableShape, rhs: any EquatableShape) -> Bool {
return true // some logic here
}
}
// Now every instance which conforms to EquatableShape also conforms to Equatable
struct CircleES: EquatableShape {
func path(in rect: CGRect) -> Path {
return Circle().path(in: rect)
}
}
var circleESGame: Game<CircleES>
// Therefore the compiler should realise this
var equatableShapeGame: Game<EquatableShape> // <= Why does this fail?
// error message: "error: MyPlayground.playground:30:25: error: type 'any EquatableShape' cannot conform to 'Equatable'"
// <= Why does it say EquatableShape CANNOT perform to 'Equatable', while 'any Shape' DOES NOT conform to protocol 'Equatable'
// Workaround 1: Define a container, which stores the shape.
struct EquatableShapeContainer: Equatable {
static func == (lhs: EquatableShapeContainer, rhs: EquatableShapeContainer) -> Bool {
return true
}
let shape: any Shape
}
// This works, but seems like a hacky workaround and not how it should be done.
var equatableShapeContainerGame: Game<EquatableShapeContainer>

Answer 1

EquatableShape is a protocol inheriting Equatable and indeed every type conforming to EquatableShape is also conforming to Equatable.
CircleES on the other hand is a struct (ie. a concrete type) conforming to EquatableShape.
Only concrete types can conform to protocol and that is why
var circleESGame: Game<CircleES>
does compile.
With :
var equatableShapeGame: Game<EquatableShape>
You are passing a protocol inheriting Equatable when the generic constraints asks for a concrete type conforming to Equatable