Comme d'habitude, cela a semblé utile pour au moins une personne (moi-même), donc le style Continuation-passant (CPS) de chaque langue. L'exemple de description de est résumé sous forme d'article.
En mode interactif, remplacez 10 par «x», puis évaluons «x + 20».
>>> x = 10
>>> x + 20
30
Lorsque je transforme cette description de programme dans un fichier et que je laisse l'interpréteur Python l'exécuter, rien ne s'affiche. En effet, en mode interactif (REPL), le résultat évalué en tant qu'expression est affiché, alors que dans l'exécution du fichier (script), un tel affichage n'est pas effectué.
C:\Users\hoge>type sample.py
x = 10
x + 20
C:\Users\hoge>python sample.py
C:\Users\hoge>
Si vous souhaitez afficher le résultat de l'évaluation en exécutant le fichier, vous devez l'afficher en utilisant, par exemple, print après avoir obtenu le résultat de l'évaluation.
C:\Users\hoge>type sample.py
x = 10
print(x + 20)
C:\Users\hoge>python sample.py
30
C:\Users\hoge>
Ici, lorsque vous décrivez comme une expression, considérez un mécanisme dans lequel la fonction qui traite le résultat de l'évaluation doit être spécifiée. Ce qui suit est un exemple de définition d'une fonction cadd20 qui est appelée en passant le résultat de l'évaluation comme argument à la fonction f après avoir évalué x + 20, et en spécifiant print pour f. ..
C:\Users\hoge>type sample.py
def cadd20(x, f): f(x + 20)
x = 10
cadd20(x, print)
C:\Users\hoge>python sample.py
30
C:\Users\hoge\python>
De cette façon, la méthode de programmation qui suppose un mécanisme pour spécifier la procédure de traitement du résultat à l'avance est "[Style de passage continu](https://ja.wikipedia.org/wiki/%E7%B6%99%]. E7% B6% 9A% E6% B8% A1% E3% 81% 97% E3% 82% B9% E3% 82% BF% E3% 82% A4% E3% 83% AB) »(style de passage continu, CPS ). Ce style a été appliqué à diverses implémentations, y compris les formes inconscientes.
try (procédure à appeler) et ʻexcept` (procédure à spécifier)Il est facile de convertir une fonction en CPS, mais une certaine ingéniosité est nécessaire pour utiliser la fonction convertie. Ici, la conversion des fonctions existantes en CPS et des exemples d'utilisation sont affichés (le corps principal de cette feuille de triche).
from operator import add, sub, mul
# func(x, y) = (x + y) * (x - y)
def func(x, y): return mul(add(x, y), sub(x, y))
print(func(10, 20)) # => -300
def cps(f):
def cps(x, y, c): return c(f(x, y))
return cps
cps(add)(10, 20, print) # => 30
def cfunc(x, y, c):
return cps(add)(x, y, lambda c1: # x + y -> c1
cps(sub)(x, y, lambda c2: # x - y -> c2
cps(mul)(c1, c2, c))) # c1 * c2 -> c
cfunc(10, 20, print) # => -300
Scheme（Gauche，Guile）
; func(x, y) = (x + y) * (x - y)
(define (func x y) (* (+ x y) (- x y)))
(display (func 10 20)) ; => -300
(define (cps f) (lambda (x y c) (c (f x y))))
((cps +) 10 20 display) ; => 30
(define (cfunc x y c)
((cps +) x y (lambda (c1) ; x + y -> c1
((cps -) x y (lambda (c2) ; x - y -> c2
((cps *) c1 c2 c)))))) ; c1 * c2 -> c
(cfunc 10 20 display) ; => -300
Ruby（CRuby）
# func(x, y) = (x + y) * (x - y)
def func1(x,y) (x+y)*(x-y) end
p func1(10,20) # => -300
add = -> x,y { x+y }
sub = -> x,y { x-y }
mul = -> x,y { x*y }
prn = -> x { p x }
cps = -> f { -> x,y,c { c.(f.(x,y)) } }
cps[add][10,20,prn] # => 30
cfunc = -> x,y,c {
cps.(add).(x, y, -> c1 { # x + y -> c1
cps.(sub).(x, y, -> c2 { # x - y -> c2
cps.(mul).(c1,c2,c) }) }) # c1 * c2 -> c
}
cfunc[10,20,prn] # => -300
JavaScript（Node.js）
// func(x, y) = (x + y) * (x - y)
function func1(x,y) { return (x+y)*(x-y) }
console.log(func1(10,20)) // => -300
add = (x,y) => x+y
sub = (x,y) => x-y
mul = (x,y) => x*y
cps = f => (x,y,c) => c(f(x,y))
cps(add)(10,20,console.log) // => 30
cfunc = function(x,y,c) {
return cps(add)(x, y, c1 => // x + y -> c1
cps(sub)(x, y, c2 => // x - y -> c2
cps(mul)(c1,c2,c))) // x * y -> c
}
cfunc(10,20,console.log) // => -300
call / cc de Scheme supprimé (à partir du commentaire Twitter)Recommended Posts