Ho pensato di fare la mia lingua (praticità: è un esperimento mentale). Una delle idee che mi sono venute in mente è la variazione semantica del linguaggio. Scriveresti essenzialmente espressioni regolari semantiche, da sostituire con codice equivalente. Puoi vederlo in una forma un po 'meno diretta in D- hanno mixin di stringhe che si convertono in codice D. Tranne che li avrei fatti implicitamente e in modo più circolare.Variazione semantica in lingua
In questo momento, ho origine da C++. Quindi se si considera:
string a, b, c, d;
// do stuff
a = b + c + d;
Questo codice restituisce vari provvisori. Anche se hai riferimenti di rvalue, creerai dei provvisori, saranno semplicemente riutilizzati in modo più efficiente. Ma esistono ancora e continuano a perdere prestazioni. Stavo pensando, nel caso più semplice, a come questi potrebbero essere eliminati. Potresti scrivere un'espressione regolare semantica che la convertirà nella forma più ottimizzata.
string a, b, c, d;
// do stuff
a.resize(b.size() + c.size() + d.size());
a = b; a += c; a += d;
Se ho implementato std :: string, potrei riuscire a scrivere qualcosa ancora più velocemente. La chiave di questo è che sono impliciti: quando si utilizza la classe std :: string, gli assiomi scritti dallo std :: string implementer possono influenzare qualsiasi codice std :: string. Si potrebbe semplicemente rilasciarlo in una base di codice C++ esistente, ricompilare e ottenere la più rapida concatenazione di stringhe che il tuo implementatore di std :: string possa concepire gratuitamente.
Al momento, le ottimizzazioni che si possono fare sono limitate, perché si ha solo il contesto che il linguaggio consente, in questo caso, l'overloading dell'operatore in C++ prende solo due argomenti, questo e arg. Ma un regs semantico potrebbe prendere praticamente tutto il contesto di cui avresti mai potuto avere bisogno - dal momento che puoi dettare ciò che corrisponde - e persino corrispondere a caratteristiche linguistiche che non esistono nella lingua ospite. Ad esempio, sarebbe banale per lo scambio di
string a;
a.size;
per
string a;
a.size();
se si voleva rubare C Proprietà #. È possibile abbinare le definizioni di classe e implementare la riflessione di compilazione o di esecuzione, ecc.
Ma, voglio dire, potrebbe diventare confuso. Se c'è stato un bug, o cosa è stato fatto dietro le quinte non riflette il codice che è stato scritto, potrebbe essere una cagna totale da rintracciare, e non ho considerato come sarebbe stato implementato in profondità. Cosa ne pensate della mia proposta di lingua?
Oh uomo, scegliendo i tag giusti. Ummm ....
Modifica: volevo anche violare l'ambito dei limiti, per quanto riguarda una risposta che ho avuto. Il semplice fatto è che la regex semantica non ha limiti (meno i dettagli di implementazione che potrebbero dover essere aggiunti). Ad esempio, si potrebbe trasformare l'espressione
int i;
cin >> i;
int lols[i];
in
int i;
cin >> i;
std::variable_array<int>(alloca(sizeof(int) * i), i);
La semantica di alloca rendere la manipolazione con i modelli impossibile- si deve scrivere una macro se si desidera che il sopra. In C++ 03 o C++ 0x, non è possibile incapsulare i propri VLA.
Inoltre, le regex semantiche possono corrispondere al codice che non richiama effettivamente alcun lavoro in fase di compilazione. Ad esempio, è possibile associare ogni membro di una definizione di classe e utilizzarlo per creare un sistema di riflessione. Questo è anche impossibile in C++ fino ad oggi.
Qualche idea su come potrebbe essere la sintassi di corrispondenza del modello? –
Al momento non ho molta idea, ma non è complicato: scrivi un po 'di codice che assomiglia al codice che vuoi sostituire e un po' di codice che assomiglia al codice che vuoi usare. – Puppy