Qual é a diferença entre =>, () => e Unit =>

Estou tentando representar uma função que não aceita argumentos e não retorna valor (estou simulando a função setTimeout em JavaScript, se você deve saber.)

case class Scheduled(time : Int, callback :  => Unit)

não é compilado, dizendo "parâmetros` `val 'podem não ser chamados por nome"

case class Scheduled(time : Int, callback :  () => Unit)  

compila, mas precisa ser invocado de maneira estranha, em vez de

Scheduled(40, { println("x") } )

Eu tenho que fazer isso

Scheduled(40, { () => println("x") } )      

O que também funciona é

class Scheduled(time : Int, callback :  Unit => Unit)

mas é invocado de uma maneira ainda menos sensível

 Scheduled(40, { x : Unit => println("x") } )

(O que seria uma variável do tipo Unit?) O que eu quero , é claro, é um construtor que possa ser chamado da maneira que eu chamaria se fosse uma função comum:

 Scheduled(40, println("x") )

Dê a mamadeira ao bebê!

Chamada por nome: => Tipo

A => Typenotação significa chamada por nome, que é uma das muitas maneiras pelas quais os parâmetros podem ser transmitidos. Se você não estiver familiarizado com eles, recomendo reservar um tempo para ler esse artigo da Wikipedia, mesmo que hoje em dia seja principalmente por valor e por referência.

O que isso significa é que o que é passado é substituído pelo nome do valor dentro da função. Por exemplo, considere esta função:

def f(x: => Int) = x * x

Se eu chamar assim

var y = 0
f { y += 1; y }

Então o código será executado assim

{ y += 1; y } * { y += 1; y }

Embora isso levante o ponto do que acontece se houver um conflito de nome de identificador. Na chamada tradicional por nome, um mecanismo chamado substituição para evitar captura ocorre para evitar conflitos de nome. No Scala, no entanto, isso é implementado de outra maneira com o mesmo resultado - nomes de identificadores dentro do parâmetro não podem se referir ou identificadores de sombra na função chamada.

Existem alguns outros pontos relacionados à chamada por nome dos quais falarei depois de explicar os outros dois.

Funções de aridade 0: () => Tipo

A sintaxe () => Typerepresenta o tipo de a Function0. Ou seja, uma função que não aceita parâmetros e retorna algo. Isso é equivalente a, digamos, chamar o método size()- ele não usa parâmetros e retorna um número.

É interessante, no entanto, que essa sintaxe seja muito semelhante à sintaxe para uma literal de função anônima , que é a causa de alguma confusão. Por exemplo,

() => println("I'm an anonymous function")

é uma função anônima literal de arity 0, cujo tipo é

() => Unit

Para que pudéssemos escrever:

val f: () => Unit = () => println("I'm an anonymous function")

É importante não confundir o tipo com o valor, no entanto.

Unidade => Tipo

Esta é realmente apenas um Function1, cujo primeiro parâmetro é do tipo Unit. Outras maneiras de escrever seria (Unit) => Typeou Function1[Unit, Type]. A questão é ... é improvável que isso seja o que se quer. O Unitobjetivo principal do tipo é indicar um valor pelo qual não se interessa, portanto, não faz sentido receber esse valor.

Considere, por exemplo,

def f(x: Unit) = ...

O que alguém poderia fazer x? Ele pode ter apenas um único valor, portanto, não é necessário recebê-lo. Um possível uso seria o encadeamento de funções retornando Unit:

val f = (x: Unit) => println("I'm f")
val g = (x: Unit) => println("I'm g")
val h = f andThen g

Como andThensó está definido Function1e as funções que estamos encadeando estão retornando Unit, tivemos que defini-las como sendo do tipo Function1[Unit, Unit]para poder encadear elas.

Fontes de confusão

A primeira fonte de confusão é pensar que a semelhança entre tipo e literal que existe para funções de aridade 0 também existe para chamada por nome. Em outras palavras, pensando que, porque

() => { println("Hi!") }

é literal para () => Unit, então

{ println("Hi!") }

seria um literal para => Unit. Não é. Isso é um bloco de código , não um literal.

Outra fonte de confusão é que Unito valor desse tipo é gravado (), que se parece com uma lista de parâmetros de 0-arity (mas não é).

case class Scheduled(time : Int, callback :  => Unit)

O casemodificador torna implícito a valpartir de cada argumento para o construtor. Portanto (como alguém observou), se você remover, casepoderá usar um parâmetro de chamada por nome. O compilador provavelmente poderia permitir isso de qualquer maneira, mas pode surpreender as pessoas se ele for criado, em val callbackvez de se transformar em lazy val callback.

Quando você muda para callback: () => Unitagora, seu caso apenas aceita uma função em vez de um parâmetro de chamada por nome. Obviamente, a função pode ser armazenada, val callbackentão não há problema.

A maneira mais fácil de obter o que você deseja ( Scheduled(40, println("x") )onde um parâmetro de chamada por nome é usado para passar um lambda) é provavelmente ignorar casee criar explicitamente o applyque você não conseguiu em primeiro lugar:

class Scheduled(val time: Int, val callback: () => Unit) {
    def doit = callback()
}

object Scheduled {
    def apply(time: Int, callback: => Unit) =
        new Scheduled(time, { () => callback })
}

Em uso:

scala> Scheduled(1234, println("x"))
res0: Scheduled = Scheduled@5eb10190

scala> Scheduled(1234, println("x")).doit
x

Na pergunta, você deseja simular a função SetTimeOut em JavaScript. Com base nas respostas anteriores, escrevo o seguinte código:

class Scheduled(time: Int, cb: => Unit) {
  private def runCb = cb
}

object Scheduled {
  def apply(time: Int, cb: => Unit) = {
    val instance = new Scheduled(time, cb)
    Thread.sleep(time*1000)
    instance.runCb
  }
}

No REPL, podemos obter algo assim:

scala> Scheduled(10, println("a")); Scheduled(1, println("b"))
a
b

Nossa simulação não se comporta exatamente da mesma forma que SetTimeOut, porque nossa simulação é função de bloqueio, mas SetTimeOut não é de bloqueio.

Eu faço desta maneira (apenas não quero interromper a aplicação):

case class Thing[A](..., lazy: () => A) {}
object Thing {
  def of[A](..., a: => A): Thing[A] = Thing(..., () => a)
}

e chame

Thing.of(..., your_value)