Je considère quelque chose comme CPS pour une utilisation dans un interprète pour un langage basé sur l'acteur.Poursuite du style de passage par rapport à une pile d'appel agressivement réduite?
Les arguments fonction sont passés dans un tableau de variantes, et la poursuite de retour dans le même tableau, donc une fonction simple
def add (x,y) => x + y
donc un appel de la lecture/Eval/boucle serait
print(add(7, 5))
serait à l'entrée est
[&add, x, y, &print, _, &repl, ...]
où _ est un emplacement vide où la La valeur de retour de la fonction est écrite.
Lors de la prochaine étape de l'exécution, les arguments deviennent
[&print, 12, &repl, ...]
puis
[repl, ...]
et ainsi de suite. L'implémentation dans C est essentiellement
for (;;)
args = (args[0].function_pointer)(args);
avec des vérifications pour écouler la fin de la matrice args et allouer plus d'espace.
Les arguments sont contigus et la 'continuation' en tant qu'objet est juste un sous-ensemble des arguments.
Si je devais implémenter des continuations de première classe, ils auraient besoin de cloner le tableau d'arguments; vous n'obtenez pas de fermetures gratuitement. L'objectif principal est quelque chose qui joue bien avec la génération simple de code machine, et vous permet de suspendre et de reprendre l'exécution. Bien que ce schéma ait été inspiré en pensant à CPS, il n'est pas tout à fait CPS, et est très similaire à ce que pourrait ressembler une pile C agressivement ajustée - juste les variables live, et les points de retour pour chaque fonction.
Y a-t-il un nom pour ce style, et en particulier l'argument array? C'est une sorte de trampoline + une pile, bien que ce que j'ai l'habitude d'appeler 'stack' soit plus l'histoire que l'avenir de l'exécution.