Scala : fold vs foldLeft

Je suis en train d'essayer de comprendre comment les plier et de les foldLeft et les réduire et reduceLeft travail. J'ai utilisé les plier et de les foldLeft comme mon exemple

scala> val r = List((ArrayBuffer(1, 2, 3, 4),10))
scala> r.foldLeft(ArrayBuffer(1,2,4,5))((x,y) => x -- y._1)

scala> res28: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(5)

scala> r.fold(ArrayBuffer(1,2,4,5))((x,y) => x -- y._1)
<console>:11: error: value _1 is not a member of Serializable with Equals
              r.fold(ArrayBuffer(1,2,4,5))((x,y) => x -- y._1)

Pourquoi fold n'a pas fonctionné comme foldLeft? Qu'est-ce que Serializable with Equals? Je comprends les plier et de les foldLeft a légèrement différent signature API en termes de paramètre de types génériques. Veuillez informer. Merci.

InformationsquelleAutor thlim | 2013-04-19
  1. 64

    La méthode fold (à l'origine ajoutée pour le calcul parallèle) est moins puissant que foldLeft en termes de types, il peut être appliqué. Sa signature est:

    def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1

    Cela signifie que le type sur lequel le pliage est fait doit être un supertype de la collection du type d'élément.

    def foldLeft[B](z: B)(op: (B, A) => B): B

    La raison en est que fold peut être mis en œuvre en parallèle, tout en foldLeft ne peut pas. Ce n'est pas seulement en raison de la *Left partie ce qui implique que foldLeft va de gauche à droite de façon séquentielle, mais aussi parce que l'opérateur op ne peut pas combiner les résultats calculés en parallèle, il ne définit comment combiner le type d'agrégation B avec le type de l'élément A, mais pas de la façon de combiner les deux agrégations de type B. Le fold méthode, à son tour, ne définissent ce, parce que le type d'agrégation A1 doit être un supertype le type de l'élément A, c'est-à A1 >: A. Cette supertype relation permet dans le même temps, se repliant sur l'agrégation et les éléments, et en combinant les agrégations-à la fois avec un seul opérateur.

    Mais, ce supertype relation entre l'agrégation et le type de l'élément signifie également que le type d'agrégation A1 dans votre exemple, devrait être le supertype de (ArrayBuffer[Int], Int). Depuis le zéro de l'élément de votre agrégation est ArrayBuffer(1, 2, 4, 5) du type ArrayBuffer[Int], le type d'agrégation est déduit d'être le supertype de ces deux -- et c'est Serializable with Equals, le seul moins à la limite supérieure d'un n-uplet et un tableau de la mémoire tampon.

    En général, si vous voulez en parallèle de pliage pour les types arbitraires (qui est en fait hors de l'ordre de), vous devez utiliser la méthode aggregate qui nécessite de définir la façon dont les deux agrégations sont associées. Dans votre cas:

    r.aggregate(ArrayBuffer(1, 2, 4, 5))({ (x, y) => x -- y._1 }, (x, y) => x intersect y)

    Btw, essayez d'écrire votre exemple avec reduce/reduceLeft -- en raison de la supertype relation entre le type d'élément et le type d'agrégation que ces deux méthodes, vous trouverez qu'elle conduit à une erreur similaire à celle que vous avez décrite.

    InformationsquelleAutor axel22