Usos de Nulo / Nada / Unidade em Scala

Acabei de ler: http://oldfashionedsoftware.com/2008/08/20/a-post-about-nothing/

Pelo que entendi, Nullé uma característica e sua única instância é null.

Quando um método recebe um argumento Nulo, só podemos passar uma Nullreferência ou nulldiretamente, mas nenhuma outra referência, mesmo que seja nula ( nullString: String = nullpor exemplo).

Eu só me pergunto em quais casos usar essa Nullcaracterística pode ser útil. Há também o traço Nothing para o qual eu realmente não vejo mais exemplos.

Também não entendo bem qual é a diferença entre usar Nothing e Unit como tipo de retorno, já que ambos não retornam nenhum resultado, como saber qual usar quando tenho um método que executa o log por exemplo?

Você usa Unit / Null / Nothing como algo mais do que um tipo de retorno?

Você só usa Nothing se o método nunca retornar (o que significa que ele não pode ser concluído normalmente com o retorno, ele pode lançar uma exceção). Nada nunca é instanciado e existe para o benefício do sistema de tipos (para citar James Iry: "O motivo pelo qual Scala tem um tipo inferior está ligado à sua capacidade de expressar variação nos parâmetros de tipo." ). Do artigo que você vinculou a:

Um outro uso de Nothing é como um tipo de retorno para métodos que nunca retornam. Isso faz sentido se você pensar sobre isso. Se o tipo de retorno de um método é Nothing, e não existe absolutamente nenhuma instância de Nothing, então tal método nunca deve retornar.

Seu método de registro retornaria Unit. Há um valor Unit para que ele possa realmente ser retornado. Dos documentos da API :

Unidade é um subtipo de scala.AnyVal. Existe apenas um valor do tipo Unit, () e não é representado por nenhum objeto no sistema de tempo de execução subjacente. Um método com tipo de retorno Unit é análogo a um método Java que é declarado nulo.

O artigo que você cita pode ser enganoso. O Nulltipo existe para compatibilidade com a máquina virtual Java Java e Java em particular.

Devemos considerar que Scala :

• é totalmente orientado a objetos: todo valor é um objeto
• é fortemente tipado: cada valor deve ter um tipo
• precisa lidar com nullreferências para acessar, por exemplo, bibliotecas Java e código

assim, torna-se necessário definir um tipo para o nullvalor, que é o Nulltraço, e tem nullcomo única instância.

Não há nada especialmente útil no Nulltipo, a menos que você seja o sistema de tipos ou esteja desenvolvendo no compilador. Em particular, não vejo nenhuma razão sensata para definir um Nullparâmetro de tipo para um método, uma vez que você não pode passar nada alémnull

Você usa Unit / Null / Nothing como algo mais do que um tipo de retorno?

Unit pode ser usado assim:

def execute(code: => Unit):Unit = {
  // do something before
  code
  // do something after
}

Isso permite que você passe um bloco arbitrário de código a ser executado.

Nullpode ser usado como um tipo inferior para qualquer valor anulável. Um exemplo é este:

implicit def zeroNull[B >: Null] =
    new Zero[B] { def apply = null }

Nothing é usado na definição de None

object None extends Option[Nothing]

Isso permite que você atribua um Nonea qualquer tipo de Optionporque Nothing'estende' tudo.

val x:Option[String] = None

se você usar Nothing, não há nada a fazer (incluir console de impressão) se você fizer algo, use o tipo de saídaUnit

object Run extends App {
  //def sayHello(): Nothing = println("hello?")
  def sayHello(): Unit = println("hello?")
  sayHello()
}

... então como usar Nothing?

trait Option[E]
case class Some[E](value: E) extends Option[E]
case object None extends Option[Nothing]

Na verdade, nunca usei o Nulltipo, mas você usa Unit, onde usaria em java void. Nothingé um tipo especial porque, como Nathan já mencionou, não pode haver nenhuma instância de Nothing. Nothingé o chamado tipo de fundo, o que significa que é um subtipo de qualquer outro tipo. Este (e o parâmetro de tipo contravariante) é o motivo pelo qual você pode acrescentar qualquer valor a Nil- que é um List[Nothing]- e a lista será desse tipo de elemento. Nonetambém se do tipo Option[Nothing]. Cada tentativa de acessar os valores dentro de tal contêiner lançará uma exceção, porque é a única maneira válida de retornar de um método do tipo Nothing.

Muitas vezes, nada é usado implicitamente. No código a seguir, val b: Boolean = if (1 > 2) false else throw new RuntimeException("error") a cláusula else é do tipo Nothing , que é uma subclasse de Boolean (assim como qualquer outro AnyVal). Assim, toda a atribuição é válida para o compilador, embora a cláusula else realmente não retorne nada.

Aqui está um exemplo de Nothingpartir scala.predef:

  def ??? : Nothing = throw new NotImplementedError

No caso de você não estar familiarizado (e os motores de busca não podem pesquisar nele), ???é a função de espaço reservado do Scala para qualquer coisa que ainda não tenha sido implementada. Assim como o de Kotlin TODO.

Você pode usar o mesmo truque ao criar objetos fictícios: substitua métodos não usados ​​por um notUsedmétodo personalizado . A vantagem de não usar ???é que você não receberá avisos de compilação para coisas que nunca pretende implementar.

Em termos de teoria das categorias, Nada é um objeto inicial e Unidade é um objeto terminal .

https://en.wikipedia.org/wiki/Initial_and_terminal_objects

Os objetos iniciais também são chamados de coterminais ou universais e os objetos terminais também são chamados de finais .

Se um objeto é inicial e terminal , ele é chamado de objeto zero ou objeto nulo .