呼叫/ cc在Lua - 可能嗎？

Question

上Continuation維基百科的文章說：
「在支持關閉任何語言，可以寫在延續傳遞風格的程序和手動執行呼叫/立方厘米。」

要麼這是真的，我需要知道如何去做，否則它是不正確的，該聲明需要糾正。

如果這是真的，請告訴我如何在Lua中實現call/cc，因爲我看不到如何。

我想我可以手動實現call/cc，如果Lua具有corruptine.clone函數，如here所解釋的那樣。

如果閉包不足以實現call/cc，那麼還需要什麼？

以下文本是可選閱讀。
P.S .: Lua對其協程表進行了一次性延續。一個coroutine.clone函數可以讓我克隆它多次調用它，從而有效地使call/cc成爲可能（除非我誤解了call/cc）。然而，克隆功能在Lua中不存在。 Lua IRC頻道上的某個人建議我使用Pluto庫（它實現序列化）來封送協同程序，複製它，然後解組並再次使用它。雖然這可能會起作用，但我對call/cc的理論實現以及查找語言爲實現其手動實現所需的實際最小特徵集合更感興趣。

編輯1：好的人，幫我在這裏，這花了我很長一段時間，因爲我不知道任何計劃，但我想出了什麼，應該幫助我們。請看下面的代碼。第一個是Scheme中的程序，第二個是Lua中的程序。
希望這會幫助我們。我相信我們非常接近。

P.S .:這些示例取自the Wikipedia article on CallCC上的第一個示例。 方案版本

(define call/cc call-with-current-continuation) 

; callcc CPS-transformed (thanks to the people from the #scheme channel at freenode.net) 
(define cpscallcc 
    (lambda (consumer k) 
    (let ((cc (lambda (result) (k result)))) 
     (consumer cc k)))) 

; this is the continuation we will use to display the "returned" values 
(define main-continuation 
    (lambda (result) 
    (display "--> ") 
    (display result) 
    (newline))) 

; define f function non-CPS 
(define (f return) 
    (return 2) 
    3) 

; these are my past attempts at defining a CPS f function 
;(define (cps-f return k) 
; (k (return 2)) 3) 
;(define (cps-f return k) 
; (k (lambda() 
;  (return 2) 
;  3))) 

; this is what I came up with - I'm not sure if this is correctly CPS-transformed but I  believe so 
(define (cps-f return k) 
    (return 2) 
    (k 3)) 

; call the non-CPS f function 
(display (f (lambda (x) x))) ; displays 3 
(newline) 

; call the non-CPS f function with call/cc (I don't understand what this does) 
(display (call/cc f)) ; displays 2 
(newline) 

; now call the CPS version of the f function 
(cps-f (lambda (x) x) main-continuation) ; displays --> 3 

; now call the CPS version of the f function with the CPS version of call/cc 
(cpscallcc cps-f main-continuation) ; displays --> 2 but then it also displays --> 3 afterwards -> I'm not sure why it displays the 3 afterwards, as it should only display the 2 just like the non-CPS versions above 

Lua版本

-- callcc CPS-version 
cpscallcc = function(consumer, k) 
    local cc = function(result) 
     return k(result) -- ?or k(result) 
    end 
    return consumer(cc, k) -- ?or return consumer(cc,k) 
end 

-- define f function non-CPS 
f = function(ret) 
    ret(2) 
    return 3 
end 

-- define f function CPS-version (again, not sure this is correct) 
cps_f = function(ret, k) 
    ret(2) 
    k(3) 
end 

-- call the non-CPS f function 
print(f(function(x) return x end)) 

-- we cant call the non-CPS f function with callcc because 
-- Lua doesnt have callcc, but the line below displays the correct expected output (maybe by accident) 
--cpscallcc(f, print) 

-- now call the CPS version of the f function 
cps_f(function(x) return x end, print) -- displays 3 

; now call the CPS version of the f function with the CPS version of call/cc 
cpscallcc(cps_f, print) -- displays 2 and then 3 just like the Scheme version!! 
-- so apparently the translation from Scheme to Lua is correct... 

我使用DrScheme和Lua的Windows - 對於任何人，願意幫助了出這是兩個方便下載和安裝剛剛工作的工具。

Answer 1

有兩個前提條件手動執行每維基百科報價呼叫/ CC：

1. 語言必須支持關閉
2. 必須在延續傳遞風格編寫程序（CPS）

我懷疑你不會喜歡＃2。

要延續傳遞風格編寫程序：

1. 每個函數必須採取一個延續參數
2. 功能必須通過調用其延續

因此，使用k作爲名稱返回繼續的論點，功能看起來像：

function multiplyadd(k, x, y, z) return k(x * y + z) end 

頂層可以使用print作爲其延續，在最高水平，從而調用multiplyadd看起來像：

multiplyadd(print, 2, 4, 1) 

隨着該腳手架我們可以定義來電/ CC作爲

function callcc(k,f) return f(k,k) end 

注意上面multiplyadd實際上作弊，因爲*和+不在CPS中。以CPS形式添加所有操作符非常繁瑣，將所有Lua庫函數替換爲CPS等價物，並將所有代碼翻譯/生成到CPS;見details here。

Answer 2

我想你忘了關於編寫程序的部分，繼續傳遞 的風格。一旦你這樣做，調用/ cc是微不足道的（以Lua或任何其他語言）， 作爲延續將是所有功能的明確參數（請致電/ cc 包括）。

PS：除了關閉之外，還需要適當的尾部呼叫才能繼續編程 傳球風格。

Answer 3

關鍵的一句是

這是可能實現延續傳遞風格

計劃（重點煤礦。）你可以通過服用常規的「直式」程序做到這一點並通過名爲CPS變換的程序轉換將它們轉換爲延續傳球風格（CPS）。關鍵是call/cc的CPS轉換是一個簡單的功能。

這對程序員來說不實用。的CPS轉換有兩種用途：

• 至於學習語言功能理論的想法，尤其是控制運營商
• 由於在使用CPS作爲中間語言的編譯器一通

你不我不想在Lua代碼上做任何接近CPS轉換的地方，特別是不需要手動轉換。

Answer 4

在Lua回答關於呼叫/ cc計劃的問題：Lua沒有呼叫/ cc的計劃。捕獲延續要麼太昂貴，要麼需要一些遠遠超出Lua編譯器所能做到的代碼。還有一個問題，即Lua延續可能包含C中的部分。然而，使用協程，我們可以在Lua中實現call/cc1（一次延續）。這對於延續的許多用途來說已經足夠了。

Answer 5

這裏是我的cps轉換計劃，只是傳遞你想要轉換的每個功能。

(define (cps-convert function . functions) 
    # Since "help" is called at 2 different places... 
    (define (help) (error "syntax: (cps-convert f1 f2 ...)")) 
    # Single function converter 
    (define (convert func) 
    # "name" contains the function's name prefixed with "cps-" 
    (let ([name (string->symbol 
          (string-append "cps-" (symbol->string func)))]) 
     # Dirty hack to define "cps-*" in the global environment 
    `(eval '(begin 
        # Necessary to prevent the function from being evaluated 
        (define ,name #f) 
           # Magic 
        (set! ,name (lambda (k . args) (k (func args))))) 
       # Global environment 
       (interaction-environment)))) 
    # Prerequisite... Call help if condition not met 
    (if (symbol? function) 
     # function is a symbol 
     (cond 
     # If there is only one function to convert 
     [(null? functions) (convert function)] 
     # Else ensure every other "functions" are symbols and convert each 
     [(every symbol? functions) (apply convert function functions)] 
     # Oops! Condition not met! 
     [else (help)]) 
     # Else clause from previous "if" 
     (help)))