# Swift: Making Tuples Equatable

*Lots of copypasta*

Until we get a first-class macro system, this involves a lot of copypasta, but it does work:

```
@infix func == <T:Equatable> (lhs: (T), rhs: (T)) -> Bool {
return lhs.0 == rhs.0
}
@infix func == <T:Equatable, T2:Equatable> (lhs: (T,T2), rhs: (T,T2)) -> Bool {
return lhs.0 == rhs.0 &&
lhs.1 == rhs.1
}
@infix func == <T:Equatable, T2:Equatable, T3:Equatable> (lhs: (T,T2,T3), rhs: (T,T2,T3)) -> Bool {
return lhs.0 == rhs.0 &&
lhs.1 == rhs.1 &&
lhs.2 == rhs.2
}
@infix func == <T:Equatable, T2:Equatable, T3:Equatable, T4:Equatable> (lhs: (T,T2,T3,T4), rhs: (T,T2,T3,T4)) -> Bool {
return lhs.0 == rhs.0 &&
lhs.1 == rhs.1 &&
lhs.2 == rhs.2 &&
lhs.3 == rhs.3
}
@infix func == <T:Equatable, T2:Equatable, T3:Equatable, T4:Equatable, T5:Equatable> (lhs: (T,T2,T3,T4, T5), rhs: (T,T2,T3,T4, T5)) -> Bool {
return lhs.0 == rhs.0 &&
lhs.1 == rhs.1 &&
lhs.2 == rhs.2 &&
lhs.3 == rhs.3 &&
lhs.4 == rhs.4
}
```

Now we can do this:

```
func test<T:Equatable,K:Equatable,V:Equatable>(a:(T,K,V), b:(T,K,V)) {
let v = a == b
}
let t1 = (1, 2, "a")
let t2 = (1, 2, "b")
test(t1, t2)
```

I'll be throwing the code up on github soon, along with all the other little bits I've collected.

I tried to extend it to support tuples without constraining all the types to equatable, since it would be nice to avoid having to specify the `Equatable`

constraint over and over, but that led to rdar://17420860

<unknown>:0: error: unable to execute command: Segmentation fault: 11

<unknown>:0: error: swift frontend command failed due to signal (use -v to see invocation)

Command usr/bin/swift failed with exit code 254

Fair warning, if you paste this code into a Swift file, not only will builds fail with a hard crash of the Swift compiler, but Xcode's SourceKit will die too. Repeatedly. Continuously.

```
@infix func == <T, T2, T3> (lhs: (T,T2,T3), rhs: (T,T2,T3)) -> Bool {
return lhs.0 as Equatable == rhs.0 as Equatable &&
lhs.1 as Equatable == rhs.1 as Equatable &&
lhs.2 as Equatable == rhs.2 as Equatable
}
```

I'm working on a feature request to support promoting a given tuple to `Equatable`

if all its elements are `Equatable`

; it would be very handy for some of the work I'm doing to support arbitrary tuples in a generic way (I ultimately don't care how many elements there are, I just care that they all satisfy the `Equatable`

constraint). If I could get a tuple's length and iterate over its items then I could treat it almost like an `Any[]`

.

This blog represents my own personal opinion and is not endorsed by my employer.