Qual è il modo più conciso per incrementare una variabile di tipo Short in Scala?

Question

Ultimamente ho lavorato un po 'su come implementare un protocollo di rete binario in Scala. Molti dei campi nei pacchetti sono naturalmente associati a Scala Shorts. Vorrei incrementare in modo conciso una variabile Short (non un valore). Idealmente, vorrei qualcosa come s += 1 (che funziona per Ints).

scala> var s = 0:Short 
s: Short = 0 

scala> s += 1 
<console>:9: error: type mismatch; 
found : Int 
required: Short 
       s += 1 
       ^

scala> s = s + 1 
<console>:8: error: type mismatch; 
found : Int 
required: Short 
     s = s + 1 
      ^

scala> s = (s + 1).toShort 
s: Short = 1 

scala> s = (s + 1.toShort) 
<console>:8: error: type mismatch; 
found : Int 
required: Short 
     s = (s + 1.toShort) 
      ^

scala> s = (s + 1.toShort).toShort 
s: Short = 2 

L'operatore += non è definita su Short, quindi sembra esserci un implicito conversione s a un Int precede l'aggiunta. Inoltre l'operatore + Short restituisce un Int. Ecco come funziona per Ints:

scala> var i = 0 
i: Int = 0 

scala> i += 1 

scala> i 
res2: Int = 1 

Per ora mi vado con s = (s + 1).toShort

Tutte le idee?

Answer 1

Si potrebbe definire un metodo implicito che converte il Int ad un Short:

scala> var s: Short = 0 
s: Short = 0 

scala> implicit def toShort(x: Int): Short = x.toShort 
toShort: (x: Int)Short 

scala> s = s + 1 
s: Short = 1 

Il compilatore lo userà per fare la partita tipi. Nota anche se ciò implica anche un deficit, da qualche parte si potrebbe avere una conversione in corso senza nemmeno sapere perché, solo perché il metodo è stato importato nell'ambito, anche la leggibilità del codice ne risente.