reduce e agregação

Às vezes, você deseja combinar os elementos sem fornecer um valor de semente separado.

reduce usa o primeiro elemento como acumulador inicial e combina os demais com ele.

Ele é um parente mais enxuto de fold para casos em que o tipo dos elementos e o tipo do resultado são iguais.

reduce recebe uma função binária (a, b) e a aplica à coleção, sem um valor inicial explícito.

Para uma soma, ele simplesmente adiciona todos os elementos.

Como reduce não tem uma semente, chamá-lo em uma coleção vazia lança uma UnsupportedOperationException.

fold e foldLeft são seguros em coleções vazias porque usam como alternativa a semente fornecida.

Use reduce somente quando souber que a coleção não está vazia.

reduceOption retorna um Option, fornecendo None para uma coleção vazia em vez de lançar uma exceção.

Essa é a forma segura de realizar uma redução quando a coleção pode estar vazia.

Assim como fold, reduce tem variantes direcionais.

reduceLeft combina da esquerda para a direita; reduceRight, da direita para a esquerda. reduce simples não oferece garantia de ordem para coleções paralelas, portanto use a variante explícita quando a direção for importante.

fold e reduce exigem que os tipos do acumulador e dos elementos tenham uma relação simples.

aggregate é a forma mais geral de fold: permite que o acumulador tenha um tipo diferente AND informa ao Scala como unir acumuladores parciais, o que é importante para o processamento paralelo.

aggregate recebe uma semente, uma seqop que dobra um elemento no acumulador e uma combop que une dois acumuladores.

Em uma coleção sequencial, combop raramente é usado; em uma coleção paralela, ele une os resultados de cada bloco.

Aqui, aggregate dobra uma lista de palavras em um total único do tipo Int, correspondente ao comprimento.

seqop adiciona o comprimento de cada palavra, enquanto combop adiciona dois totais parciais.

O tipo do acumulador (Int) é diferente do tipo dos elementos (String).

O verdadeiro poder de aggregate aparece com coleções paralelas.

Cada thread dobra seu próprio bloco com seqop; depois, os blocos são unidos com combop. As duas funções permitem que Scala divida e reúna o trabalho com segurança.

Use reduce ou reduceOption quando o tipo do resultado for igual ao tipo dos elementos e a combinação for associativa.

Use foldLeft quando precisar de uma semente ou de um tipo de resultado diferente em processamento sequencial.

Use aggregate quando os tipos do acumulador e dos elementos forem diferentes e você quiser uma combinação adequada ao processamento paralelo.

aggregate pode calcular várias coisas ao mesmo tempo acumulando os resultados em uma tupla.

Aqui, obtemos a soma e a contagem em uma única passagem, unindo as tuplas em combop.

A redução combina elementos sem um valor inicial, usando o primeiro elemento como início; ela lança uma exceção em uma coleção vazia, enquanto reduceOption retorna None.

aggregate é a dobra mais geral: um valor inicial, uma seqop para dobrar os elementos e uma combop para combinar acumuladores parciais em operações paralelas.

Escolha a redução para combinações associativas do mesmo tipo, foldLeft para dobras sequenciais com valor inicial e aggregate quando os tipos forem diferentes ou quando houver paralelismo.