Je viens de regarder cette conférence de Daniel Spiewak où il parle des avantages du typage structurel par rapport au typage nominal de Scala et Java . Un exemple de cette différence serait le code Java suivant
public interface Foo {
public int length();
}
public interface Bar {
public int length();
}
Foo f = ...;
Bar b = f;
qui bien sûr ne compilerait pas car la compatibilité des types entre Foo
et Bar
est déterminée par le nom.
Un système de type structurel, d'autre part, pourrait déclarer les deux types égaux ou compatibles et donc, entre autres, permettre le typage vérifié du canard.
Maintenant, je pense que je comprends la plupart des avantages d'un système de type structurel, mais je me demande si cela n'invaliderait pas la sécurité des types à partir d'exemples tels que les suivants
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
Est-ce que je comprends que dans un système de type structurel, la dernière ligne se compilerait également et si oui, ne serait-ce pas un inconvénient en ce qui concerne la sécurité des types?