Scala: Nil vs List ()

128

Gibt es in Scala überhaupt einen Unterschied zwischen Nilund List()?

Wenn nicht, welcher ist der idiomatischere Scala-Stil? Sowohl zum Erstellen neuer leerer Listen als auch zum Mustervergleich für leere Listen.

scala

— Bart
quelle

Antworten:

188

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

Nil ist idiomatischer und kann in den meisten Fällen bevorzugt werden. Fragen?

— Benutzer unbekannt
quelle

Man könnte erwähnen, dass Nildas idiomatischer ist.

— Rex Kerr

System.identityHashCode wurde hinzugefügt, um zu verdeutlichen, was "eq" bereits sagt - es handelt sich um dasselbe Objekt.

— James Iry

Außerdem verweist Nil direkt auf ein Objekt, während List () ein Methodenaufruf ist.

— Jean-Philippe Pellet

Ist ein Akkumulatorwert für foldLeft nicht List[A]()(nicht Nil) erforderlich? Beispiel - Die

scala> Map(1 -> "hello", 2 -> "world").foldLeft(List[String]())( (acc, el) => acc :+ el._2) res1: List[String] = List(hello, world)

Verwendung Nilals Akkumulator hier würde nicht funktionieren.

— Kevin Meredith

Map(1 -> "hello", 2 -> "world").foldLeft(Nil: List[String])( _ :+ _._2)

— Raul

Unbekannter Benutzer hat gezeigt, dass der Laufzeitwert von beiden Nilund List()gleich ist. Ihr statischer Typ ist jedoch nicht:

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

Dies ist von besonderer Bedeutung, wenn es verwendet wird, um auf einen Typ zu schließen, z. B. im Akkumulator einer Falte:

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)
                                               ^

— Daniel C. Sobral
quelle

Ich verstehe nicht, warum 2 :: Nil funktioniert, aber nicht Fold's Akkumulator y :: x

— FUD

@FUD Nun, y :: x funktioniert . Das Problem ist, dass der zurückgegebene Typ nicht der erwartete Typ ist. Es kehrt zurück List[Int], während der erwartete Typ entweder List[Nothing]oder ist Nil.type(ich denke der erstere, aber vielleicht der letztere).

— Daniel C. Sobral

Wie die Antwort des unbekannten Benutzers zeigt, handelt es sich um dasselbe Objekt.

Idiomatisch sollte Nil bevorzugt werden, weil es schön und kurz ist. Es gibt jedoch eine Ausnahme: Wenn aus irgendeinem Grund ein expliziter Typ benötigt wird, denke ich

List[Foo]()

ist schöner als

Nil : List[Foo]

— James Iry
quelle

Es gibt auch List.empty[Foo]eine dritte Alternative.

— Kassens