Che cosa impedisce un linguaggio a tipizzazione statica di avere qualcosa di simile method_missing di Ruby?

Question

Non ho molta esperienza con i linguaggi staticamente tipizzati (attualmente apprendimento Scala per passione!), Ma una cosa che ho notato è che essi non sempre sembrano avere qualcosa di simile method_missing di Ruby o onMissingMethod di ColdFusion. C'è qualche limitazione intrinseca nei linguaggi staticamente tipizzati che impediscono o rendono questo difficile?

Answer 1

Certamente potrebbe essere aggiunto un meccanismo per la loro movimentazione, ma è in contrasto con ciò che tipizzazione statica è:. Determinazione in fase di compilazione che il programma è privo di errori di tipo

Addendum

Scala 2.9 ha introdotto un'opzione sperimentale che consente questo tipo di gestione dinamica degli accessi ai tipi in modi che altrimenti fallire controllo di tipo statico. È stato perfezionato e reso non sperimentale a 2.10, anche se è ancora controllata da una bandiera funzione predefinita di disabilitazione. Si può leggere su di esso nel href="http://docs.scala-lang.org/sips/pending/type-dynamic.html" rel="nofollow"> SIP 17 documento SIP 18 per una spiegazione della Scala 2.10 di "modularizzazione" e con le bandiere.

Answer 2

Versione Scala 2.9 introduce questa funzionalità attraverso la Dynamic trait ( scaladoc ). Classi che estendono Dynamic ottenere il metodo applyDynamic(methodName, args) magico, che è analoga alla method_missing di rubino. Come di Scala 2.9, l'opzione -Xexperimental deve essere abilitato per l'utilizzo Dynamic.

Answer 3

In linguaggi staticamente tipizzati, funzioni membro vengono richiamati direttamente. Se il compilatore non può capire quale funzione membro per richiamare, il programma non verrà compilato. Metodo invocazione è, in questo senso, statico.

In lingue dinamicamente tipizzati, funzioni membro non sono invocato direttamente. Piuttosto, codice chiamante invia un messaggio a un oggetto, e poi Language Runtime capisce che cosa fare con quel messaggio. Ad esempio, il runtime esegue la scansione dell'oggetto per un metodo con lo stesso nome, e quindi esegue la scansione dell'oggetto per un metodo con il nome method_missing. Metodo invocazione è, in questo senso, dinamica.

C # 4 combina tipizzazione statica con tipizzazione dinamica. Una variabile può avere una fase di compilazione di dynamic. Qualsiasi metodo invocazioni su questa variabile saranno trattati come nei linguaggi dinamicamente tipizzati. Qualsiasi metodo invocazioni sulle variabili con tipi statici saranno trattati come nei linguaggi staticamente tipizzati.

# static invocation, bound at compile time by the compiler
var s = 6;
s.ToString();

# dynamic invocation, handled at runtime by the CLR
dynamic d = 6;
d.ToString();

Answer 4

Solo per posta ulteriormente di Randall, è possibile, ma la ragione va contro il paradigma statico è che è al di là di "spedizione dinamica". spedizione dinamica consente lieto di spedizione verso una funzione che è dinamicamente legato a un pezzo statica noto di codice. cioè i set compilatore fino alla spedizione che viene eseguita a runtime deterministico, dalla sua prospettiva.

Che la chiamata method_missing fa, è essenzialmente fare un "prendere tutto" in cui si decide cosa fare in base al nome del metodo utilizzando uno switch o un titolo equivalente (che sono sicuro si sa). Così, il compilatore ha idea di cosa sta per succedere qui. Diciamo che il compilatore ha fatto qualcosa di simile:

if (function is known at compile time)
{
  provide static call or dynamic call to "some" derivation
}
else
{
  bind the function call to obj.method_missing(...) and pass in the "details"
}

Poi si deve fornire method_missing in questo modo:

def method_missing(intendedFunctionName, arguments)
{
  if (intendedFunctionName is "X")
  {
    X may not need arguments, so just do something
  }
  else if (intendedFunctionName is "Y")
  {
    Y expects 5 arguments of varying types
    Throw exception if there isn't the right number or types
  }
  ... etc ...
}

Chiedendo il compilatore per l'invio di "arbitrari" (cioè non è noto al momento della compilazione) argomenti di tipi arbitrari, con una intendedFunctionName che potrebbe non essere la contabilità per ... beh, non è molto sicuro, e Scala ha lo scopo di essere un linguaggio staticamente sicuro.

Sì, è fattibile, ma non nello spirito di un linguaggio statico. Se si vuole veramente quel tipo di flessibilità, programmazione poliglotta è probabilmente tuo amico.

Nota: Objective-C non è tipizzato strettamente staticamente. C'è un motore runtime su cui viene eseguito il codice e il sistema dinamico di battitura non consente codice di strappare o inline come C / C ++.

Answer 5

Objective-C ha "method_missing" (nello specifico, forwardInvocation e methodSignatureForSelector ) ed è probabilmente staticamente tipizzato. Questo funziona perché sarà il trattamento di errori di tipo statico quali avvertenze, piuttosto che gli errori in fase di compilazione, in quanto metodo di spedizione si verifica in fase di esecuzione in misura maggiore molto di qualcosa di simile a metodi virtuali in C ++ (e questo è il motivo per cui si può avere "method_missing").