সাধারণভাবে, সমস্ত 6 ভাঁজ ফাংশন সংগ্রহের প্রতিটি উপাদানগুলিতে বাইনারি অপারেটর প্রয়োগ করে। প্রতিটি পদক্ষেপের ফলাফল পরবর্তী পদক্ষেপে পৌঁছে দেওয়া হয় (বাইনারি অপারেটরের দুটি আর্গুমেন্টের মধ্যে একটিতে ইনপুট হিসাবে)। এই ভাবে আমরা করতে স্তূপীকৃত করা একটি ফলাফল।
reduceLeftএবং reduceRightএকক ফলাফল সংগ্রহ করা।
foldLeftএবং foldRightএকটি শুরুর মানটি ব্যবহার করে একটি ফলাফল অর্জন করুন।
scanLeftএবং scanRightএকটি প্রারম্ভিক মান ব্যবহার করে মধ্যবর্তী संचयी ফলাফলগুলির সংগ্রহ সংগ্রহ করুন ulate
স্তূপাকার করা
বাম এবং এগিয়ে থেকে ...
উপাদানগুলির সংগ্রহ abcএবং একটি বাইনারি অপারেটরের সাহায্যে addআমরা সংগ্রহের এলএইফটি উপাদানটি থেকে এগিয়ে যাওয়ার সময় বিভিন্ন ভাঁজ ফাংশনগুলি কী করে তা অন্বেষণ করতে পারি (এ থেকে সিতে):
val abc = List("A", "B", "C")
def add(res: String, x: String) = {
println(s"op: $res + $x = ${res + x}")
res + x
}
abc.reduceLeft(add)
// op: A + B = AB
// op: AB + C = ABC // accumulates value AB in *first* operator arg `res`
// res: String = ABC
abc.foldLeft("z")(add) // with start value "z"
// op: z + A = zA // initial extra operation
// op: zA + B = zAB
// op: zAB + C = zABC
// res: String = zABC
abc.scanLeft("z")(add)
// op: z + A = zA // same operations as foldLeft above...
// op: zA + B = zAB
// op: zAB + C = zABC
// res: List[String] = List(z, zA, zAB, zABC) // maps intermediate results
ডান দিক থেকে এবং পিছনে ...
আমরা যদি সঠিক উপাদানটি দিয়ে শুরু করি এবং পিছনের দিকে চলে যাই (সি থেকে ক এ) আমরা লক্ষ্য করব যে এখন আমাদের বাইনারি অপারেটরের দ্বিতীয় তর্কটি ফলাফল সংগ্রহ করে (অপারেটরটি একই, আমরা তাদের ভূমিকাগুলি পরিষ্কার করার জন্য আর্গুমেন্টের নামগুলি পরিবর্তন করেছি) ):
def add(x: String, res: String) = {
println(s"op: $x + $res = ${x + res}")
x + res
}
abc.reduceRight(add)
// op: B + C = BC
// op: A + BC = ABC // accumulates value BC in *second* operator arg `res`
// res: String = ABC
abc.foldRight("z")(add)
// op: C + z = Cz
// op: B + Cz = BCz
// op: A + BCz = ABCz
// res: String = ABCz
abc.scanRight("z")(add)
// op: C + z = Cz
// op: B + Cz = BCz
// op: A + BCz = ABCz
// res: List[String] = List(ABCz, BCz, Cz, z)
।
ডি-স্তূপীকৃত করা
বাম এবং এগিয়ে থেকে ...
পরিবর্তে যদি আমরা কোনও সংগ্রহের এলএইফটি উপাদান থেকে শুরু করে বিয়োগ করে কিছু ফলাফল ডি-কমুলেট করি, আমরা resআমাদের বাইনারি অপারেটরের প্রথম যুক্তির মাধ্যমে ফলাফলটি সংহত করব minus:
val xs = List(1, 2, 3, 4)
def minus(res: Int, x: Int) = {
println(s"op: $res - $x = ${res - x}")
res - x
}
xs.reduceLeft(minus)
// op: 1 - 2 = -1
// op: -1 - 3 = -4 // de-cumulates value -1 in *first* operator arg `res`
// op: -4 - 4 = -8
// res: Int = -8
xs.foldLeft(0)(minus)
// op: 0 - 1 = -1
// op: -1 - 2 = -3
// op: -3 - 3 = -6
// op: -6 - 4 = -10
// res: Int = -10
xs.scanLeft(0)(minus)
// op: 0 - 1 = -1
// op: -1 - 2 = -3
// op: -3 - 3 = -6
// op: -6 - 4 = -10
// res: List[Int] = List(0, -1, -3, -6, -10)
ডান দিক থেকে এবং পিছনে ...
তবে এখনই এক্সরাইটের বৈচিত্রগুলি সন্ধান করুন! মনে রাখবেন যে xRight প্রকরণের (ডি-) জমে থাকা মানটি আমাদের বাইনারি অপারেটরের দ্বিতীয় প্যারামিটারে চলে গেছে :resminus
def minus(x: Int, res: Int) = {
println(s"op: $x - $res = ${x - res}")
x - res
}
xs.reduceRight(minus)
// op: 3 - 4 = -1
// op: 2 - -1 = 3 // de-cumulates value -1 in *second* operator arg `res`
// op: 1 - 3 = -2
// res: Int = -2
xs.foldRight(0)(minus)
// op: 4 - 0 = 4
// op: 3 - 4 = -1
// op: 2 - -1 = 3
// op: 1 - 3 = -2
// res: Int = -2
xs.scanRight(0)(minus)
// op: 4 - 0 = 4
// op: 3 - 4 = -1
// op: 2 - -1 = 3
// op: 1 - 3 = -2
// res: List[Int] = List(-2, 3, -1, 4, 0)
শেষ তালিকা (-2, 3, -1, 4, 0) সম্ভবত আপনি যা স্বজ্ঞাতভাবে আশা করবেন তা নয়!
আপনি দেখতে পাচ্ছেন, পরিবর্তে কেবল একটি স্ক্যানএক্স চালিয়ে আপনার ফোল্ডএক্স কী করছে তা পরীক্ষা করতে পারেন এবং প্রতিটি পদক্ষেপে বদ্ধ ফলাফলটি ডিবাগ করতে পারেন।
শেষের সারি