Scala: Néant vs Liste()

Question

En Scala, quelle est la différence entre, Nil et List()?

Si non, lequel est le plus idiomatique à la Scala de style? À la fois pour la création de nouveaux vides listes et le pattern matching sur vide listes.

Answer 1

scala> println (Nil == List())
true

scala> println (Nil eq List())
true

scala> println (Nil equals List())
true

scala> System.identityHashCode(Nil)
374527572

scala> System.identityHashCode(List())
374527572

Nul n'est plus idiomatique et peut être préférée dans la plupart des cas. Des Questions?

Answer 2

Utilisateur inconnu a montré que le temps d'exécution de la valeur de deux Nil et List() sont les mêmes. Cependant, leur type statique n'est pas:

scala> val x = List()
x: List[Nothing] = List()

scala> val y = Nil
y: scala.collection.immutable.Nil.type = List()

scala> def cmpTypes[A, B](a: A, b: B)(implicit ev: A =:= B = null) = if (ev eq null) false else true
cmpTypes: [A, B](a: A, b: B)(implicit ev: =:=[A,B])Boolean

scala> cmpTypes(x, y)
res0: Boolean = false

scala> cmpTypes(x, x)
res1: Boolean = true

scala> cmpTypes(y, y)
res2: Boolean = true

Ceci est particulièrement important quand il est utilisé pour en déduire un type, comme dans un pli de l'accumulateur:

scala> List(1, 2, 3).foldLeft(List[Int]())((x, y) => y :: x)
res6: List[Int] = List(3, 2, 1)

scala> List(1, 2, 3).foldLeft(Nil)((x, y) => y :: x)
<console>:10: error: type mismatch;
 found   : List[Int]
 required: scala.collection.immutable.Nil.type
       List(1, 2, 3).foldLeft(Nil)((x, y) => y :: x)
                                               ^

Answer 3

En tant qu'utilisateur inconnu de la réponse indique, ils sont le même objet.

Idiomatique Néant doit être préférée, car elle est belle et courte. Il y a cependant une exception: si un type explicite est nécessaire pour quelque raison que ce soit, je pense

List[Foo]() 

est plus agréable que de

Nil : List[Foo]