Esto fue una sorpresa bastante desagradable:

scala> Set(1, 2, 3, 4, 5)       
res18: scala.collection.immutable.Set[Int] = Set(4, 5, 1, 2, 3)
scala> Set(1, 2, 3, 4, 5).toList
res25: List[Int] = List(5, 1, 2, 3, 4)

El ejemplo en sí mismo sugiere una respuesta "no" a mi pregunta. Entonces, ¿qué pasa conListSet?

scala> import scala.collection.immutable.ListSet
scala> ListSet(1, 2, 3, 4, 5)
res21: scala.collection.immutable.ListSet[Int] = Set(1, 2, 3, 4, 5)

Este parece funcionar, pero ¿debo confiar en este comportamiento? ¿Qué otra estructura de datos es adecuada para una colección inmutable de elementos únicos, donde se debe preservar el pedido original?

Por cierto, sé sobredistict método enList. El problema es que quiero imponer la unicidad de los elementos (al tiempo que se preserva el orden) en el nivel de la interfaz, por lo que utilizodistinct estropearía mi diseño aseado ..

EDITA

ListSet tampoco parece muy confiable:

scala> ListSet(1, 2, 3, 4, 5).toList
res28: List[Int] = List(5, 4, 3, 2, 1)

EDIT2

En mi búsqueda de un diseño perfecto probé esto:

scala> class MyList[A](list: List[A]) { val values = list.distinct }
scala> implicit def toMyList[A](l: List[A]) = new MyList(l)
scala> implicit def fromMyList[A](l: MyList[A]) = l.values     

Lo que realmente funciona:

scala> val l1: MyList[Int] = List(1, 2, 3)
scala> l1.values
res0: List[Int] = List(1, 2, 3)

scala> val l2: List[Int] = new MyList(List(1, 2, 3))
l2: List[Int] = List(1, 2, 3)

El problema, sin embargo, es que no quiero exponer aMyList fuera de la biblioteca. ¿Hay alguna forma de tener la conversión implícita al anular? Por ejemplo

trait T { def l: MyList[_] }
object O extends T { val l: MyList[_] = List(1, 2, 3) }
scala> O.l mkString(" ")  // Let's test the implicit conversion
res7: String = 1 2 3      

Me gustaría hacerlo así:

object O extends T { val l = List(1, 2, 3) }  // Doesn't work