सामान्य प्रकार का पूर्वानुमान क्या है?

Question

मैं उत्सुक हूं - Traversable की foreach विधि की घोषणा में जेनेरिक प्रकार U का बिंदु क्या है?

def foreach[U](f: A => U): Unit 

के बाद से Function1 की वापसी प्रकार covariant है, क्यों नहीं है कि बस हो सकता है:

def foreach(f: A => Any): Unit 

?

Answer 1

नहीं मार्टिन ओडर्स्की किया जा रहा है , मैं केवल अनुमान लगा सकता हूं :-) foreach के स्कालाडोक को देखते हुए, मुझे यह दिखाई देता है:

/** Applies a function `f` to all elements of this $coll. 
    * 
    * @param f the function that is applied for its side-effect to every element. 
    *    The result of function `f` is discarded. 
    *    
    * @tparam U the type parameter describing the result of function `f`. 
    *    This result will always be ignored. Typically `U` is `Unit`, 
    *    but this is not necessary. 
    * 
    * @usecase def foreach(f: A => Unit): Unit 
    */ 

तो वापसी का प्रकार f कोई फर्क नहीं पड़ता और इसका परिणाम हमेशा त्याग दिया जाता है। यह मेरे लिए, सुझाव देता है कि रिटर्न प्रकार को चिह्नित करने के लिए यहां एक सामान्य प्रकार पैरामीटर का उपयोग करना केवल एक प्रलेखन सूक्ष्मता है, कह रहा है "वापसी का प्रकार कुछ भी हो सकता है, वास्तव में कुछ भी, आपको पसंद है"। जबकि Any का रिटर्न प्रकार (कुछ) पाठकों को यहां लागू फ़ंक्शन प्रकारों के लिए कुछ प्रकार की सीमा का सुझाव दे सकता है।

एक और पहलू यह है कि स्कैला को बहुत ही जागरूक रूप से जमीन से सामान्य होने के लिए डिज़ाइन किया गया था। तो - मेरे लिए - यहां एक सामान्य प्रकार पैरामीटर का उपयोग करके Any का उपयोग करते समय भाषा के सामान्य दर्शन के अनुरूप है - हालांकि तकनीकी रूप से उपयोग करने योग्य - निश्चित रूप से गैर-सामान्य दृष्टिकोण होगा जो शेष भाषा के साथ बाधाओं में होगा।

Answer 2

शायद आपको Traversable से प्राप्त करने की अनुमति देने के लिए, और से वापसी मूल्य U का कुछ उपयोग करें?

trait TraversableWithHandler[+A, E <: Option[Throwable]] extends Traversable[A] { 
    override def foreach[U](f: A => U): Unit 
    def handleError(t: E) 
} 

jQuery में

उदाहरण के लिए, foreach अंदर से false की वापसी break के बराबर है, किसी भी अलग अलग मूल्य एक continue है।

प्रयोग करें प्रकरण

breakable { 
    List(1,2,3).foreach(_ match { 
    case 1 => println("ok") 
    case 2 => 
     println("Sort of, soft interrupt?") 
     return false 
    case 3 => break 
    }) 
} 

क्योंकि अगली कोड (समानांतर), कभी नहीं टूट जाता है (stackless फेंकने योग्य समाधान इस मामले में गैर आदर्श लगती है?):

import scala.util.control.Breaks._ 

breakable { 
    (0 to 100).toList.par.foreach(_ match { 
    case n if (n <= 50) => 
     println("#" * 100) 
     try { break } catch { 
     case t: Throwable => println("" + t); break 
     } 
    case n if (n > 50) => 
     println("" + n) 
    case _ => "ok" 
    }) 
}