Scala'da foldLeft ve reduceLeft arasındaki fark

Temel fark öğrendim arasında foldLeftvereduceLeft

foldLeft:

• başlangıç ​​değeri geçilmelidir

reduceLeft:

• koleksiyonun ilk öğesini başlangıç ​​değeri olarak alır
• koleksiyon boşsa istisna atar

Başka bir fark var mı?

Benzer işlevselliğe sahip iki yöntemin olması için belirli bir neden var mı?

Gerçek cevabı vermeden önce burada belirtilecek birkaç şey:

• Sorunuzla hiçbir ilgisi yok left, daha çok azaltma ve katlama arasındaki farkla ilgili
• Fark uygulama değildir, sadece imzalara bakın.
• Sorunun özellikle Scala ile bir ilgisi yok, daha ziyade fonksiyonel programlamanın iki kavramı hakkında.

Sorunuza geri dönün:

İşte imzası foldLeft ( foldRightyapacağım nokta için de olabilirdi ):

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

Ve işte imzası reduceLeft (yine yön burada önemli değil)

def reduceLeft [B >: A] (f: (B, A) => B): B

Bu ikisi birbirine çok benzer ve karışıklığa neden oldu. reduceLeftözel bir durumfoldLeft (bu arada bazen aynı şeyi ikisinden birini kullanarak ifade edebileceğiniz anlamına gelir ).

Aradığınızda reduceLeftbir üzerinde söz sahibi List[Int]bu anlamıyla Çeşidi olacak tek bir değer, içine tamsayılar bütün liste azaltacaktırInt (veya bir süpertip Intdolayısıyla [B >: A]).

Aradığınızda foldLefta söylemekList[Int] tek bir değere (kağıt parçası haddeleme hayal) tüm listeyi kat edeceği, ancak bu değer bile ilişkili olmak zorunda değildir Int(dolayısıyla [B]).

İşte bir örnek:

def listWithSum(numbers: List[Int]) = numbers.foldLeft((List.empty[Int], 0)) {
   (resultingTuple, currentInteger) =>
      (currentInteger :: resultingTuple._1, currentInteger + resultingTuple._2)
}

Bu yöntem a alır List[Int]ve a Tuple2[List[Int], Int]veya döndürür (List[Int], Int). Toplamı hesaplar ve bir tamsayılar listesi içeren bir tuple döndürür. Bu arada liste geri döndürülür, çünküfoldLeft yerinefoldRight .

Daha ayrıntılı bir açıklama için hepsini yönetmek için Bir Katlamayı izleyin .

reduceLeftsadece kolaylık sağlayan bir yöntemdir. Eşdeğerdir

list.tail.foldLeft(list.head)(_)

foldLeftdaha genel bir yöntemdir, orijinal olarak koyduğunuzdan tamamen farklı bir şey üretmek için kullanabilirsiniz. Oysa reduceLeftyalnızca aynı türden veya toplama türünün süper türünden bir sonuç üretebilir. Örneğin:

List(1,3,5).foldLeft(0) { _ + _ }
List(1,3,5).foldLeft(List[String]()) { (a, b) => b.toString :: a }

En foldLeftson katlanan sonuçla (ilk değeri ilk kez kullanırken) ve sonraki değeri içeren kapanışı uygular.

reduceLeftÖte yandan, ilk önce listeden iki değeri birleştirecek ve bunları kapatmaya uygulayacaktır. Daha sonra değerlerin geri kalanını kümülatif sonuçla birleştirecektir. Görmek:

List(1,3,5).reduceLeft { (a, b) => println("a " + a + ", b " + b); a + b }

Liste boşsa foldLeft, başlangıç ​​değeri yasal bir sonuç olarak sunulabilir. reduceLeftdiğer yandan listede en az bir değer bulamazsa yasal bir değeri yoktur.

Her ikisinin de Scala standart kütüphanesinde olmasının temel nedeni muhtemelen her ikisinin de Haskell standart kütüphanesinde ( foldlve olarak adlandırılır foldl1) olmasıdır. Olmasaydı reduceLeft, genellikle farklı projelerde bir kolaylık yöntemi olarak tanımlanırdı.

Başvuru için, reduceLeftaşağıdaki hatayla boş bir kapsayıcıya uygulanırsa hata verir.

java.lang.UnsupportedOperationException: empty.reduceLeft

Kullanılacak kodu yeniden işleme

myList foldLeft(List[String]()) {(a,b) => a+b}

potansiyel bir seçenektir. Başka reduceLeftOptionbir seçenek Seçenek sarılmış sonucu döndüren varyantı kullanmaktır .

myList reduceLeftOption {(a,b) => a+b} match {
  case None    => // handle no result as necessary
  case Some(v) => println(v)
}

Gönderen Scala Fonksiyonel Programlama İlkeleri (Martin Odersky):

Fonksiyon reduceLeftdaha genel bir fonksiyon olarak tanımlanır foldLeft,.

foldLeftgibidir reduceLeftancak boş bir listede çağrıldığında döndürülen ek bir parametre olarak bir akümülatör alır :zfoldLeft

(List (x1, ..., xn) foldLeft z)(op) = (...(z op x1) op ...) op x

[aksine reduceLeft, boş bir listede çağrıldığında bir istisna atar.]

Elbette, desen eşleştirme ve özyineleme kullanımlarında çok benzer olmalarına rağmen, bu işlevlerin farklılıklarını gösteren soyut tanımlarını sağlar.

abstract class List[T] { ...
  def reduceLeft(op: (T,T)=>T) : T = this match{
    case Nil     => throw new Error("Nil.reduceLeft")
    case x :: xs => (xs foldLeft x)(op)
  }
  def foldLeft[U](z: U)(op: (U,T)=>U): U = this match{
    case Nil     => z
    case x :: xs => (xs foldLeft op(z, x))(op)
  }
}

Not foldLefttürde bir değer verir Umutlaka aynı türde değildir, List[T]ama reduceLeft listesi aynı tipte) bir değerini verir.

Katlama / azaltma ile ne yaptığınızı gerçekten anlamak için şunu kontrol edin: http://wiki.tcl.tk/17983 çok iyi bir açıklama. katlama kavramını aldıktan sonra, azaltma yukarıdaki cevapla bir araya gelecek: list.tail.foldLeft (list.head) (_)