Scala Numeric init con costante 0

Question

Consente di avere una classe di utilità chiamata MathUtil.

e sembra così.

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

Lets ho sottoclasse in questo modo

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 
} 

Ho un problema con l'istruzione

private var sum:T = 0 

Ora, devo inizializzare sommare a 0. direi qualsiasi numerica avere un modo per rappresentare 0. Im abbastanza nuovo per scala. Come posso risolvere questo problema?

Answer 1

Il Numeric type class instance ha un metodo zero che fa quello che si vuole:

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 
} 

Si noti che è necessario anche l'istanza per il metodo plus, a meno che non si importano Numeric.Implicits._, nel qual caso è possibile utilizzare +. È anche possibile pulire il codice un po ', non utilizzando il contesto legato sintassi in questo caso:

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 
} 

Questo è esattamente equivalente: la versione contesto legato è lo zucchero sintattico per questo argomento implicito, ma se avete bisogno di usa esplicitamente questo argomento (come fai qui, per il suo zero), trovo più pulito scrivere la versione desugared.

Answer 2

Penso che ci sia bisogno di essere un piccolo chiarimento di esattamente quello che stai cercando di realizzare. Dai documenti Scala, il tipo numerico stesso è generico. Il mio sentimento qui è ciò che in realtà vuoi è descrivere un'astrazione MathUtil che gestisce qualsiasi [T] numerico piuttosto che sottoclassi di Numeric [_], che è ciò che il tuo codice sta attualmente descrivendo. Ecco l'implementazione corretta basata su tale assunto.

//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 

Se quanto sopra non fa quello che vuoi, chiarisci la tua domanda.