//----------------------------------------------------------------------------
// This program demonstrates (what I assume must be) a compiler bug.
// The compiler forgets some of the same type constraints of the protocol in
// protocol extensions. The issue can be worked around by restating those
// constraints at the extension.
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
// Compiling without the workaround (ie this program, as is):
//----------------------------------------------------------------------------
// $ swiftc --version
// Apple Swift version 5.1.3 (swiftlang-1100.0.282.1 clang-1100.0.33.15)
// Target: x86_64-apple-darwin19.2.0
// $ swiftc test.swift
// test.swift:43:33: error: cannot convert value of type 'Self.Swapped.B' to specified type 'Self.A'
//         let _: Self.A = swapped.b // <- ERROR: Cannot convert value of type
//                         ~~~~~~~~^
//                                   as! Self.A
// test.swift:46:33: error: cannot convert value of type 'Self.Swapped.A' to specified type 'Self.B'
//         let _: Self.B = swapped.a // <- ERROR: Cannot convert value of type
//                         ~~~~~~~~^
//                                   as! Self.B
//
// Same thing when using dev snapshot 2020-01-31, ie:
// Apple Swift version 5.2-dev (Swift a0fbeb9179)
// Target: x86_64-apple-darwin19.2.0
//
//----------------------------------------------------------------------------
// Compiling and running with the workaround (ie after uncommenting line 62):
//----------------------------------------------------------------------------
// $ swiftc test.swift && ./test
// 123 abc
// abc 123
//----------------------------------------------------------------------------


/// A type with a "swapped dual".
/// ```
/// x.swapped.swapped == x
/// && x.a == x.swapped.b
/// && x.b == x.swapped.a
/// ```
/// Note that `x` and `x.swapped` can be of different types,
/// and so can `x.a` and `x.b`.
protocol Swappable where
    Swapped: Swappable,
    Swapped.Swapped == Self,
    Swapped.A == B, Swapped.B == A
{
    associatedtype A
    associatedtype B
    associatedtype Swapped
    var a: A { get }
    var b: B { get }
    var swapped: Swapped { get }
}


// This should compile according to constraints of Swappable, but does not:
extension Swappable
    // WORKAROUND: Uncomment these (restated) constraints:
    // where Swapped.A == B, Swapped.B == A
{
    func bar() {
        let _: Self = swapped.swapped // <- Compiles as expected.
        let _: Self.A = swapped.b // <- ERROR: Cannot convert value of type
        //           'Self.Swapped.B' to specified
        //           type 'Self.A'.
        let _: Self.B = swapped.a // <- ERROR: Cannot convert value of type
        //           'Self.Swapped.A' to specified
        //           type 'Self.B'.
    }
}


struct Pair<L, R> {
    var left: L
    var right: R
}
extension Pair : Swappable{
    var a: L { return left }
    var b: R { return right }
    var swapped: Pair<R, L> { return Pair<R, L>(left: right, right: left) }
}

func foo() {
    // This works as expected (with or without the extension):
    let op = Pair(left: 123, right: "abc") // (op = Original Pair)
    let sp = op.swapped                    // (sp = Swapped Pair)
    print(op.left, op.right) // 123 abc
    print(sp.left, sp.right) // abc 123
}
foo()