What is a 'thunk', as used in Scheme or in general?









up vote
53
down vote

favorite
18












I come across the word 'thunk' at a lot of places in code and documentation related to Scheme, and similar territories. I am guessing that it is a generic name for a procedure, which has a single formal argument. Is that correct? If yes, is there more to it? If no, please?



For eg. in SRFI 18, in the 'Procedures' section.










share|improve this question

















  • 1




    possible duplicate of What is a 'thunk'?
    – Stephan
    May 13 '14 at 9:09














up vote
53
down vote

favorite
18












I come across the word 'thunk' at a lot of places in code and documentation related to Scheme, and similar territories. I am guessing that it is a generic name for a procedure, which has a single formal argument. Is that correct? If yes, is there more to it? If no, please?



For eg. in SRFI 18, in the 'Procedures' section.










share|improve this question

















  • 1




    possible duplicate of What is a 'thunk'?
    – Stephan
    May 13 '14 at 9:09












up vote
53
down vote

favorite
18









up vote
53
down vote

favorite
18






18





I come across the word 'thunk' at a lot of places in code and documentation related to Scheme, and similar territories. I am guessing that it is a generic name for a procedure, which has a single formal argument. Is that correct? If yes, is there more to it? If no, please?



For eg. in SRFI 18, in the 'Procedures' section.










share|improve this question













I come across the word 'thunk' at a lot of places in code and documentation related to Scheme, and similar territories. I am guessing that it is a generic name for a procedure, which has a single formal argument. Is that correct? If yes, is there more to it? If no, please?



For eg. in SRFI 18, in the 'Procedures' section.







programming-languages functional-programming scheme






share|improve this question













share|improve this question











share|improve this question




share|improve this question










asked May 29 '09 at 10:35







user59634














  • 1




    possible duplicate of What is a 'thunk'?
    – Stephan
    May 13 '14 at 9:09












  • 1




    possible duplicate of What is a 'thunk'?
    – Stephan
    May 13 '14 at 9:09







1




1




possible duplicate of What is a 'thunk'?
– Stephan
May 13 '14 at 9:09




possible duplicate of What is a 'thunk'?
– Stephan
May 13 '14 at 9:09












3 Answers
3






active

oldest

votes

















up vote
64
down vote



accepted










It is really simple. When you have some computation, like adding 3 to 5, in your program, then creating a thunk of it means not to calculate it directly, but instead create a function with zero arguments that will calculate it when the actual value is needed.



(let ((foo (+ 3 5))) ; the calculation is performed directly, foo is 8
;; some other things
(display foo)) ; foo is evaluated to 8 and printed

(let ((foo (lambda () (+ 3 5)))) ; the calculation is delayed, foo is a
; function that will perform it when needed
;; some other things
(display (foo))) ; foo is evaluated as a function, returns 8 which is printed


In the second case, foo would be called a thunk.



Lazy languages blur the line between binding a variable to a value and creating a function to return that value, so that writing something like the first form above is actually treated like the second, under the hood.






share|improve this answer
















  • 1




    Scheme is not a lazy language, right? (in 'Overview of Scheme' in r6rs). So, iff I create a think, like above, it will create a lazy evaluation scenario?
    – user59634
    May 29 '09 at 15:09






  • 1




    ^ s/think/thunk/ (my bad)
    – user59634
    May 29 '09 at 15:09






  • 1




    Please look at the link kotlinski (stackoverflow.com/questions/925365/…) provided for how Scheme implements a lazy evaluation scheme.
    – Svante
    May 29 '09 at 15:59






  • 1




    Yes. I did. However, my query here was: Will creating a lambda as above delay the evaluation in a non-Lazy language like Scheme?
    – user59634
    May 30 '09 at 11:17






  • 1




    Yes, of course. Why shouldn't it? Lazy just means that you don't have to do this explicitly, like the above.
    – Svante
    May 30 '09 at 11:48

















up vote
36
down vote













A "thunk" is a procedure object with no formal arguments, e.g. from your SRFI link:



(lambda () (write '(b1)))


The b1 variable is bound in the enclosing block, and this gives us a clue to the etymology of the word "thunk," which relies on a joke about poor grammar.



A zero-argument function has no way to change its behavior based on parameters it is called with, since it has no parameters. Therefore the entire operation of the function is set -- it is just waiting to be executed. No more "thought" is required on the part of the computer, all of the "thinking" has been done -- the action is completely "thunk" through.



That's all a "thunk" is in this SRFI's context -- a procedure with no arguments.






share|improve this answer


















  • 6




    Thanks for explaining why it is called a "thunk"
    – mynameistechno
    Apr 22 '15 at 16:16

















up vote
13
down vote













Wikipedia has the following answer:




In functional programming, "thunk" is another name for a nullary function — a function that takes no arguments. Thunks are frequently used in strict languages as a means of simulating lazy evaluation; the thunk itself delays the computation of a function's argument, and the function forces the thunk to obtain the actual value. In this context, a thunk is often called a suspension or (in Scheme) a promise.




Adding a lazy evaluation example in Scheme. Here, promise is another word for thunk.






share|improve this answer


















  • 4




    Thank You. I am looking for something better. Wikipedia doesn't explain things and concepts I really want to know.
    – user59634
    May 29 '09 at 10:37






  • 1




    @Amit -- I assume you commented before the question was updated with the quote. This is the exact answer to your question.
    – tvanfosson
    May 29 '09 at 10:41






  • 1




    @tvanfosson probablty it was edited after the original post. @kotlinski will it be possible to demonstrate it somehow?
    – user59634
    May 29 '09 at 10:47






  • 1




    OK, added an example... This is also explained well in Paradigms of Artificial Intelligence Programming by Peter Norvig (examine delay/force examples).
    – Johan Kotlinski
    May 29 '09 at 11:11






  • 1




    'force' and 'delay' seems to have been removed from the R6RS.
    – user59634
    May 30 '09 at 11:12










Your Answer






StackExchange.ifUsing("editor", function ()
StackExchange.using("externalEditor", function ()
StackExchange.using("snippets", function ()
StackExchange.snippets.init();
);
);
, "code-snippets");

StackExchange.ready(function()
var channelOptions =
tags: "".split(" "),
id: "1"
;
initTagRenderer("".split(" "), "".split(" "), channelOptions);

StackExchange.using("externalEditor", function()
// Have to fire editor after snippets, if snippets enabled
if (StackExchange.settings.snippets.snippetsEnabled)
StackExchange.using("snippets", function()
createEditor();
);

else
createEditor();

);

function createEditor()
StackExchange.prepareEditor(
heartbeatType: 'answer',
convertImagesToLinks: true,
noModals: true,
showLowRepImageUploadWarning: true,
reputationToPostImages: 10,
bindNavPrevention: true,
postfix: "",
imageUploader:
brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
allowUrls: true
,
onDemand: true,
discardSelector: ".discard-answer"
,immediatelyShowMarkdownHelp:true
);



);













 

draft saved


draft discarded


















StackExchange.ready(
function ()
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f925365%2fwhat-is-a-thunk-as-used-in-scheme-or-in-general%23new-answer', 'question_page');

);

Post as a guest





























3 Answers
3






active

oldest

votes








3 Answers
3






active

oldest

votes









active

oldest

votes






active

oldest

votes








up vote
64
down vote



accepted










It is really simple. When you have some computation, like adding 3 to 5, in your program, then creating a thunk of it means not to calculate it directly, but instead create a function with zero arguments that will calculate it when the actual value is needed.



(let ((foo (+ 3 5))) ; the calculation is performed directly, foo is 8
;; some other things
(display foo)) ; foo is evaluated to 8 and printed

(let ((foo (lambda () (+ 3 5)))) ; the calculation is delayed, foo is a
; function that will perform it when needed
;; some other things
(display (foo))) ; foo is evaluated as a function, returns 8 which is printed


In the second case, foo would be called a thunk.



Lazy languages blur the line between binding a variable to a value and creating a function to return that value, so that writing something like the first form above is actually treated like the second, under the hood.






share|improve this answer
















  • 1




    Scheme is not a lazy language, right? (in 'Overview of Scheme' in r6rs). So, iff I create a think, like above, it will create a lazy evaluation scenario?
    – user59634
    May 29 '09 at 15:09






  • 1




    ^ s/think/thunk/ (my bad)
    – user59634
    May 29 '09 at 15:09






  • 1




    Please look at the link kotlinski (stackoverflow.com/questions/925365/…) provided for how Scheme implements a lazy evaluation scheme.
    – Svante
    May 29 '09 at 15:59






  • 1




    Yes. I did. However, my query here was: Will creating a lambda as above delay the evaluation in a non-Lazy language like Scheme?
    – user59634
    May 30 '09 at 11:17






  • 1




    Yes, of course. Why shouldn't it? Lazy just means that you don't have to do this explicitly, like the above.
    – Svante
    May 30 '09 at 11:48














up vote
64
down vote



accepted










It is really simple. When you have some computation, like adding 3 to 5, in your program, then creating a thunk of it means not to calculate it directly, but instead create a function with zero arguments that will calculate it when the actual value is needed.



(let ((foo (+ 3 5))) ; the calculation is performed directly, foo is 8
;; some other things
(display foo)) ; foo is evaluated to 8 and printed

(let ((foo (lambda () (+ 3 5)))) ; the calculation is delayed, foo is a
; function that will perform it when needed
;; some other things
(display (foo))) ; foo is evaluated as a function, returns 8 which is printed


In the second case, foo would be called a thunk.



Lazy languages blur the line between binding a variable to a value and creating a function to return that value, so that writing something like the first form above is actually treated like the second, under the hood.






share|improve this answer
















  • 1




    Scheme is not a lazy language, right? (in 'Overview of Scheme' in r6rs). So, iff I create a think, like above, it will create a lazy evaluation scenario?
    – user59634
    May 29 '09 at 15:09






  • 1




    ^ s/think/thunk/ (my bad)
    – user59634
    May 29 '09 at 15:09






  • 1




    Please look at the link kotlinski (stackoverflow.com/questions/925365/…) provided for how Scheme implements a lazy evaluation scheme.
    – Svante
    May 29 '09 at 15:59






  • 1




    Yes. I did. However, my query here was: Will creating a lambda as above delay the evaluation in a non-Lazy language like Scheme?
    – user59634
    May 30 '09 at 11:17






  • 1




    Yes, of course. Why shouldn't it? Lazy just means that you don't have to do this explicitly, like the above.
    – Svante
    May 30 '09 at 11:48












up vote
64
down vote



accepted







up vote
64
down vote



accepted






It is really simple. When you have some computation, like adding 3 to 5, in your program, then creating a thunk of it means not to calculate it directly, but instead create a function with zero arguments that will calculate it when the actual value is needed.



(let ((foo (+ 3 5))) ; the calculation is performed directly, foo is 8
;; some other things
(display foo)) ; foo is evaluated to 8 and printed

(let ((foo (lambda () (+ 3 5)))) ; the calculation is delayed, foo is a
; function that will perform it when needed
;; some other things
(display (foo))) ; foo is evaluated as a function, returns 8 which is printed


In the second case, foo would be called a thunk.



Lazy languages blur the line between binding a variable to a value and creating a function to return that value, so that writing something like the first form above is actually treated like the second, under the hood.






share|improve this answer












It is really simple. When you have some computation, like adding 3 to 5, in your program, then creating a thunk of it means not to calculate it directly, but instead create a function with zero arguments that will calculate it when the actual value is needed.



(let ((foo (+ 3 5))) ; the calculation is performed directly, foo is 8
;; some other things
(display foo)) ; foo is evaluated to 8 and printed

(let ((foo (lambda () (+ 3 5)))) ; the calculation is delayed, foo is a
; function that will perform it when needed
;; some other things
(display (foo))) ; foo is evaluated as a function, returns 8 which is printed


In the second case, foo would be called a thunk.



Lazy languages blur the line between binding a variable to a value and creating a function to return that value, so that writing something like the first form above is actually treated like the second, under the hood.







share|improve this answer












share|improve this answer



share|improve this answer










answered May 29 '09 at 11:10









Svante

38.8k662109




38.8k662109







  • 1




    Scheme is not a lazy language, right? (in 'Overview of Scheme' in r6rs). So, iff I create a think, like above, it will create a lazy evaluation scenario?
    – user59634
    May 29 '09 at 15:09






  • 1




    ^ s/think/thunk/ (my bad)
    – user59634
    May 29 '09 at 15:09






  • 1




    Please look at the link kotlinski (stackoverflow.com/questions/925365/…) provided for how Scheme implements a lazy evaluation scheme.
    – Svante
    May 29 '09 at 15:59






  • 1




    Yes. I did. However, my query here was: Will creating a lambda as above delay the evaluation in a non-Lazy language like Scheme?
    – user59634
    May 30 '09 at 11:17






  • 1




    Yes, of course. Why shouldn't it? Lazy just means that you don't have to do this explicitly, like the above.
    – Svante
    May 30 '09 at 11:48












  • 1




    Scheme is not a lazy language, right? (in 'Overview of Scheme' in r6rs). So, iff I create a think, like above, it will create a lazy evaluation scenario?
    – user59634
    May 29 '09 at 15:09






  • 1




    ^ s/think/thunk/ (my bad)
    – user59634
    May 29 '09 at 15:09






  • 1




    Please look at the link kotlinski (stackoverflow.com/questions/925365/…) provided for how Scheme implements a lazy evaluation scheme.
    – Svante
    May 29 '09 at 15:59






  • 1




    Yes. I did. However, my query here was: Will creating a lambda as above delay the evaluation in a non-Lazy language like Scheme?
    – user59634
    May 30 '09 at 11:17






  • 1




    Yes, of course. Why shouldn't it? Lazy just means that you don't have to do this explicitly, like the above.
    – Svante
    May 30 '09 at 11:48







1




1




Scheme is not a lazy language, right? (in 'Overview of Scheme' in r6rs). So, iff I create a think, like above, it will create a lazy evaluation scenario?
– user59634
May 29 '09 at 15:09




Scheme is not a lazy language, right? (in 'Overview of Scheme' in r6rs). So, iff I create a think, like above, it will create a lazy evaluation scenario?
– user59634
May 29 '09 at 15:09




1




1




^ s/think/thunk/ (my bad)
– user59634
May 29 '09 at 15:09




^ s/think/thunk/ (my bad)
– user59634
May 29 '09 at 15:09




1




1




Please look at the link kotlinski (stackoverflow.com/questions/925365/…) provided for how Scheme implements a lazy evaluation scheme.
– Svante
May 29 '09 at 15:59




Please look at the link kotlinski (stackoverflow.com/questions/925365/…) provided for how Scheme implements a lazy evaluation scheme.
– Svante
May 29 '09 at 15:59




1




1




Yes. I did. However, my query here was: Will creating a lambda as above delay the evaluation in a non-Lazy language like Scheme?
– user59634
May 30 '09 at 11:17




Yes. I did. However, my query here was: Will creating a lambda as above delay the evaluation in a non-Lazy language like Scheme?
– user59634
May 30 '09 at 11:17




1




1




Yes, of course. Why shouldn't it? Lazy just means that you don't have to do this explicitly, like the above.
– Svante
May 30 '09 at 11:48




Yes, of course. Why shouldn't it? Lazy just means that you don't have to do this explicitly, like the above.
– Svante
May 30 '09 at 11:48












up vote
36
down vote













A "thunk" is a procedure object with no formal arguments, e.g. from your SRFI link:



(lambda () (write '(b1)))


The b1 variable is bound in the enclosing block, and this gives us a clue to the etymology of the word "thunk," which relies on a joke about poor grammar.



A zero-argument function has no way to change its behavior based on parameters it is called with, since it has no parameters. Therefore the entire operation of the function is set -- it is just waiting to be executed. No more "thought" is required on the part of the computer, all of the "thinking" has been done -- the action is completely "thunk" through.



That's all a "thunk" is in this SRFI's context -- a procedure with no arguments.






share|improve this answer


















  • 6




    Thanks for explaining why it is called a "thunk"
    – mynameistechno
    Apr 22 '15 at 16:16














up vote
36
down vote













A "thunk" is a procedure object with no formal arguments, e.g. from your SRFI link:



(lambda () (write '(b1)))


The b1 variable is bound in the enclosing block, and this gives us a clue to the etymology of the word "thunk," which relies on a joke about poor grammar.



A zero-argument function has no way to change its behavior based on parameters it is called with, since it has no parameters. Therefore the entire operation of the function is set -- it is just waiting to be executed. No more "thought" is required on the part of the computer, all of the "thinking" has been done -- the action is completely "thunk" through.



That's all a "thunk" is in this SRFI's context -- a procedure with no arguments.






share|improve this answer


















  • 6




    Thanks for explaining why it is called a "thunk"
    – mynameistechno
    Apr 22 '15 at 16:16












up vote
36
down vote










up vote
36
down vote









A "thunk" is a procedure object with no formal arguments, e.g. from your SRFI link:



(lambda () (write '(b1)))


The b1 variable is bound in the enclosing block, and this gives us a clue to the etymology of the word "thunk," which relies on a joke about poor grammar.



A zero-argument function has no way to change its behavior based on parameters it is called with, since it has no parameters. Therefore the entire operation of the function is set -- it is just waiting to be executed. No more "thought" is required on the part of the computer, all of the "thinking" has been done -- the action is completely "thunk" through.



That's all a "thunk" is in this SRFI's context -- a procedure with no arguments.






share|improve this answer














A "thunk" is a procedure object with no formal arguments, e.g. from your SRFI link:



(lambda () (write '(b1)))


The b1 variable is bound in the enclosing block, and this gives us a clue to the etymology of the word "thunk," which relies on a joke about poor grammar.



A zero-argument function has no way to change its behavior based on parameters it is called with, since it has no parameters. Therefore the entire operation of the function is set -- it is just waiting to be executed. No more "thought" is required on the part of the computer, all of the "thinking" has been done -- the action is completely "thunk" through.



That's all a "thunk" is in this SRFI's context -- a procedure with no arguments.







share|improve this answer














share|improve this answer



share|improve this answer








edited May 20 '17 at 18:13









Koneke

1017




1017










answered May 29 '09 at 11:23









Steven Huwig

12.1k74976




12.1k74976







  • 6




    Thanks for explaining why it is called a "thunk"
    – mynameistechno
    Apr 22 '15 at 16:16












  • 6




    Thanks for explaining why it is called a "thunk"
    – mynameistechno
    Apr 22 '15 at 16:16







6




6




Thanks for explaining why it is called a "thunk"
– mynameistechno
Apr 22 '15 at 16:16




Thanks for explaining why it is called a "thunk"
– mynameistechno
Apr 22 '15 at 16:16










up vote
13
down vote













Wikipedia has the following answer:




In functional programming, "thunk" is another name for a nullary function — a function that takes no arguments. Thunks are frequently used in strict languages as a means of simulating lazy evaluation; the thunk itself delays the computation of a function's argument, and the function forces the thunk to obtain the actual value. In this context, a thunk is often called a suspension or (in Scheme) a promise.




Adding a lazy evaluation example in Scheme. Here, promise is another word for thunk.






share|improve this answer


















  • 4




    Thank You. I am looking for something better. Wikipedia doesn't explain things and concepts I really want to know.
    – user59634
    May 29 '09 at 10:37






  • 1




    @Amit -- I assume you commented before the question was updated with the quote. This is the exact answer to your question.
    – tvanfosson
    May 29 '09 at 10:41






  • 1




    @tvanfosson probablty it was edited after the original post. @kotlinski will it be possible to demonstrate it somehow?
    – user59634
    May 29 '09 at 10:47






  • 1




    OK, added an example... This is also explained well in Paradigms of Artificial Intelligence Programming by Peter Norvig (examine delay/force examples).
    – Johan Kotlinski
    May 29 '09 at 11:11






  • 1




    'force' and 'delay' seems to have been removed from the R6RS.
    – user59634
    May 30 '09 at 11:12














up vote
13
down vote













Wikipedia has the following answer:




In functional programming, "thunk" is another name for a nullary function — a function that takes no arguments. Thunks are frequently used in strict languages as a means of simulating lazy evaluation; the thunk itself delays the computation of a function's argument, and the function forces the thunk to obtain the actual value. In this context, a thunk is often called a suspension or (in Scheme) a promise.




Adding a lazy evaluation example in Scheme. Here, promise is another word for thunk.






share|improve this answer


















  • 4




    Thank You. I am looking for something better. Wikipedia doesn't explain things and concepts I really want to know.
    – user59634
    May 29 '09 at 10:37






  • 1




    @Amit -- I assume you commented before the question was updated with the quote. This is the exact answer to your question.
    – tvanfosson
    May 29 '09 at 10:41






  • 1




    @tvanfosson probablty it was edited after the original post. @kotlinski will it be possible to demonstrate it somehow?
    – user59634
    May 29 '09 at 10:47






  • 1




    OK, added an example... This is also explained well in Paradigms of Artificial Intelligence Programming by Peter Norvig (examine delay/force examples).
    – Johan Kotlinski
    May 29 '09 at 11:11






  • 1




    'force' and 'delay' seems to have been removed from the R6RS.
    – user59634
    May 30 '09 at 11:12












up vote
13
down vote










up vote
13
down vote









Wikipedia has the following answer:




In functional programming, "thunk" is another name for a nullary function — a function that takes no arguments. Thunks are frequently used in strict languages as a means of simulating lazy evaluation; the thunk itself delays the computation of a function's argument, and the function forces the thunk to obtain the actual value. In this context, a thunk is often called a suspension or (in Scheme) a promise.




Adding a lazy evaluation example in Scheme. Here, promise is another word for thunk.






share|improve this answer














Wikipedia has the following answer:




In functional programming, "thunk" is another name for a nullary function — a function that takes no arguments. Thunks are frequently used in strict languages as a means of simulating lazy evaluation; the thunk itself delays the computation of a function's argument, and the function forces the thunk to obtain the actual value. In this context, a thunk is often called a suspension or (in Scheme) a promise.




Adding a lazy evaluation example in Scheme. Here, promise is another word for thunk.







share|improve this answer














share|improve this answer



share|improve this answer








edited Nov 10 at 13:32









antoine

557




557










answered May 29 '09 at 10:36









Johan Kotlinski

18.5k66294




18.5k66294







  • 4




    Thank You. I am looking for something better. Wikipedia doesn't explain things and concepts I really want to know.
    – user59634
    May 29 '09 at 10:37






  • 1




    @Amit -- I assume you commented before the question was updated with the quote. This is the exact answer to your question.
    – tvanfosson
    May 29 '09 at 10:41






  • 1




    @tvanfosson probablty it was edited after the original post. @kotlinski will it be possible to demonstrate it somehow?
    – user59634
    May 29 '09 at 10:47






  • 1




    OK, added an example... This is also explained well in Paradigms of Artificial Intelligence Programming by Peter Norvig (examine delay/force examples).
    – Johan Kotlinski
    May 29 '09 at 11:11






  • 1




    'force' and 'delay' seems to have been removed from the R6RS.
    – user59634
    May 30 '09 at 11:12












  • 4




    Thank You. I am looking for something better. Wikipedia doesn't explain things and concepts I really want to know.
    – user59634
    May 29 '09 at 10:37






  • 1




    @Amit -- I assume you commented before the question was updated with the quote. This is the exact answer to your question.
    – tvanfosson
    May 29 '09 at 10:41






  • 1




    @tvanfosson probablty it was edited after the original post. @kotlinski will it be possible to demonstrate it somehow?
    – user59634
    May 29 '09 at 10:47






  • 1




    OK, added an example... This is also explained well in Paradigms of Artificial Intelligence Programming by Peter Norvig (examine delay/force examples).
    – Johan Kotlinski
    May 29 '09 at 11:11






  • 1




    'force' and 'delay' seems to have been removed from the R6RS.
    – user59634
    May 30 '09 at 11:12







4




4




Thank You. I am looking for something better. Wikipedia doesn't explain things and concepts I really want to know.
– user59634
May 29 '09 at 10:37




Thank You. I am looking for something better. Wikipedia doesn't explain things and concepts I really want to know.
– user59634
May 29 '09 at 10:37




1




1




@Amit -- I assume you commented before the question was updated with the quote. This is the exact answer to your question.
– tvanfosson
May 29 '09 at 10:41




@Amit -- I assume you commented before the question was updated with the quote. This is the exact answer to your question.
– tvanfosson
May 29 '09 at 10:41




1




1




@tvanfosson probablty it was edited after the original post. @kotlinski will it be possible to demonstrate it somehow?
– user59634
May 29 '09 at 10:47




@tvanfosson probablty it was edited after the original post. @kotlinski will it be possible to demonstrate it somehow?
– user59634
May 29 '09 at 10:47




1




1




OK, added an example... This is also explained well in Paradigms of Artificial Intelligence Programming by Peter Norvig (examine delay/force examples).
– Johan Kotlinski
May 29 '09 at 11:11




OK, added an example... This is also explained well in Paradigms of Artificial Intelligence Programming by Peter Norvig (examine delay/force examples).
– Johan Kotlinski
May 29 '09 at 11:11




1




1




'force' and 'delay' seems to have been removed from the R6RS.
– user59634
May 30 '09 at 11:12




'force' and 'delay' seems to have been removed from the R6RS.
– user59634
May 30 '09 at 11:12

















 

draft saved


draft discarded















































 


draft saved


draft discarded














StackExchange.ready(
function ()
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f925365%2fwhat-is-a-thunk-as-used-in-scheme-or-in-general%23new-answer', 'question_page');

);

Post as a guest














































































Popular posts from this blog

Top Tejano songwriter Luis Silva dead of heart attack at 64

ReactJS Fetched API data displays live - need Data displayed static

政党