स्थिर 0

Question

के साथ स्कैला न्यूमेरिक init मेरे पास MathUtil नामक एक उपयोगिता वर्ग है।

और ऐसा लगता है।

abstract class MathUtil(T:Numeric){ 
    def nextNumber(value:T) 
    def result():T 
} 

मैं इसे इस तरह से

class SumUtil[T:Numeric] extends MathUtil[T]{ 
    private var sum:T = 0 
    override def nextNumber(value:T){ 
    sum = sum + value 
    } 
    override def result():T = sum 
} 

उपवर्ग मैं

private var sum:T = 0 

अब बयान के साथ एक समस्या है, मैं 0 पर योग करने के लिए मैं किसी भी सांख्यिक लगता होगा प्रारंभ करने के लिए है की सुविधा देता है 0 का प्रतिनिधित्व करने का एक तरीका है। मैं स्कैला के लिए बहुत नया हूं। मैं इस मुद्दे को कैसे हल करूं?

class SumUtil[T: Numeric] extends MathUtil[T] { 
    private var sum: T = implicitly[Numeric[T]].zero 
    override def nextNumber(value: T) { 
    sum = implicitly[Numeric[T]].plus(sum, value) 
    } 
    override def result(): T = sum 
} 

ध्यान दें, जिस स्थिति में आप + उपयोग कर सकते हैं कि आप भी, plus विधि के लिए उदाहरण की जरूरत है जब तक आप Numeric.Implicits._ आयात:

Answer 1

Numeric type class instance करता है कि आप क्या चाहते हैं एक zero विधि है। तुम भी संदर्भ इस मामले में वाक्य रचना के लिए बाध्य का उपयोग नहीं कर से थोड़ा कोड साफ कर सकते हैं:

class SumUtil[T](implicit ev: Numeric[T]) extends MathUtil[T] { 
    import Numeric.Implicits._ 
    private var sum: T = ev.zero 
    override def nextNumber(value: T) { 
    sum = sum + value 
    } 
    override def result(): T = sum 
} 

यह ठीक बराबर है: संदर्भ बाध्य संस्करण इस अंतर्निहित तर्क के लिए बस वाक्यात्मक चीनी है, लेकिन आप की जरूरत है उस तर्क का स्पष्ट रूप से उपयोग करें (जैसा कि आप यहां करते हैं, इसके zero के लिए), मुझे यह desugared संस्करण लिखने के लिए क्लीनर लगता है।

Answer 2

मुझे लगता है कि आप जो कुछ करने की कोशिश कर रहे हैं उसके बारे में थोड़ा सा स्पष्टीकरण होना चाहिए। स्कैला दस्तावेज़ों से, संख्यात्मक प्रकार स्वयं सामान्य है। मेरी भावना यह है कि आप वास्तव में जो चाहते हैं वह गणित का वर्णन करना है जो अमूर्त [_] के उप-वर्गों के बजाय किसी भी संख्यात्मक [टी] को संभालता है जो कि आपका कोड वर्तमान में वर्णन कर रहा है। उस धारणा के आधार पर सही कार्यान्वयन यहां दिया गया है।

//Define a MathUtil that works on any T 
abstract class MathUtil[T] { 
    def nextNumber(value: T) 
    def result(): T 
} 

//Define a SumUtil that works on any T that has an available Numeric 
//Will search implicit scope, but also allows you to provide an 
//implementation if desired. 
class SumUtil[T](implicit n: Numeric[T]) extends MathUtil[T] { 
    //Use the Numeric to generate the zero correctly. 
    private var sum: T = n.zero 
    //Use the Numeric to correctly add the sum and value 
    override def nextNumber(value: T) = sum = n.plus(sum, value) 
    override def result(): T = sum 
} 

//Test that it works. 
val a = new SumUtil[Int] 
val b = List(1,2,3) 

b map a.nextNumber //Quick and dirty test... returns a meaningless list 
println(a.result) //Does indeed print 6 

यदि उपरोक्त आप जो चाहते हैं वह नहीं करता है, तो कृपया अपने प्रश्न को स्पष्ट करें।