In scala, is it possible to have a two-elements only Set? - scala

Question

In the end, I want to have a case class Swap so that Swap(a, b) == Swap(b, a).
I thought I could use a Set of two elements, and it quite does the job :
scala> case class Swap(val s:Set[Int])
defined class Swap
scala> Swap(Set(2, 1)) == Swap(Set(1, 2))
res0: Boolean = true
But this allows for any number of elements, and I would like to limit my elements to two. I found the class Set.Set2, which is the default implementation for an immutable Set with two elements, but it doesn't work the way I tried, or variations of it :
scala> val a = Set(2, 1)
a: scala.collection.immutable.Set[Int] = Set(2, 1)
scala> a.getClass
res3: Class[_ <: scala.collection.immutable.Set[Int]] = class scala.collection.immutable.Set$Set2
scala> case class Swap(val s:Set.Set2[Int])
defined class Swap
scala> val swp = Swap(a)
<console>:10: error: type mismatch;
found : scala.collection.immutable.Set[Int]
required: Set.Set2[Int]
val swp = Swap(a)
^
So my questions are :
is there a way to use Set2 as I try ?
is there a better way to implement my case class Swap ? I read that one shouldn't override equals in a case class, though it was my first idea.

Answer 1

This is a generic implementation -
import scala.collection.immutable.Set.Set2
def set2[T](a: T, b: T): Set2[T] = Set(a, b).asInstanceOf[Set2[T]]
case class Swap[T](s: Set2[T])
Swap(set2(1,2)) == Swap(set2(2,1)) //true
The reason that your solution didn't work is because of the signature
Set(elems: A*): Set
In case of 2 elements the concrete type will be Set2 but the compiler doesn't know that so you have to cast it to Set2

Answer 2

You can always hide the implementation details of Swap, in this case you actually should.
You could implement it using Set or you could implement it as:
// invariant a <= b
class Swap private (val a: Int, val b: Int)
object Swap {
def apply(a: Int, b: Int): Swap =
if (a <= b) new Swap(a, b) else new Swap(b, a)
}
Unfortunately you have to use class here and reimplement equals hashCode etc yourself, as we cannot get rid of scalac auto-generated apply: related SO Q/A
And make all functions on Swap maintain that invariant.
Then equals comparion is essentially this.a == other.a && this.b == other.b, we don't need to care about swapping anymore.

Answer 3

The problem is that you don't know statically that a is a Set2 - as far as the compiler is concerned you called Set(as: A*) and got back some kind of Set.
You could use shapeless sized collections to enforce a statically known collection size.