Scala liste de concaténation, ::: vs ++

Quelle est la différence entre ::: et ++ pour la concaténation de listes de Scala?

scala> List(1,2,3) ++ List(4,5)
res0: List[Int] = List(1, 2, 3, 4, 5)

scala> List(1,2,3) ::: List(4,5)
res1: List[Int] = List(1, 2, 3, 4, 5)

scala> res0 == res1
res2: Boolean = true

De la documentation il ressemble ++ est plus général, alors que ::: est Listspécifiques. Est le dernier parce qu'il est utilisé dans d'autres langages fonctionnels?

  • Aussi ::: est un préfixe de l'opérateur, comme toutes les méthodes commençant par :
  • Les réponses assez bien délimiter le chemin que la scala a évolué dans des listes et de l'exploitant de l'homogénéité dans la Scala (ou l'absence de celui-ci). C'est un peu malheureux que quelque chose de si simple a une longue queue de minuties à confondre et à perdre le temps de tout Scala de l'apprenant. J'aimerais que ce soit stabilisé en 2.12.
InformationsquelleAutor Luigi a.k.a. Rhys | 2011-07-02
  1. 303

    Héritage. La liste a été défini à l'origine pour être fonctionnelle-langues-recherche:

    1 :: 2 :: Nil //a list
list1 ::: list2  //concatenation of two lists

list match {
  case head :: tail => "non-empty"
  case Nil          => "empty"
}

    Bien sûr, Scala évolué autres collections, d'une manière ad-hoc. Lorsque 2.8 est sorti, les collections ont été redessinés pour un maximum de réutilisation de code et d'API cohérente, de sorte que vous pouvez utiliser ++ pour concaténer tout deux collections -- et même les itérateurs. Liste, cependant, obtenu de garder son origine opérateurs, à part un ou deux qui s'est obsolète.

    • Ainsi est-il la meilleure pratique pour éviter de ::: en faveur de ++ maintenant? Également utiliser +: au lieu de ::?
    • :: est utile en raison de filtrage (voir Daniel deuxième exemple). Vous ne pouvez pas le faire avec +:
    • Pourtant, à n'importe quel taux. Il est trivial à mettre en œuvre +: et :+ comme objet d'extracteurs.
    • Si vous utilisez List au lieu de Seq, vous pourriez aussi bien utiliser idiomatiques List méthodes. D'autre part, il sera plus difficile de modifier d'un autre type, si jamais vous avez envie de le faire.
    • Je le trouve bon, que l'on a à la fois la Liste idiomatiques opérations (comme :: et :::) et le fonctionnement plus général qui sont communs à d'autres collections. Je ne voudrais pas tomber, soit le fonctionnement de la langue.
    • Scala 2.10 a :+ et +: objet d'extracteurs.
    • pourquoi ++ n'est pas marqué comme obsolète?
    • Pourquoi ++ être obsolète?
    • parce qu'ils (:::, ++) les deux font le même travail (suite) pour les listes. Ou pourquoi ne pas utiliser uniquement ::: pour toutes les séquences au lieu de ++? N'aime pas l'idée en utilisant le même résultat, méthodes, comme avoir marteau rouge et verte pour mettre un clou.
    • Vous ne pouvez pas à la fois le respect d'une convention pour les opérateurs sur la liste et d'utiliser le même opérateur pour les non-listes. Le point de :: et ::: est qu'ils sont List-seulement, comme les autres langues qui en ont. Si vous n'êtes pas venu par le biais de ces langues, il n'aura pas de sens pour vous, ce qui ne signifie pas qu'il est dénué de sens.
    • Ainsi, vous pouvez utiliser :: dans la correspondance de motif. Mais est-ce que toute la pertinence de la méthode ::? Pour des raisons de cohérence, elles sont définies de la même façon, mais ils pourraient ajouter le support pour +: et :+ dans la correspondance de modèle droit?? Est-ce ce 0__'s point?
    • Vous pouvez utiliser +: dans la correspondance de motif. Il n'y a pas de raison d'utiliser ::, dans la correspondance de motif ou d'ailleurs, à l'exception d'une esthétique de préférence, si vous en avez un.

    InformationsquelleAutor Daniel C. Sobral
  2. 83

    ::: ne fonctionne qu'avec des listes, alors que ++ peut être utilisé avec n'importe quel traversable. Dans l'implémentation actuelle (2.9.0), ++ retombe sur ::: si l'argument est aussi un List.

    • Il est donc très facile à utiliser à la fois ::: ++ et de travail avec la liste. Qui peuvent potentiellement mettre un bordel à code / style.
    InformationsquelleAutor paradigmatic
  3. 81

    Toujours utiliser :::. Il y a deux raisons: l'efficacité et la sécurité de type.

    Efficacité

    x ::: y ::: z est plus rapide que x ++ y ++ z, parce que ::: est droit associatif. x ::: y ::: z est analysée comme x ::: (y ::: z), qui est algorithmiquement plus vite que (x ::: y) ::: z (ce dernier nécessite O(|x|) plus).

    De sécurité de Type

    Avec ::: vous ne pouvez concaténer deux Lists. Avec ++ vous pouvez ajouter n'importe quelle collection de List, ce qui est terrible:

    scala> List(1, 2, 3) ++ "ab"
res0: List[AnyVal] = List(1, 2, 3, a, b)

    ++ est également facile à mélanger avec +:

    scala> List(1, 2, 3) + "ab"
res1: String = List(1, 2, 3)ab
    • Lors de la concaténation de seulement 2 listes, il n'y a pas de différence, mais dans le cas de 3 ou plus, vous avez un bon point, et j'ai confirmé avec un rapide benchmark. Toutefois, si vous êtes inquiet au sujet de l'efficacité, x ::: y ::: z doit être remplacé par List(x, y, z).flatten. pastebin.com/gkx7Hpad
    • il n'ajoute pas beaucoup de sécurité de type... List(1) ::: List("2") devient List[Any] = List(1, 2). Si le type de la sécurité est une préoccupation(comme il devrait l'être), je vous recommande d'éviter à la fois ++ et ::: en faveur de scalaz de |+| ou similaire. Si l'efficacité est la principale préoccupation, puis par tous les moyens l'utilisation :::
    • Veuillez expliquer, pourquoi la gauche associative concaténation nécessite plus de O(x) des mesures. Je pensais que les deux d'entre eux travaillent pour O(1).
    • Les listes sont individuellement liée, pour ajouter une liste à l'autre, vous devez faire une copie de la première liste qui a le deuxième joint à la fin. L'enchaînement est donc O(n) le nombre d'éléments dans la première liste. La longueur de la deuxième liste n'a pas d'effet sur l'exécution ainsi, il est préférable d'ajouter une longue liste pour une courte durée, plutôt que d'ajouter une courte liste est longue.
    • Scala listes sont immuable. C'est pourquoi nous ne pouvons pas simplement remplacer le dernier lien, quand on fait de la concaténation. Nous devons créer une nouvelle liste à partir de zéro.
    • ZhekaKozlov je comprends que la scala collections sont immuables, mais les deux opérateurs de concaténation - ::: et ++ utiliser le même concept avec ListBuffer sous le capot et deux d'entre eux doivent avoir le même temps de la complexité - O(n) où n = x + y + z, si je me trompe, s'il vous plaît, corrigez-moi.
    • Mais les deux concaténation - x ::: (y ::: z) et (x ::: y) ::: z vigueur à l'itération le long de toutes les listes - x, y, z mais dans un ordre différent. x ::: (y ::: z) doit itérer y et z et en fin de compte x, tandis que (x ::: y) ::: z - x et y et enfin z. Et algorithmiquement dans les deux cas, il O(n) n = x+y+z
    • La complexité est toujours linéaire par rapport à la longueur de x et y (z n'est jamais réitéré, en tout cas, n'a aucune influence sur le temps d'exécution, c'est pourquoi il est préférable d'ajouter une longue liste pour une courte durée, que l'inverse), mais la complexité asymptotique ne pas raconter toute l'histoire. x ::: (y ::: z) itère y et ajoute z, puis itère x et ajoute le résultat de y ::: z. x et y sont à la fois réitéré une fois. (x ::: y) ::: z itère x et ajoute y, puis itère le résultat de x ::: y et ajoute z. y est encore réitéré une fois, mais x est répété deux fois dans ce cas.

    InformationsquelleAutor ZhekaKozlov
  4. 20

    Un autre point est que la première phrase est analysée comme:

    scala> List(1,2,3).++(List(4,5))
res0: List[Int] = List(1, 2, 3, 4, 5)

    Alors que le deuxième exemple est analysé comme:

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

    Donc, si vous utilisez des macros, vous devez prendre soin de.

    En outre, ++ pour les deux listes appelle ::: mais avec plus de surcharge, car il demande une valeur implicite de disposer d'un générateur de Liste de Liste. Mais microbenchmarks n'a pas à prouver quoi que ce soit d'utile dans ce sens, je suppose que le compilateur optimise de tels appels.

    Micro-Benchmarks après l'échauffement.

    scala>def time(a: => Unit): Long = { val t = System.currentTimeMillis; a; System.currentTimeMillis - t}
scala>def average(a: () => Long) = (for(i<-1 to 100) yield a()).sum/100

scala>average (() => time { (List[Int]() /: (1 to 1000)) { case (l, e) => l ++ List(e) } })
res1: Long = 46
scala>average (() => time { (List[Int]() /: (1 to 1000)) { case (l, e) => l ::: List(e ) } })
res2: Long = 46

    Comme Daniel C. Sobrai dit, vous pouvez ajouter le contenu de n'importe quelle collection d'une liste à l'aide de ++, alors qu'avec ::: vous ne pouvez concaténer des listes.

    • Merci de ne poster votre pas trop simpliste microbenchmarks et je vais voter en place.
    InformationsquelleAutor Mikaël Mayer