विभिन्न संख्यात्मक प्रकारों की सूची स्वीकार करने वाले कार्यों को परिभाषित करने के लिए स्कैला तरीका

Question

मुझे निम्न समस्या है: मेरे पास एक ऐसा फ़ंक्शन है जो सूची [डबल] पैरामीटर के रूप में लेता है, सूची के तत्वों पर कुछ अंकगणितीय परिचालन करता है और परिणाम लौटाता है । मैं समारोह को सूची [Int] स्वीकार करने के लिए भी चाहता हूं।

def f(l: List[Double]) = { 
    var s = 0.0 
    for (i <- l) 
     s += i 
    s 
} 

val l1 = List(1.0, 2.0, 3.0) 
val l2 = List(1, 2, 3) 

println(f(l1)) 
println(f(l2)) 

पाठ्यक्रम दूसरा println च के बाद से विफल रहता है के

सूची [डबल] और सूची नहीं [इंट] की आवश्यकता है: यहाँ एक उदाहरण है।

फ़ंक्शन के भीतर 0 (या अन्य स्थिरांक) का उपयोग करने की आवश्यकता को प्रमाणित करने के लिए एफ फ़ंक्शन के भीतर योग की गैर स्कैला शैली फॉर्मूलेशन को भी ध्यान दें (यदि मैं इंट वैल्यू को जोड़ता हूं तो मुझे 0 में प्रवेश करना होगा नहीं 0.0।

सबसे अच्छा तरीका है (कम कोड) डबल और इंट दोनों पर समारोह काम पाने के लिए?

(मैंने देखा है कुछ 2.8 के बारे में संख्यात्मक विशेषता मैं इसे कैसे उपयोग करने के लिए इतना यकीन नहीं कर रहा है कौन सा ...)

मदद के लिए

धन्यवाद सब लोग।

Answer 1

स्केला 2.8 और संख्यात्मक का उपयोग कर के साथ अंतर्निहित रूपांतरण के लिए गठबंधन के रूप में अपने उदाहरण लिखा जा सकता है:

import Numeric._ 
def f[T](l: List[T])(implicit n: Numeric[T]):T = { 
    var s = n.zero 
    for (i <- l) 
     s = n.plus(s, i) 
    s 
} 

val l1 = List(1.0, 2.0, 3.0) 
val l2 = List(1, 2, 3) 

println(f(l1)) 
println(f(l2)) 

//or 
def f2[T](l: List[T])(implicit n: Numeric[T]):T = { 
import n._ 
var s = zero 
for (i <- l) 
    s += i 
s 
} 
println(f2(l1)) 
println(f2(l2)) 

अब एक और अधिक स्केला तरह से योग कर रही है एक और उदाहरण:

def sum[T](l:List[T])(implicit n: Numeric[T]):T = { 
import n._ 
l.foldLeft(zero)(_ + _) 
} 

println(sum(l1)) 
println(sum(l2)) 

//or since 2.8 Seq include already a sum function 
def sum[T](l:List[T])(implicit n: Numeric[T]):T = l.sum 

println(sum(l1)) 
println(sum(l2)) 

Answer 2

This answer संख्यात्मक विशेषता का उपयोग करता है।

import Numeric._ 
def f[A](l: List[A])(implicit numeric: Numeric[A]) = 
    l reduceLeft ((l,r) => numeric.plus(l, r)) 

या इसका उपयोग करते संदर्भ सीमा:

def f[A : Numeric](l: List[A]) = 
    l.reduceLeft((l,r) => implicitly[Numeric[A]].plus(l, r))