एक परिवर्तन श्रृंखला के परिणाम को एक समारोह में पाइप कैसे करें?

मैं परिवर्तनों की एक श्रृंखला लिखना चाहता हूं और अंततः एक ब्लॉक है जहां मैं परिणाम का संग्रह किए बिना परिणामस्वरूप संग्रह के साथ कुछ करता हूं। क्या संग्रह पर एक उच्च-आदेश फ़ंक्शन है जो केवल उस संग्रह को प्रदान करता है जिस पर इसे आपूर्ति किए गए फ़ंक्शन में बुलाया जाता है?

Query( ... )
  .map { ... }
  .filter { ... }
  .combinations(2)
  .pipeTo { col =>
     ...
     consolidate(col)
  }

बेशक एक समारोह कॉल के लिए कोई ऐसा कर सकता है:

consolidate(
  Query()
    .map { ... }
    .filter { ... }
    .combinations(2)
)

लेकिन पूर्व मेरे लिए अधिक प्राकृतिक पढ़ता है और उदाहरण देता है कुछ सशर्तों के एक आसान इंजेक्शन के लिए।

मैं जिस कामकाज का उपयोग कर रहा हूं वह अंत में एक मैच खंड रख रहा है:

Query()
  .map { ... }
  .filter { ... }
  .combinations(2)
  match { case lst =>
    ...
    consolidate(lst)
  }

लेकिन चूंकि यह पैटर्न अक्सर होता है, इसलिए मैं सोच रहा था कि यह लिखने का बेवकूफ तरीका क्या है।

0
मैंने अपने दूसरे उदाहरण में उस विकल्प को कवर किया, लेकिन यह मैच उदाहरण के बराबर नहीं है क्योंकि बाद में "समेकित" फ़ंक्शन को कॉल करने के अलावा अतिरिक्त प्रसंस्करण की अनुमति मिलती है।
जोड़ा लेखक estolua, स्रोत
यह थोड़ा मूर्ख हो सकता है, लेकिन क्या आप सिर्फ अपनी पूरी श्रृंखला पर समेकित नहीं हो सकते? समेकित (क्वेरी ()। नक्शा (...)। फ़िल्टर (...)। संयोजन (2)) ऐसा लगता है कि यह वही काम करता है जो आपका अंतिम उदाहरण करता है
जोड़ा लेखक Nicolas Rinaudo, स्रोत

1 उत्तर

शायद सबसे बेवकूफ तरीका तथाकथित मेरा लाइब्रेरी पैटर्न पंप , जो किसी को किसी भी कक्षा में अंतर्निहित वर्ग रूपांतरणों के माध्यम से एक्सटेंशन विधियों को जोड़ने की अनुमति देता है।

उदाहरण के लिए, समेकित विधि सूची s में जोड़ने के लिए, आप लिख सकते हैं:

object ListExtensions {
  implicit class ConsolidatableList[T](val lst: List[T]) extends AnyVal {
    def consolidate = ???//Do whatever you want with the List lst
  }
}

import ListExtensions._

List(1,2,3)
  .map(x => x * x)
  .consolidate

यदि आप वास्तव में एक श्रृंखला में मनमानी वस्तुओं पर मनमानी कार्यों को कॉल करने में सक्षम होना चाहते हैं, तो आप एक "पाइपलाइन" ऑपरेटर को भी परिभाषित कर सकते हैं जैसे F #:

object Extensions {
  implicit class PipelineExtension[T](val obj: T) extends AnyVal {
    def |>[S](f: T => S): S = f(obj)
  }
}

import Extensions._

List(1,2,3)
  .map(x => x * x) 
  .|> (consolidate)

Query( ... )
  .map { ... }
  .filter { ... }
  .combinations(2)
  .|> { col =>
     ...
     consolidate(col)
  }

The |> operator behaves like the pipeTo method you have defined.

असल में, यह आपके द्वारा परिभाषित विभिन्न एक्सटेंशन विधियों के साथ प्रकार के प्रकार से एक अंतर्निहित रूपांतरण बनाकर काम करता है। AnyVal एक्सटेंशन क्लास को एक मान क्लास बनाता है, इसलिए इसका उपयोग कम रनटाइम लागत नहीं होगा।

0
जोड़ा
इसलिए मैं इसे स्कैला लाइब्रेरी किसी भी रूप में ऐसे ऑपरेटर की पेशकश नहीं करता हूं?
जोड़ा लेखक estolua, स्रोत
यह नही है कि मैं जानता हूँ। संभवतः, पहले उदाहरण में एक्सटेंशन विधियों को परिभाषित करना या आंशिक परिणामों को पकड़ने के लिए मध्यवर्ती val s को परिभाषित करना और फिर उन मध्यवर्ती val s पर फ़ंक्शन कॉल करना पसंद है।
जोड़ा लेखक kong, स्रोत