scala - studio - mpu6050 arduino tutorial

Más sobre funciones genéricas de Scala

Question

Intentando implementar, en Scala, la siguiente función Haskell (de Learn You a Haskell ...) para que funcione con Int, Double, etc.

doubleUs x y = x * 2 + y * 2 

Tenga en cuenta que esto es similar a Scala: ¿Cómo definir parámetros de función "genéricos"?

Aquí está mi intento y error. ¿Puede alguien explicar lo que está pasando y ofrecer una solución? Gracias.

scala> def doubleUs[A](x:A,y:A)(implicit numeric: Numeric[A]): A = numeric.plus(numeric.times(x,2),numeric.times(y,2)) 
<console>:34: error: type mismatch;
 found   : Int(2)
 required: A
       def doubleUs[A](x:A,y:A)(implicit numeric: Numeric[A]): A = numeric.plus(numeric.times(x,2),numeric.times(y,2)) 

Answer 1

Además de lo que dijo @Dylan, puede hacer que se vea un poco menos tedioso al importar en el alcance los contenidos de Numeric implícito como se muestra a continuación:

scala> def doubleUs[N](x: N, y: N)(implicit ev: Numeric[N]) = {
     |   import ev._
     |   x * fromInt(2) + y * fromInt(2)
     | }
doubleUs: [N](x: N, y: N)(implicit ev: Numeric[N])N

scala> doubleUs(3, 4)
res9: Int = 14

scala> doubleUs(8.9, 1.2)
res10: Double = 20.2

Answer 2

Dylan respondió esencialmente, pero para lo que vale la pena, permítame sugerirle usar la sintaxis vinculada al contexto en lugar del argumento implícito (ambos son equivalentes, y el primero es reescrito automáticamente por el compilador en el último).

def doubleUs[A : Numeric](x : A, y : A) : A = {
  val num = implicitly[Numeric[A]]
  import num.{plus,times,fromInt}
  plus(times(x, fromInt(2)), times(y, fromInt(2)))
}

Answer 3

Está utilizando el Int literal 2 pero scala está esperando el tipo A Numeric . La API numérica de Scala tiene una función de utilidad def fromInt(x:Int): T Esto es lo que desea usar, así que reemplace su uso de 2 con numeric.fromInt(2)

def doubleUs[A](x:A,y:A)(implicit numeric: Numeric[A]): A =
  numeric.plus (numeric.times (x, numeric.fromInt (2)), numeric.times (y, numeric.fromInt (2)))

Además, dado que una instancia numérica define una conversión implícita a un Ops, puede import numeric._ y luego decir x * fromInt(2) + y * fromInt(2) .

Answer 4

Necesita algunas implicaciones en el alcance:

def doubleUs[A](x: A, y: A)(implicit num: Numeric[A]) = {
  import num._
  implicit def fromInt(i: Int) = num.fromInt(i)
  x * 2 + y * 2
}