Pattern che combina le funzioni zero-argument in scala: mistificato tramite avviso

Question

Sto giocando con gli attori distribuiti di scala. Molto bella.

Ho un server che esegue oggetti funzione in entrata. Ad esempio, il cliente ha

object Tasks { 
    def foo = {Console.println("I am Foo")}; 
    def bar = {Console.println("I am Bar");} 
} 

// In client actor... 
... 
    server ! Tasks.foo _ 
... 

E il server può prenderli ed eseguirli con il codice di attore come

react { 
    case task:(()=>Unit) => 
    task() 

Tutto questo funziona bene (che è davvero molto molto cool), ma io' sto mistificato da un messaggio di avviso di uscita dalla scalac per il codice del server:

warning: non variable type-argument Unit in type pattern is unchecked since it is eliminated by erasure 
     case task:(()=>Unit) => 
        ^

Come posso pulire questo avvertimento in su?

(sono abbastanza chiare sulla differenza tra il tipo Unit, e il tipo di funzioni zero argomento ()=>Unit. Sto solo cercando di abbinare task:Unit nel react è libero di avvertimento-, ma in realtà non corrisponde ai compiti in arrivo .)

Uso di Scala 2.7.5 su Debian, con Sun's Java6.

Answer 1

Stai davvero corrispondenti a questi criteri:

case task:Function0[Unit] => task() 

causa di cancellazione, unità non è visibile in fase di esecuzione. Se davvero non si preoccupano il tipo di ritorno, si può fare questo nel blocco di reagire:

case task:Function0[_] => task() 

Answer 2

Questo è complementare alle @Mitch Blevins s' risposta dal momento che la sua risposta si arriva attraverso in questo caso.

Vedere How do I get around type erasure on Scala? Or, why can’t I get the type parameter of my collections? Probabilmente devi passare una tupla di (Function0[T],Manifest[T]) all'attore. Come puoi vedere qui sotto, Scala è abbastanza intelligente da dedurre il tipo di T anche se scrivi solo matchFunction(foo _).

scala> def foo = {Console.println("I am Foo")} 
foo: Unit 

scala> import scala.reflect.Manifest 
import scala.reflect.Manifest 

scala> def matchFunction[T](f: Function0[T])(implicit m : Manifest[T]) { 
    | (m,f) match { 
    |  case (om: Manifest[_],of: Function0[_]) => 
    |  if(om <:< m) { 
    |   of.asInstanceOf[Function0[T]]() 
    |  } 
    | } 
    | } 
matchFunction: [T](() => T)(implicit scala.reflect.Manifest[T])Unit 

scala> matchFunction(foo _) 
I am Foo