protocol XType {
    associatedtype Value
    func doX(_ value1: Value, _ value2: Value) -> Bool
}
protocol YType {
    associatedtype Value
    func doY(_ value: Value)
}

protocol A: Equatable {
    associatedtype X: XType
    static var x: X { get }
}

protocol B: A {
    associatedtype Y: YType
    static var y: Y { get }
}

extension B where Y == X {
    static var x: X {
        return y
    }
}
struct X<T> {
    typealias Value = T
}
struct Y<T> {
    typealias Value = T
}
extension X: XType {
    func doX(_ value1: Value, _ value2: Value) -> Bool { return true }
}
extension Y: XType {
    func doX(_ value1: Value, _ value2: Value) -> Bool { return true }
}
extension Y: YType {
    func doY(_ value: T) {}
}

func ==<T: A>(lhs: T, rhs: T) -> Bool where T.X.Value == T {
    return T.x.doX(lhs, rhs)
}

struct M: B {
    static var y: Y<M> {
        return Y()
    }
}