Ho appena visto questo talk di Daniel Spiewak dove parla dei vantaggi di tipizzazione strutturale rispetto alla digitazione nominale di Scala ans Java. Un esempio di questa differenza sarebbe il seguente codice Java
public interface Foo {
public int length();
}
public interface Bar {
public int length();
}
Foo f = ...;
Bar b = f;
che ovviamente non verrebbe compilato perché la compatibilità di tipo tra Foo e Bar è determinata dal nome.
Un sistema di tipo strutturale, d'altra parte, potrebbe dichiarare entrambi i tipi uguali o compatibili e quindi, tra le altre cose, consentire la digitazione controllata degli anatra.
Ora penso di capire la maggior parte dei vantaggi di un sistema di tipo strutturale, ma mi chiedo se non invalida la sicurezza del tipo da esempi come il seguente
class Foo {
class Bar { /* ... */ }
def takeBar(b: Bar) = { /* ... */ }
def getBar: Bar = new Bar
}
val foo1 = new Foo
val foo2 = new Foo
foo1.takeBar(foo1.getBar) // should compile
foo1.takeBar(foo2.getBar) // should not compile
La mia comprensione è corretta sul fatto che in un sistema di tipo strutturale anche l'ultima riga dovrebbe essere compilata e, in tal caso, non sarebbe uno svantaggio rispetto alla sicurezza del tipo?