Perché lo scala non effettua il controllo del tipo quando si controlla l'uguaglianza

Naviga le tue risposte
1

Ad esempio: 

scala> val a: String = "5"
a: String = 5

scala> val b: Int = 5
b: Int = 5

scala> a == b
res5: Boolean = false

Mi aspetto un TypeError, come in Java: 

class MyClass {
    public static void main(String[ ] args) {
        int a = 5;
        String b = "5";
        System.out.println(a == b);
    }
}

Mi chiedo quale sia stato il ragionamento dei designer scala a non eseguire il controllo dei tipi. Personalmente non vedo alcun vantaggio nel non farlo. Quando potrebbe essere praticamente utile? Tuttavia, potrebbe causare errori di esecuzione.

Inoltre, ritengo che un controllo dei tipi più strong sia più in linea con il paradigma funzionale, perché scala ha cambiato il comportamento del suo predecessore java ?

    
posta Akavall 02.05.2017 - 03:34
fonte

2 risposte

7

Scala ha ereditato questo comportamento da Java.

La chiave è che% co_de di Scala è equivalente a == di Java, non equals (che controlla l'uguaglianza referenziale).

    
risposta data 02.05.2017 - 06:09
fonte
3

Scala ha ereditato il concetto di uguaglianza universale dalle sue lingue ospitanti. Ricorda, Scala è progettato per essere una lingua ospitata , cioè una lingua che diventa parte dell'ecosistema di un'altra lingua. Ad esempio, Scala.NET (ora abbandonato) sulla piattaforma .NET, Scala-JVM sulla piattaforma Java, Scala.js sulla piattaforma ECMAScript e così via.

Ciò che tutte queste lingue hanno in comune è l'uguaglianza universale: 

// ### Java:
String s = "42";
int    i =  42;


// ### Value equality:
s.equals(i);
//=> false


// ### Reference equality:
s == i
// error: bad operand types for binary operator '=='

// ### C♯:
var s = "42";
var i =  42;

// ### Value equality:
s.Equals(i);
//=> False

s == i;
// error CS0019: Operator '==' cannot be applied to operands of type 'string' and 'int'


// ### Reference equality:
object.ReferenceEquals(s, i);
//=> False

// ### ECMAScript:
const s = "42";
const i =  42;

// ### Value equality:
s == i;
//=> true

s === i;
//=> false

// ### Scala:
val s = "42"
val i =  42

// ### Value equality:
s == i
//=> false


// ### Reference equality:
s eq i
// error: the result type of an implicit conversion must be more specific than AnyRef

Come puoi vedere, Scala non è il solo a restituire un valore booleano per l'uguaglianza di valore. Java, C♯ (tranne quando si utilizza l'operatore == ) e ECMAScript si comportano in modo simile. (ECMAScript restituisce anche true in un caso!)

Lì sono , comunque, persone nella comunità di Scala che pensa intensamente all'uguaglianza . Fortunatamente, non si lamentano solo, ma offrono anche soluzioni, ad esempio Scalaz Equal typeclass e cats ' Eq typeclass non sono universali.

    
risposta data 02.05.2017 - 15:17
fonte

Leggi altre domande sui tag

Golden Data vs ?? (forse dati di uscita?) Documentazione del mio codice utilizzando interfacce di modelli di progettazione generici