sự khác biệt giữa FoldLeft và lessLeft trong Scala

Tôi đã học được sự khác biệt cơ bản giữa foldLeftvàreduceLeft

nếp gấp:

• giá trị ban đầu phải được thông qua

giảm sức mạnh:

• lấy phần tử đầu tiên của bộ sưu tập làm giá trị ban đầu
• ném ngoại lệ nếu bộ sưu tập trống

Có sự khác biệt nào khác không?

Bất kỳ lý do cụ thể để có hai phương pháp với chức năng tương tự?

Vài điều cần đề cập ở đây, trước khi đưa ra câu trả lời thực tế:

• Câu hỏi của bạn không liên quan gì left, đó là về sự khác biệt giữa giảm và gấp
• Sự khác biệt hoàn toàn không phải là việc thực hiện, chỉ cần nhìn vào chữ ký.
• Câu hỏi không liên quan gì đến Scala nói riêng, đó là về hai khái niệm lập trình chức năng.

Quay lại câu hỏi của bạn:

Đây là chữ ký của foldLeft (cũng có thể foldRightlà điểm mà tôi sẽ thực hiện):

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

Và đây là chữ ký của reduceLeft (một lần nữa hướng không quan trọng ở đây)

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

Hai cái này trông rất giống nhau và do đó gây ra sự nhầm lẫn. reduceLeftlà một trường hợp đặc biệt củafoldLeft (điều này có nghĩa là đôi khi bạn có thể diễn đạt điều tương tự bằng cách sử dụng một trong hai).

Khi bạn gọi reduceLeftsay trên một List[Int]nghĩa đen, nó sẽ giảm toàn bộ danh sách các số nguyên thành một giá trị duy nhất, sẽ thuộc loạiInt (hoặc siêu kiểu Int, do đó [B >: A]).

Khi bạn gọi foldLeftnói trên mộtList[Int] nó sẽ gấp toàn bộ danh sách (tưởng tượng cuộn một mảnh giấy) thành một giá trị duy nhất, nhưng giá trị này không nhất thiết phải liên quan đến Int(do đó [B]).

Đây là một ví dụ:

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

Phương pháp này lấy một List[Int]và trả về một Tuple2[List[Int], Int]hoặc (List[Int], Int). Nó tính toán tổng và trả về một tuple với danh sách các số nguyên và đó là tổng. Bằng cách này, danh sách được trả lại, bởi vì chúng tôi đã sử dụng foldLeftthay vì foldRight.

Xem One Fold để thống trị tất cả để có giải thích sâu hơn.

reduceLeftchỉ là một phương pháp thuận tiện. Nó tương đương với

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

foldLeftlà chung chung hơn, bạn có thể sử dụng nó để tạo ra một cái gì đó hoàn toàn khác với những gì bạn đặt vào ban đầu. Trong khi đó, reduceLeftchỉ có thể tạo ra kết quả cuối cùng của cùng loại hoặc siêu loại của bộ sưu tập. Ví dụ:

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

Các foldLeftsẽ áp dụng việc đóng cửa với kết quả xếp cuối cùng (lần đầu tiên sử dụng giá trị ban đầu) và giá trị tiếp theo.

reduceLeftmặt khác trước tiên sẽ kết hợp hai giá trị từ danh sách và áp dụng các giá trị đó vào bao đóng. Tiếp theo, nó sẽ kết hợp phần còn lại của các giá trị với kết quả tích lũy. Xem:

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

Nếu danh sách trống foldLeftcó thể trình bày giá trị ban đầu là kết quả pháp lý. reduceLeftmặt khác không có giá trị pháp lý nếu nó không thể tìm thấy ít nhất một giá trị trong danh sách.

Lý do cơ bản cả hai đều nằm trong thư viện tiêu chuẩn Scala có lẽ là vì cả hai đều nằm trong thư viện chuẩn Haskell (được gọi foldlvà foldl1). Nếu reduceLeftkhông, nó thường được định nghĩa là một phương thức thuận tiện trong các dự án khác nhau.

Để tham khảo, reduceLeftsẽ lỗi nếu áp dụng cho một container rỗng với lỗi sau.

java.lang.UnsupportedOperationException: empty.reduceLeft

Làm lại mã để sử dụng

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

là một lựa chọn tiềm năng. Một cách khác là sử dụng reduceLeftOptionbiến thể trả về kết quả được bọc Tùy chọn.

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

Từ các nguyên tắc lập trình chức năng trong Scala (Martin Oderky):

Hàm reduceLeftđược định nghĩa dưới dạng hàm tổng quát hơn , foldLeft.

foldLeftgiống như reduceLeftnhưng lấy một bộ tích lũy z , như một tham số bổ sung, được trả về khi foldLeftđược gọi trong danh sách trống:

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

[trái ngược với reduceLeft, nó ném một ngoại lệ khi được gọi trong danh sách trống.]

Khóa học (xem bài giảng 5.5) cung cấp các định nghĩa trừu tượng về các chức năng này, minh họa cho sự khác biệt của chúng, mặc dù chúng rất giống nhau trong việc sử dụng phương thức khớp và đệ quy mẫu.

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

Lưu ý rằng foldLefttrả về một giá trị của loại U, không nhất thiết phải cùng loại với List[T], nhưng lessLeft trả về một giá trị cùng loại với danh sách).

Để thực sự hiểu những gì bạn đang làm với nếp gấp / giảm, hãy kiểm tra điều này: http://wiki.tcl.tk/17983 giải thích rất tốt. một khi bạn có được khái niệm về nếp gấp, giảm sẽ đi kèm với câu trả lời ở trên: list.tail. FoldLeft (list.head) (_)