I am trying to implement SK combinators in the type system, but an expression that should terminate quickly is throwing the trait resolver into an infinite loop. Have I gotten something wrong, or should I submit this as a bug report?

```
struct S;
struct K;
type I = ((S,K),K);
trait Derive {
type Result;
}
// No Arguments
impl Derive for S { type Result = Self; }
impl Derive for K { type Result = Self; }
// One Argument
impl<X:Derive> Derive for (S,X) { type Result = (S, X::Result); }
impl<X:Derive> Derive for (K,X) { type Result = (K, X::Result); }
// Two Arguments
impl<X,Y> Derive for ((S,X),Y) where
X: Derive,
Y: Derive
{ type Result = ((S,X::Result),Y::Result); }
impl<X,Y> Derive for ((K,X), Y) where X:Derive
{ type Result = X::Result; }
// Three Arguments
impl<X,Y,Z> Derive for (((S, X), Y), Z) where
((X, Z), (Y, Z)): Derive,
{ type Result = <((X, Z), (Y, Z)) as Derive>::Result; }
impl<X,Y,Z> Derive for (((K,X), Y), Z) where
(X,Z): Derive
{ type Result = <(X, Z) as Derive>:: Result; }
// 4+ Arguments
impl<V,W,X,Y,Z,A> Derive for ((((V,W), X), Y), Z) where
(((V,W), X), Y): Derive<Result = A>,
(A,Z): Derive
{ type Result = <(A, Z) as Derive>::Result; }
fn main() {
dbg!(std::any::type_name::<<S as Derive>::Result>());
dbg!(std::any::type_name::<<(S,S) as Derive>::Result>());
dbg!(std::any::type_name::<<((K,S),K) as Derive>::Result>());
dbg!(std::any::type_name::<<(((K,S),K),S) as Derive>::Result>());
dbg!(std::any::type_name::<<(I,S) as Derive>::Result>());
dbg!(std::any::type_name::<<((K,K),K) as Derive>::Result>());
dbg!(std::any::type_name::<<(((S, S), K), S) as Derive>::Result>());
dbg!(std::any::type_name::<<(((S, S), S), S) as Derive>::Result>());
// Uncommenting this line leads to infinite recursion
// dbg!(std::any::type_name::<<(((((K,K),K),S),K),S) as Derive>::Result>());
}
```