scala - ocultar - instagram how to hide hashtags

Confusión de patrones de Scala con Opción

Question

Tengo el siguiente código de Scala.

import scala.actors.Actor

object Alice extends Actor {
  this.start
  def act{
    loop{
      react {
        case "Hello" => sender ! "Hi"
        case i:Int => sender ! 0
      }
    }
  }
}
object Test {
  def test = {
    (Alice !? (100, "Hello")) match {
      case i:Some[Int] => println ("Int received "+i)
      case s:Some[String] => println ("String received "+s)
      case _ =>
    }
    (Alice !? (100, 1)) match {
      case i:Some[Int] => println ("Int received "+i)
      case s:Some[String] => println ("String received "+s)
      case _ =>
    }
  }
}

Después de hacer Test.test , obtengo la salida:

scala> Test.test
Int received Some(Hi)
Int received Some(0)

Esperaba la salida

String received Some(Hi)
Int received Some(0)

¿Cuál es la explicación?

Como segunda pregunta, recibo advertencias unchecked marcar con lo anterior como sigue:

C:/scalac -unchecked a.scala
a.scala:17: warning: non variable type-argument Int in type pattern Some[Int] is unchecked since it is eliminated by erasure
      case i:Some[Int] => println ("Int received "+i)
             ^
a.scala:18: warning: non variable type-argument String in type pattern Some[String] is unchecked since it is eliminated by erasure
      case s:Some[String] => println ("String received "+s)
             ^
a.scala:22: warning: non variable type-argument Int in type pattern Some[Int] is unchecked since it is eliminated by erasure
      case i:Some[Int] => println ("Int received "+i)
             ^
a.scala:23: warning: non variable type-argument String in type pattern Some[String] is unchecked since it is eliminated by erasure
      case s:Some[String] => println ("String received "+s)
             ^
four warnings found

¿Cómo puedo evitar las advertencias?

EDIT: Gracias por las sugerencias. La idea de Daniel es buena, pero no parece funcionar con tipos genéricos, como en el siguiente ejemplo.

def test[T] = (Alice !? (100, "Hello")) match { 
   case Some(i: Int) => println ("Int received "+i) 
   case Some(t: T) => println ("T received ") 
   case _ =>  
}

Se encuentra la siguiente advertencia de error : warning: abstract type T in type pattern T is unchecked since it is eliminated by erasure

Answer 1

Como ya se dijo, estás en contra de borrar aquí.

Para la solución ... Es normal que el actor Scala defina las clases de casos para cada tipo de mensaje que probablemente envíe:

case class MessageTypeA(s : String)
case class MessageTypeB(i : Int)

object Alice extends Actor {
  this.start
  def act{
    loop{
      react {
        case "Hello" => sender ! MessageTypeA("Hi")
        case i:Int => sender ! MessageTypeB(0)
      }
    }
  }
}
object Test {
  def test = {
    (Alice !? (100, "Hello")) match {
      case Some(MessageTypeB(i)) => println ("Int received "+i)
      case Some(MessageTypeA(s)) => println ("String received "+s)
      case _ =>
    }
    (Alice !? (100, 1)) match {
      case Some(MessageTypeB(i)) => println ("Int received " + i)
      case Some(MessageTypeA(s)) => println ("String received " + s)
      case _ =>
    }
  }
}

Answer 2

Cualquier información sobre los parámetros de tipo solo está disponible en tiempo de compilación, no en tiempo de ejecución (esto se conoce como borrado de tipo). Esto significa que en el tiempo de ejecución no hay diferencia entre la Option[String] y la Option[Int] , por lo que cualquier patrón que coincida con el tipo de Option[String] , también coincidirá con la Option[Int] porque en el tiempo de ejecución ambos son solo Option .

Como esto casi siempre no es lo que pretendes, recibes una advertencia. La única forma de evitar la advertencia es no verificar el tipo genérico de algo en el tiempo de ejecución (lo cual está bien porque no funciona como usted quiere).

No hay forma de verificar si una Option es una Option[Int] o una Option[String] en tiempo de ejecución (aparte de inspeccionar el contenido si es un Some ).

Answer 3

Esto se debe al borrado de tipo. La JVM no conoce ningún parámetro de tipo, excepto en las matrices. Debido a eso, el código de Scala no puede verificar si una Option es una Option[Int] o una Option[String] ; esa información se ha borrado.

Aunque podrías arreglar tu código de esta manera:

object Test {
  def test = {
    (Alice !? (100, "Hello")) match {
      case Some(i: Int) => println ("Int received "+i)
      case Some(s: String) => println ("String received "+s)
      case _ =>
    }
    (Alice !? (100, 1)) match {
      case Some(i: Int) => println ("Int received "+i)
      case Some(s: String) => println ("String received "+s)
      case _ =>
    }
  }
}

De esta manera, no está probando cuál es el tipo de Option , sino el tipo de su contenido, suponiendo que haya algún contenido. Un None caerá al caso predeterminado.