(Dis-) Vantaggi della tipizzazione strutturale

Question

Ho appena guardato Questo discorso di Daniel Spiewak dove parla dei vantaggi di digitazione strutturale Rispetto a Scala's Ans Java's digitazione nominale. Un esempio per 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 si compilerebbe perché la compatibilità del tipo tra Foo e Bar è determinato per nome.

Un sistema di tipo strutturale d'altra parte potrebbe dichiarare che entrambi i tipi siano uguali o compatibili e quindi, tra le altre cose, consentire la tipizzazione anatra controllata.

Ora penso di capire la maggior parte dei vantaggi di un sistema di tipo strutturale, ma mi chiedo se non invalidare la sicurezza del tipo da esempi come i seguenti

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 che in un sistema di tipo strutturale si sarebbe anche compilata l'ultima riga e, in tal caso, non sarebbe uno svantaggio rispetto alla sicurezza del tipo?