È possibile denominare le lingue con controllo di tipo statico (come Java) e dove il codice è dati (come in LISP)? Intendo entrambe le cose in una sola lingua.Conosci una lingua con il tipo statico che controlla dove il codice è dati?
Se si sta semplicemente cercando la possibilità di eseguire codice in modo dinamico in un linguaggio a tipizzazione statica, quindi Java stesso può farlo:
http://www.javaworld.com/javaworld/jw-06-2006/jw-0612-dynamic.html
Se avete bisogno di più di questo (desidera metodi e classi come oggetti di prima classe, ecc.), quindi vorrete usare qualcosa come Haskell o C# (come menzionato in altre risposte).
F # ha Quotation expressions. Dalla pagina di MSDN:
// typed
let e : Expr<int> = <@ 1 + 1 @>
// untyped
let e' : Expr = <@@ 1 + 1 @@>
// splicing with %
// similar to Lisp's unquote-splicing, but type-checked:
// you can only splice expressions of the appropriate type
<@ 1 + %e @>
Credo che questi sono disponibili in C#, ma (1) Io non so quale sia la sintassi è (2) le strutture di dati sono diversi.
Queste lingue consentire codice come i dati in fase di compilazione, come le macro Lisp:
Disclaimer: non sono realmente utilizzati qualsiasi di questi. Per quanto ne so, sono tutti molto più complicati di quelli di Lisp quote.
Tuttavia, il 90% di "Codice come dati" utilizzando quote può essere realizzato con chiusure, poiché ritardano anche la valutazione. Molte lingue hanno una comoda sintassi per creare chiusure (in particolare C#, Clojure, Scala e Ruby) e non ho più bisogno di quote. Anche in Scheme, che è un Lisp definitivo, lo stile prevalente favorisce il passaggio delle funzioni rispetto alle macro di scrittura.
I macro non sono "tempo di compilazione". I macro funzionano perfettamente bene con gli interpreti Lisp. Anche i macro Lisp non rappresentano il 90% della valutazione ritardata. Le macro hanno molti scopi. La maggior parte non ha nulla a che fare con la valutazione ritardata. –
La valutazione macro si verifica in "tempo di lettura" in Common Lisp e Scheme (per quanto ricordo). Non sapevo se il richiedente avrebbe riconosciuto il termine, quindi ho usato uno meno preciso ma più comune. Ci sono stati Lisp sperimentali con macro di prima classe, ma non sono diffusi. Per quanto riguarda il ritardo nella valutazione, questo è esattamente ciò che è "preventivo", e quali sono le chiusure, anche se con meno convenienza. Non stavo parlando solo di macro, dato che sono un uso limitato di codice come dati. –
Nathan, la valutazione macro non si verifica in "tempo di lettura" in Common Lisp. Neanche un po. L'espansione delle macro avviene durante l'interpretazione e/o la compilazione e viene descritta nello standard CL. Se il codice viene eseguito interpretato, è possibile espandere le macro durante l'interpretazione. QUOTE non è anche per ritardare la valutazione come 'chiusure'. QUOTE è lì per denotare i dati letterali. Il codice quotato non viene ritardato, in modo che possa essere 'forzato'. Se si vuole eseguire un codice quotato, deve essere estratto. Questa è un'enorme differenza. –
Qi è un dialetto Lisp tipicamente statico. Inoltre, molti altri dialetti Lisp hanno una digitazione statica (opzionale).
Java ha funzionalità molto limitate di questo tipo.
La domanda interessante non è tanto se si può avere metaprogrammazione e tipizzazione statica, è se è possibile avere dinamica metaprogrammazione essere staticamente type-safe.
C'è Template Haskell che fa metaprogrammazione e è type-safe, ma è statica metaprogrammazione.
Al momento non riesco a pensare a nessuna lingua che conosco per un fatto che consente la metaprogrammazione dinamica e dove la metaprogrammazione dinamica è staticamente sicura dal tipo. Qi potrebbe essere balla per farlo, ma non ne sono sicuro.
Posso chiedere un chiarimento dei termini? Non sono sicuro di aver capito il tuo punto così com'è. Cosa intendi per metaprogrammazione dinamica rispetto a quella statica? La metaprogrammazione statica "in fase di compilazione", ad es. Macro, vs dinamica, "in fase di esecuzione", cioè la citazione di un'espressione arbitraria? –
Template Haskell è staticamente digitato ma consente di manipolare il codice come dati, alias metaprogramming. Le lingue correlate includono MetaML e MetaOCaml. Guarda il lavoro di Tim Sheard.
MetaML e MetaOCaml sono molto diversi da TH - i primi sono dattiloscritti (i generatori digitati garantiscono di generare solo il codice digitato) mentre TH è solo tipizzato singolarmente, cioè solo i risultati dell'espansione del modello sono controllati dal tipo. –
@Jacques buon punto, ma sono ancora abbastanza simili che sono disposto a metterli nella stessa risposta :-) –
Racket (in precedenza Schema PLT) ha uno statically typed dialect, che è progettato per funzionare bene con idiomi Scheme - compresi i macro. (Funziona per tipo-controllo dei risultati di espansione.)
Forse Strongtalk o Zero quali sono sistema riflettente alla Smalltalk, ma vengono digitati in modo statico.
Vorrei essere d'accordo con le risposte a questa domanda: http://stackoverflow.com/questions/2953141/why-are-most-s-expression-languages-dynamically-typed che semplicemente non è possibile avere entrambi. –
@Daniel: solo la risposta più votata a quella domanda afferma che non è possibile averli entrambi. Lo fa affermando che la digitazione sarebbe davvero difficile. Difficile, sì, ma non impossibile. –
Questo è molto simile a http://stackoverflow.com/questions/3037643/typed-metaprogramming-lingue –