स्केला: एक कार्यात्मक ढंग से संग्रह से एक वर जमा (है कि, कोई वार्स है)

Question

यह एक नौसिखिया सवाल

है मैं निम्नलिखित कोड है:

var total = 0L 
docs.foreach(total += _.length) 

डॉक्स में मैं का एक संग्रह है .length संपत्ति के साथ वस्तुओं

मैं की तरह कुछ करना चाहते हैं:

val total = docs.[someScalaMethod](0, (element, acum) => acum + element.length) 

मेरा मतलब है, एक विधि है कि दोहराता प्रत्येक तत्व एक संचायक चर गुजर ...

पहले शून्य मैं संचायक वर का प्रारंभिक मूल्य होना चाहिए पारित ..

यह कैसे प्राप्त किया जा सकता?

Answer 1

यह एक गुना कहा जाता है। यह लगभग ठीक है कि तुम क्या कहा गया है:

docs.foldLeft(0)((accum, element) => accum + element.length) 

संस्करण है कि बाएं से दाएं (आमतौर पर बेहतर से संग्रह को पार करता लिए

; दाएं से बाएं foldRight है, और 2.9 एक fold कि कहीं भी शुरू कर सकते हैं है, लेकिन पर कैसे सीमाएँ हैं यह प्रकार को बदल सकता है)।

एक बार जब आप इसका उपयोग कर लेंगे, तो गुना बाएं का एक छोटा सा संस्करण है, जहां संचयक बाईं ओर जाता है (इसे लगता है कि इसे बाएं से दाएं सूची में धक्का दिया जाता है), और आप प्लेसहोल्डर का उपयोग करते हैं चर नाम के बाद से आप केवल उन्हें एक बार का उपयोग प्रत्येक: (0 /: docs)(_ + _.length)

Answer 2

docs map { _.length } reduce { _ + _ } 

या (tHX लुइगी Plinge को जाता है)

docs.map(_.length).sum 

Answer 3

यहाँ एक Scalaz संस्करण है:

docs.foldMap(_.length) 

यह docs.map(_.length).sum के बराबर है लेकिन केवल एक ही पास लेता है। इसके अलावा, सभी monoids के साथ काम करता है।