sto leggendo Scala e mi chiedo ...
PerchéQual è il motivo per avere "capacità di val: Int" invece di "Capacity val Int" a Scala
val capacity : Int
invece di
val Int capacity.
Qualsiasi motivo per cui questa scelta è stata fatta. In caso contrario, non mi sembra una buona scelta allontanarmi dal modo in cui Java lo dichiara. Avrebbe reso più semplice la transizione da Java a Scala (non di molto, ma poco)
Poiché la maggior parte del tempo è possibile lasciare la parte Int. Scala ha un sistema di inferenza di tipo molto più ordinato rispetto a Java.
x: T è la notazione standard per i tipi in logica e molti linguaggi di programmazione. C e i suoi discendenti, con Java tra di loro, si discosta da questo. Ma la notazione di tipo di C è davvero terribile (prova a scrivere il tipo per una funzione di ordine superiore moderatamente complicata come la mappa).
Inoltre, con questa notazione è facile escludere il tipo (come già scritto da Wysawyg) o aggiungere un tipo all'interno di un'espressione.
Ecco un esempio di dichiarazione di Wysawyg:
val capacity = 2
Ma in genere non potrebbe fare questo con un semplice val.
trait Foo {
def capacity = 2 // Allow child classes to override and decide the value later
}
// Force instances of Bar to set the value
class Bar(override val capacity : Int) extends Foo
// Have Bat determine it on the fly
trait Bat extends Foo {
def onlyAThird : Int
override def capacity = onlyAThird * 3
}
(ho cercato di inserire questo come un commento, ma ahimè, senza formattazione.)
Perché usi 'def' per una costante letterale? Inoltre: 'def' sembra essere spiegato come' default' qui, per inciso. –
Ah, 'def' è circa il tempo di valutazione. Se dicessimo 'val capacity = 2' non potremmo permettere a' Bat' di estendere 'Foo' con una funzione che determina la capacità al volo. –
Credo di aver capito ora. Basta definirlo come 'def' per renderlo sovrascrivibile con un metodo.Una val sarebbe solo sostituibile da un'altra val. –
In Programming in Scala si dice che la ragione tecnica per questa sintassi è che rende l'inferenza di tipo più semplice.
Penso Daniel pensato a qualcosa di simile:
val a = 7
val b: Int = 8
var x = "Foo"
var y: String = "Bar"
def sum (a: Int, b: Int) = a + b
def mul (a: Int, b: Int): Int = a * b
Il tipo spesso può essere dedotto.
Penso di aver letto una dichiarazione di Martin Odersky da qualche parte affermando che questa decisione è stata presa anche per migliorare la leggibilità. Questo è certamente il caso, ad es. confrontare
val Double number = ...
val Array[(Seq[String], Map[Seq[String], Double])] something = ...
val String pattern = ...
con
val number : Double = ...
val something : Array[(Seq[String], Map[Seq[String], Double])] = ...
val pattern : String = ...
maggior parte delle volte è necessario trovare nomi di riferimenti/mathods veloce (visivamente), non i tipi.
Se si aggiunge un esempio con e senza il tipo, ciò renderà più ovvia la ragione. –
Depends. A volte, quando il sito della mano destra è complicato (specialmente quando si costruiscono le API) è necessario annotare i tipi in quanto cattura molti bug in fase di compilazione. – Raphael