ความแตกต่างระหว่าง foldLeft และลด leeft ใน Scala

ฉันได้เรียนรู้ความแตกต่างพื้นฐานระหว่างfoldLeftและreduceLeft

foldLeft:

• ค่าเริ่มต้นจะต้องถูกส่งผ่าน

reduceLeft:

• ใช้องค์ประกอบแรกของการรวบรวมเป็นค่าเริ่มต้น
• พ่นข้อยกเว้นถ้าคอลเลกชันว่างเปล่า

มีความแตกต่างอื่น ๆ อีกไหม?

เหตุผลใดที่มีสองวิธีที่มีฟังก์ชั่นคล้ายกัน

มีบางสิ่งที่ต้องพูดถึงที่นี่ก่อนที่จะให้คำตอบจริง:

• คำถามของคุณไม่มีอะไรเกี่ยวข้องกับleftมันค่อนข้างเกี่ยวกับความแตกต่างระหว่างการลดและการพับ
• ความแตกต่างไม่ใช่การใช้งานเลยเพียงแค่ดูที่ลายเซ็น
• คำถามไม่มีส่วนเกี่ยวข้องกับ Scala โดยเฉพาะมันค่อนข้างเกี่ยวกับสองแนวคิดของการเขียนโปรแกรมเชิงฟังก์ชัน

กลับไปที่คำถามของคุณ:

นี่คือลายเซ็นของfoldLeft(อาจเป็นfoldRightสำหรับจุดที่ฉันจะทำด้วย):

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

และนี่คือลายเซ็นต์ของreduceLeft(อีกทิศทางไม่สำคัญที่นี่)

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

ทั้งสองดูคล้ายกันมากและทำให้เกิดความสับสน reduceLeftเป็นกรณีพิเศษของfoldLeft(ซึ่งโดยวิธีการที่บางครั้งคุณสามารถแสดงสิ่งเดียวกันโดยใช้อย่างใดอย่างหนึ่ง)

เมื่อคุณเรียกใช้reduceLeftSay บนList[Int]ตัวอักษรมันจะลดรายการทั้งหมดของจำนวนเต็มเป็นค่าเดียวซึ่งจะเป็นประเภทInt(หรือประเภทของIntดังนั้น[B >: A])

เมื่อคุณโทรfoldLeftพูดบนList[Int]มันจะพับรายการทั้งหมด (ลองนึกภาพม้วนกระดาษ) เป็นค่าเดียว แต่ค่านี้ไม่จำเป็นต้องเกี่ยวข้องแม้แต่กับInt(ดังนั้น[B])

นี่คือตัวอย่าง:

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

วิธีการนี้จะใช้เวลาList[Int]และผลตอบแทนหรือTuple2[List[Int], Int] (List[Int], Int)มันคำนวณผลรวมและส่งกลับ tuple ด้วยรายการจำนวนเต็มและผลรวม โดยวิธีการที่รายการจะถูกส่งกลับไปข้างหลังเพราะเราใช้แทนfoldLeftfoldRight

ดูOne Fold เพื่อควบคุมทั้งหมดสำหรับคำอธิบายเชิงลึก

reduceLeftเป็นเพียงวิธีการอำนวยความสะดวก มันเทียบเท่ากับ

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

foldLeftเป็นแบบทั่วไปมากขึ้นคุณสามารถใช้มันเพื่อสร้างบางสิ่งที่แตกต่างไปจากเดิมอย่างสิ้นเชิงโดยที่คุณreduceLeftสามารถสร้างผลลัพธ์สุดท้ายของประเภทคอลเลกชันเดียวกันหรือประเภทซูเปอร์ ตัวอย่างเช่น:

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

foldLeftจะใช้ปิดที่มีผลพับสุดท้าย (ครั้งแรกที่ใช้ค่าเริ่มต้น) และความคุ้มค่าต่อไป

reduceLeftในทางกลับกันก่อนจะรวมสองค่าจากรายการและนำไปใช้กับการปิด ถัดไปมันจะรวมค่าที่เหลือกับผลสะสม ดู:

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

หากรายการว่างเปล่าfoldLeftสามารถแสดงค่าเริ่มต้นเป็นผลทางกฎหมาย reduceLeftในทางกลับกันไม่มีค่าทางกฎหมายหากไม่สามารถหาค่าอย่างน้อยหนึ่งค่าในรายการ

เหตุผลพื้นฐานที่ทั้งคู่อยู่ในห้องสมุดมาตรฐานของสกาล่าอาจเป็นเพราะพวกเขาทั้งคู่อยู่ในห้องสมุดมาตรฐานของแฮสเคลล์ (เรียกว่าfoldlและfoldl1) ถ้าreduceLeftไม่เป็นเช่นนั้นก็มักจะถูกกำหนดให้เป็นวิธีการอำนวยความสะดวกในโครงการต่างๆ

สำหรับการอ้างอิงreduceLeftจะเกิดข้อผิดพลาดหากนำไปใช้กับภาชนะที่ว่างเปล่าที่มีข้อผิดพลาดดังต่อไปนี้

java.lang.UnsupportedOperationException: empty.reduceLeft

ทำใหม่รหัสที่จะใช้

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

เป็นหนึ่งในตัวเลือกที่มีศักยภาพ อีกวิธีหนึ่งคือการใช้reduceLeftOptionชุดตัวเลือกที่ส่งกลับผลลัพธ์เป็นทางเลือก

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

จากหลักการเขียนโปรแกรมเชิงหน้าที่ใน Scala (Martin Odersky):

ฟังก์ชั่นที่reduceLeftกำหนดไว้ในแง่ของฟังก์ชั่นทั่วไปมากขึ้น, foldLeft.

foldLeftเป็นเหมือนreduceLeftแต่ใช้แอคคูมูเล zเตอร์เป็นพารามิเตอร์เพิ่มเติมซึ่งจะถูกส่งคืนเมื่อfoldLeftถูกเรียกบนรายการว่าง:

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

[ตรงข้ามกับreduceLeftข้อผิดพลาดเมื่อเรียกใช้ในรายการว่าง]

หลักสูตร (ดูการบรรยาย 5.5) ให้คำจำกัดความที่เป็นนามธรรมของฟังก์ชั่นเหล่านี้ซึ่งแสดงให้เห็นถึงความแตกต่างของพวกเขาแม้ว่าพวกเขาจะคล้ายกันมากในการใช้การจับคู่รูปแบบและการเรียกซ้ำ

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

โปรดทราบว่าfoldLeftคืนค่าประเภทUซึ่งไม่จำเป็นต้องเป็นชนิดเดียวกันList[T]แต่ลดค่าระดับต่ำคืนค่าประเภทเดียวกันเป็นรายการ)

หากต้องการทำความเข้าใจกับสิ่งที่คุณทำด้วยการย่อ / ลดให้ตรวจสอบสิ่งนี้: http://wiki.tcl.tk/17983 คำอธิบายที่ดีมาก เมื่อคุณได้รับแนวคิดการพับการลดจะมาพร้อมกับคำตอบข้างต้น: list.tail.foldLeft (list.head) (_)