title: CS450 layout: true author: Tiago Cogumbreiro lecture: 10 abstract: TypedRacket, thunks, and promises sep: &nbsp;☽&nbsp; <img id="logo" src="data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8"?>
<svg id="a" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 124.8 59.6"><defs><style>.b{fill:#005a8b;}</style></defs><path class="b" d="M6.45,43.91c1.38,0,2.52-.32,3.4-.97,.88-.65,1.32-1.52,1.32-2.61,0-.78-.27-1.47-.81-2.05-.54-.58-1.25-.95-2.15-1.09,1.69-.51,2.53-1.52,2.53-3.03,0-.95-.37-1.71-1.12-2.27-.75-.56-1.81-.84-3.19-.84H.28v12.85H6.45Zm-3.38-10.54h2.94c.65,0,1.14,.11,1.46,.32,.32,.21,.49,.57,.49,1.06,0,.93-.65,1.4-1.95,1.4H3.07v-2.77h0Zm0,5.01h2.97c1.49,0,2.24,.54,2.24,1.62s-.75,1.6-2.24,1.6H3.07v-3.21h0Zm10.7,4.43c.92,.92,2.07,1.39,3.45,1.39s2.59-.45,3.49-1.34c.89-.89,1.34-2.07,1.34-3.54s-.45-2.62-1.35-3.52c-.9-.9-2.06-1.35-3.48-1.35s-2.56,.45-3.47,1.35c-.91,.9-1.36,2.07-1.36,3.52s.46,2.57,1.38,3.5h0Zm3.45-.69c-.66,0-1.18-.24-1.55-.71-.37-.47-.56-1.16-.56-2.07s.19-1.61,.56-2.1c.37-.5,.89-.74,1.55-.74s1.18,.25,1.55,.74c.37,.5,.56,1.2,.56,2.1s-.19,1.59-.56,2.07c-.37,.47-.89,.71-1.55,.71h0Zm7.26,1.32c.8,.48,1.75,.72,2.84,.72,1.32,0,2.36-.27,3.12-.82,.76-.54,1.14-1.28,1.14-2.21,0-1.51-1.05-2.46-3.16-2.86l-1.27-.24c-.49-.09-.82-.19-1-.32-.18-.13-.27-.32-.27-.58s.11-.48,.34-.64c.23-.16,.55-.24,.96-.24,.92,0,1.54,.43,1.85,1.29l2.15-.97c-.25-.58-.7-1.07-1.37-1.49-.67-.42-1.5-.62-2.51-.62-1.21,0-2.17,.26-2.88,.79-.71,.53-1.06,1.23-1.06,2.11s.24,1.48,.73,1.89c.48,.42,1.26,.73,2.32,.94l1.3,.26c.42,.09,.71,.21,.88,.36,.17,.15,.26,.36,.26,.62s-.13,.49-.38,.66c-.25,.17-.59,.26-1.02,.26-.77,0-1.29-.17-1.56-.51-.28-.36-.46-.7-.53-1.03l-2.37,.75c.18,.8,.68,1.43,1.48,1.91h0Zm9.98-.2c.42,.44,.99,.66,1.71,.66h3.07v-2.07h-1.98c-.28,0-.49-.06-.62-.19-.13-.13-.19-.33-.19-.62v-4.31h2.39v-1.98h-2.39v-2.88h-2.61v2.88h-1.93v1.98h1.93v4.79c0,.72,.21,1.3,.62,1.74h0Zm6.76-.43c.92,.92,2.07,1.39,3.45,1.39s2.59-.45,3.49-1.34c.89-.89,1.34-2.07,1.34-3.54s-.45-2.62-1.35-3.52c-.9-.9-2.06-1.35-3.48-1.35s-2.56,.45-3.47,1.35c-.91,.9-1.36,2.07-1.36,3.52s.46,2.57,1.38,3.5h0Zm3.45-.69c-.66,0-1.18-.24-1.55-.71-.37-.47-.56-1.16-.56-2.07s.19-1.61,.56-2.1c.37-.5,.89-.74,1.55-.74s1.18,.25,1.55,.74c.37,.5,.56,1.2,.56,2.1s-.19,1.59-.56,2.07c-.37,.47-.89,.71-1.55,.71h0Zm9.16,1.78v-4.35c0-1.15,.2-1.97,.61-2.46,.27-.33,.68-.5,1.23-.5,.98,0,1.47,.58,1.47,1.73v5.58h2.61v-6.15c0-1.05-.25-1.87-.76-2.44-.51-.58-1.26-.86-2.27-.86-1.28,0-2.27,.56-2.96,1.69v-1.41h-2.53v9.18h2.61Z"/><path class="b" d="M1.86,25.7c1.05,.95,2.44,1.43,4.19,1.43s3.1-.48,4.17-1.43c1.06-.95,1.6-2.25,1.6-3.87v-7.84h-2.79v7.4c0,2.24-.99,3.36-2.97,3.36-.98,0-1.72-.28-2.22-.85-.5-.57-.75-1.4-.75-2.51v-7.4H.29v7.84c0,1.63,.52,2.92,1.57,3.87h0Zm15.5,1.14v-10.46l3.54,10.46h2.48l3.58-10.48v10.48h2.79V13.99h-4.41l-2.15,6.26c-.4,1.21-.73,2.12-.97,2.74-.24-.61-.57-1.52-.97-2.74l-2.11-6.26h-4.57v12.85h2.79Zm15.13-.44c.55,.49,1.24,.73,2.07,.73,1.38,0,2.43-.54,3.14-1.63,.1,.89,.65,1.34,1.65,1.34h2v-1.98h-.81c-.25,0-.4-.03-.46-.09-.06-.06-.09-.21-.09-.46v-3.36c0-1.17-.35-2.06-1.06-2.66-.7-.6-1.72-.9-3.04-.9-1.25,0-2.27,.28-3.06,.83-.79,.55-1.22,1.21-1.29,1.98l2.35,.51c.23-.97,.91-1.45,2.02-1.45,1,0,1.51,.42,1.51,1.27v.35c-.89,.09-1.67,.21-2.32,.36-.65,.15-1.25,.36-1.78,.63-.53,.27-.94,.62-1.22,1.06-.28,.44-.43,.96-.44,1.56,0,.78,.28,1.42,.83,1.91h0Zm4.39-1.73c-.37,.37-.83,.55-1.38,.55-.8,0-1.19-.33-1.19-.99,0-.54,.26-.93,.77-1.17,.51-.24,1.3-.43,2.35-.57v.59c0,.7-.18,1.23-.55,1.6h0Zm6.38,1.71c.8,.48,1.75,.72,2.84,.72,1.32,0,2.36-.27,3.12-.82,.76-.54,1.14-1.28,1.14-2.21,0-1.51-1.05-2.46-3.16-2.86l-1.27-.24c-.49-.09-.82-.19-1-.32-.18-.13-.27-.32-.27-.58s.11-.48,.34-.64c.23-.16,.55-.24,.96-.24,.92,0,1.54,.43,1.85,1.29l2.15-.97c-.24-.58-.7-1.07-1.37-1.49-.67-.42-1.5-.62-2.51-.62-1.21,0-2.17,.26-2.88,.79-.71,.53-1.07,1.23-1.07,2.11s.24,1.47,.72,1.89c.48,.42,1.26,.73,2.32,.94l1.3,.26c.42,.09,.71,.21,.88,.36,.17,.15,.26,.36,.26,.62s-.13,.49-.38,.66c-.25,.17-.59,.26-1.02,.26-.77,0-1.29-.17-1.56-.51-.28-.35-.46-.7-.53-1.03l-2.37,.75c.18,.8,.68,1.43,1.48,1.91h0Zm9.45,0c.8,.48,1.75,.72,2.84,.72,1.32,0,2.36-.27,3.12-.82,.76-.54,1.14-1.28,1.14-2.21,0-1.51-1.05-2.46-3.16-2.86l-1.27-.24c-.49-.09-.82-.19-1-.32-.18-.13-.27-.32-.27-.58s.11-.48,.34-.64c.23-.16,.55-.24,.96-.24,.92,0,1.54,.43,1.85,1.29l2.15-.97c-.24-.58-.7-1.07-1.37-1.49-.67-.42-1.5-.62-2.51-.62-1.21,0-2.17,.26-2.88,.79-.71,.53-1.07,1.23-1.07,2.11s.24,1.47,.73,1.89c.48,.42,1.26,.73,2.32,.94l1.3,.26c.42,.09,.71,.21,.88,.36,.17,.15,.26,.36,.26,.62s-.13,.49-.38,.66c-.25,.17-.59,.26-1.02,.26-.77,0-1.29-.17-1.56-.51-.28-.35-.46-.7-.53-1.03l-2.37,.75c.18,.8,.68,1.43,1.48,1.91h0Z"/><path class="b" d="M123.56,37.95c0-5.44,0-10.89,0-16.33,0-.53-.02-1.06-.04-1.6-.05-1.15-.22-2.29-.47-3.41-1.66-7.41-7.23-13.36-14.5-15.5-1.66-.49-3.36-.78-5.1-.82-.54-.01-1.08,0-1.62,0h-36.56v.4c0,7.18,0,14.36,0,21.54,0,5.25,0,10.51,0,15.76,0,.66,.04,1.33,.08,1.99,.09,1.32,.34,2.61,.69,3.88,1.78,6.46,6.71,11.78,13,14.06,2.38,.86,4.83,1.26,7.36,1.26,5.2,0,10.4,0,15.6,0,.84,0,1.67-.04,2.51-.09,1.04-.06,2.06-.24,3.07-.49,5.22-1.32,9.35-4.21,12.39-8.64,1.68-2.44,2.74-5.14,3.27-8.06,.23-1.3,.32-2.61,.32-3.93h0Zm-20.01-23.79c-.03,.87-.12,1.72-.34,2.56-.3,1.19-.83,2.26-1.68,3.15-.68,.72-1.5,1.24-2.41,1.63-1.07,.46-2.19,.73-3.35,.89-1.26,.18-2.53,.22-3.81,.21-.63,0-1.26,0-1.88,0h-.31V8.19c0-.63,.01-1.26,.11-1.88,.02-.11,.04-.22,.06-.33,.08-.44,.33-.72,.78-.85,.55-.16,1.12-.29,1.69-.34,.67-.06,1.34-.1,2.01-.1,1.32,0,2.62,.18,3.88,.64,2.44,.88,4.03,2.58,4.79,5.06,.38,1.23,.5,2.49,.45,3.77h0Zm2.39,20.48c.32,1.32,.41,2.67,.33,4.02-.06,1.11-.24,2.2-.61,3.25-.87,2.48-2.55,4.2-4.94,5.25-1.01,.44-2.07,.73-3.16,.89-.94,.15-1.89,.22-2.84,.19-.87-.03-1.74-.09-2.58-.35-.94-.29-1.57-.9-1.9-1.83-.23-.66-.35-1.35-.4-2.05-.04-.7-.07-1.39-.07-2.09,0-4.75,0-9.49,0-14.24v-.4c.12,0,.21-.01,.29-.01,1.12,0,2.23-.01,3.35,.01,2.02,.05,4.01,.29,5.95,.88,.99,.3,1.93,.7,2.81,1.25,1.97,1.22,3.2,2.97,3.75,5.21h0Zm15.64,3.79c-.04,4.84-1.74,9.07-5.01,12.64-2.57,2.81-5.72,4.67-9.42,5.58h0c-.91,.23-1.84,.4-2.78,.45-.71,.04-1.43,.09-2.14,.09-5.35,0-10.7,.01-16.05,0-3.78,0-7.26-1.05-10.41-3.13-1.68-1.11-3.14-2.46-4.4-4.04-1.03-1.29-1.63-2.77-1.89-4.4-.18-1.13-.22-2.26-.12-3.39,.1-1.16,.24-2.32,.36-3.49,.12-1.11,.25-2.22,.39-3.33,.13-1.1,.26-2.2,.39-3.3,.11-.96,.22-1.92,.34-2.88,.11-.95,.23-1.9,.34-2.86,.11-.96,.23-1.92,.34-2.88,.11-.95,.23-1.9,.34-2.86,.08-.65,.15-1.3,.24-1.95,.03-.19-.03-.32-.18-.44-.38-.3-.75-.63-1.13-.93-.12-.09-.18-.2-.18-.35,0-.89,0-2.67,0-2.67v-.27h2.45v-4.6h-1.2s2.78-2.17,4.08-3.14c.13-.1,.29-.34,.29-.54-.01-.8,0-1.56,0-2.36,0-.08,0-.16,0-.24,.02-.11,.08-.19,.18-.22,.03-.01,.06-.02,.1-.02,.14,0,.25,.09,.27,.23,.01,.08,0,.16,0,.23,0,.82,.02,1.54,0,2.36,0,.2,.14,.44,.27,.54,1.29,.96,4.11,3.14,4.11,3.14h-1.2v4.6h2.46s0,.29,0,.69c0,.58,0,1.62,0,2.24,0,.14-.05,.24-.16,.34-.41,.33-.8,.67-1.21,1-.12,.09-.16,.19-.14,.34,.1,.87,.19,1.73,.29,2.6,.1,.88,.19,1.75,.28,2.63,.1,.89,.2,1.79,.29,2.68,.09,.88,.19,1.75,.28,2.63,.1,.89,.19,1.79,.29,2.68,.1,.88,.19,1.75,.28,2.63,.1,.9,.2,1.8,.29,2.7,.09,.88,.19,1.75,.28,2.63,.1,.89,.19,1.79,.29,2.68,.09,.88,.19,1.75,.28,2.63,.12,1.13,.19,2.28,.47,3.39,.09,.35,.19,.71,.32,1.05,.5,1.35,1.44,2.26,2.78,2.76,.74,.27,1.51,.43,2.29,.52,1.19,.13,2.38,.2,3.58,.15,1.26-.05,2.53-.1,3.79-.2,1.88-.16,3.73-.45,5.55-.92,.61-.16,1.21-.33,1.81-.53,2.11-.7,4.08-1.66,5.86-3,1.92-1.44,3.48-3.19,4.54-5.36,.68-1.41,1.09-2.9,1.25-4.46,.2-1.97,.04-3.9-.6-5.78-.76-2.22-2.12-4-3.99-5.42-1.48-1.12-3.12-1.91-4.86-2.5-.49-.17-1-.31-1.5-.47-.08-.03-.16-.05-.31-.09,.13-.07,.21-.11,.29-.15,1.17-.55,2.28-1.21,3.29-2.02,2.31-1.84,3.8-4.19,4.28-7.12,.52-3.13,.03-6.1-1.62-8.84-.1-.16-.22-.34-.36-.53-.83-1.06-2.26-2.39-2.3-2.46,.08,.02,.16,.04,.24,.07,5.41,1.89,9.26,5.47,11.54,10.73,.66,1.53,1.08,3.13,1.29,4.78,.1,.77,.16,1.55,.16,2.32,.01,5.8,.05,11.61,0,17.41h0ZM75,14.04s1.98,0,2.98,0c0-1.55,0-4.61,0-4.61h-2.98v4.6h0Zm42.41,45.14v-2.54h.95v-.34h-2.28v.34h.95v2.54h.38Zm1.7,0v-2.45l.83,2.45h.34l.84-2.41v2.41h.37v-2.88h-.51l-.69,2c-.07,.2-.12,.36-.15,.46-.03-.09-.07-.24-.14-.43l-.68-2.04h-.57v2.88h.37Z"/></svg>" height="64" /> .bottom-bar[ {{title}} {{sep}} {{abstract}} {{sep}} Lecture {{lecture}} {{sep}} {{author}} ] --- class: middle, full # {{title}} ## Structure of Higher Level Languages ### Lecture {{lecture}}: {{abstract}} ### {{author}} --- class: impact # Module 4: # Lazy evaluation --- # Module 4 ## Lazy evaluation * TypedRacket: typing annotations on top of Racket * Using functions to delay computation * Lazy evaluation as a form of controlling execution * Lazy evaluation as data structures * Functional patterns applied to delayed evaluation --- class: impact # TypedRacket --- # Typing a factorial example .col-7[ ```scheme *1. #lang typed/racket *2. (: factorial (-> Number Number)) 3. (define (factorial n) 4. (cond [(= n 0) 1] 5. [else (* n (factorial (- n 1)))])) ``` ] .row[] ---- - *Line 1.* Specifies that we are using TypedRacket with `typed/racket` - *Line 2.* **Function signature:** `(: name-of-function (-> TypeOfArg1 TypeOfArg2 ReturnType))` - **Running a script is the same as with Racket.** Run `racket script.rkt` as usual! - Run `racket -I typed/racket` to start the TypedRacket REPL. - Write `#lang typed/racket/no-check` to disable type-checking (not advised). --- class: impact # Delayed evaluation --- # Recall the evaluation order ### Function application The evaluation of function application can be called *eager* * Evaluating a function application first evaluates each argument before evaluating the body of the function. ### Condition The evaluation of `cond` can be called *lazy*, in the sense that a branch of `cond` is only evaluated when its guard yields true (and only the one branch is evaluated). --- # How to encode an `if-then-else`? ```scheme (: factorial (-> Number Number)) (define (factorial n) (cond [(= n 0) 1] [else (* n (factorial (- n 1)))])) ``` -- ### Example .col-6.small[ ```scheme (: if (All [T] (-> Boolean T T T))) (define (if b then-branch else-branch) (cond [b then-branch] [else else-branch])) (: factorial (-> Number Number)) (define (factorial n) (if (= n 0) 1 (* n (factorial (- n 1))))) (factorial 10) ``` ] .col-1[&nbsp;] .col-5.box[ The type `(All [T] (-> Boolean T T T))` specifies a **type-parameter**, akin to a generic of Java or a template parameter of C++ ] .row[] > What is wrong with this implementation? -- > Why does `(factorial 10)` not terminate? --- # Our implementation of `if` is too eager Because our `if` is a function, applying it evaluates the `then-branch` and the `else-branch` before choosing what to return. This means our factorial no longer has a base case, and, therefore, it does not terminate. ```scheme = (factorial 0) = (if `(= 0 0)` 1 (* 0 (factorial (- 0 1)))) = (if #t 1 (* 0 (factorial `(- 0 1)`))) = (if #t 1 (* 0 `(factorial -1)`)) = (if #t 1 (* 0 (if (= -1 0) 1 (* -1 (factorial (- -1 1)))))) = ... ``` > Any idea how we can work around this limitation? --- # Using `lambda`s to delay computation > We can use a zero-argument lambda to hold each branch, as a `lambda` delays > computation! ```scheme (: if (All [T] (-> Boolean `(-> T)` `(-> T)` T))) (define (if b then-branch else-branch) (cond [b (then-branch)] [else (else-branch)])) (: factorial (-> Number Number)) (define (factorial n) (if (= n 0) (`lambda ()` 1) (`lambda ()` (* n (factorial (- n 1)))))) (factorial 10) ``` ---- - Now each parameter is of type `(-> T)`, a function that takes 0 arguments and returns a value of type `T` --- ## Typechecking errors .col-6.small[ ```scheme foo.rkt:8:2: Type Checker: Polymorphic function `if' could not be applied to arguments: Argument 1: Expected: Boolean Given: Boolean Argument 2: Expected: (-> T) Given: One Argument 3: Expected: (-> T) Given: (-> Number) Result type: T Expected result: Number *in:(if (= n 0) 1 (lambda () (* n (factorial (- n 1))))) ``` ] .col-6[ | # | Value | Expected | Given | |--|------|------|-----| | 1. | `(= n 0)` | `Boolean` | `Boolean` | | 2. | `1` | `(-> T)` | `One` | | 3. | `(lambda)` | `(-> T)` | `(-> Number)` | | | return | `T` | `Number` | - Ignore row when same type (Arg 1) - Ignore when type param `T` vs `Number` - .alt[Only interesting is `Argument 2`, `(-> T)` vs `One`, which is the type of `1`] ] --- # Thunks: zero-argument functions The pattern of using zero-argument functions to delay evaluation is called a *thunk*. You can use thunk as a verb which is a synonym of delaying evaluation. * `(lambda () e)` delays expression `e` * `(e)` evaluates thunk `e` and calls that thunk ??? > Notice that thunks are only possible because of lexical scoping and closures. --- # Using `thunk` Racket offers `(thunk e)` as a short-hand notation for `(lambda () e)`; both notations are equivalent. ```scheme (: if (All [T] (-> Boolean (-> T) (-> T) T))) (define (if b then-branch else-branch) (cond [b (then-branch)] [else (else-branch)])) (: factorial (-> Number Number)) (define (factorial n) (if (= n 0) `(thunk` 1) `(thunk` (* n (factorial (- n 1)))))) (factorial 10) ``` --- # Thunks for delayed evaluation - You can use `(lambda () some-computation)` to delay the evaluation of `some-computation`. - To initiate `some-computation` you need to run the lambda. - You can use `(thunk some-computation)` as a short-hand notation. - Using a lambda to delay computation also lets you run the same computation multiple times. ```scheme (: f (-> Number)) ; (define (f) (displayln "Called (f)") 0) ; <- equivalent (define f (thunk (displayln "Called (f)") 0 ) ) (f) ; Outputs: Called (f) (f) ; Outputs: Called (f) ``` --- class: impact # Functional patterns: promises --- # Repeated delayed computation > In functional programming, there are cases where you have an intertwined > pipeline of functions where a thunk might be carried around. Since we aim at > side-effect free programming models, it is wasteful to compute a thunk > multiple times, when at most one would do. ### Example ```scheme (define (runner count thunk call-back) (cond [(<= count 0) (call-back (thunk) thunk)] ; `invokes thunk once, and passes it along` [else (call-back count thunk)])) ; `does not invoke thunk` ``` > It might not be possible to know, at the function-level, if `thunk` was already > called, as it depends on the caller and, in this case, on `call-back` as well. --- # Promises: memoize delayed computation * `(delay e)` delays the evaluation of an expression (yielding a promise) * `(force e)` caches the result of evaluating `e`, so that multiple applications of that thunk return the result. > **Did you know?** > * Memoization: optimization technique that caches the result of an expensive function and returns the cached result > * Haskell does not share the same evaluation model as we have in Racket. > Instead, *all* expressions of the language are lazily evaluated. > * The idea of memoized delayed evaluation provides an elegant way to parallelize code. > The concept is usually known as a *future*. > * The idea of memoized delayed evaluation (promises) is also very important in asynchronous code (networking, and GUI), e.g., in JavaScript, in Python --- # Example: `delay`/`force` <div class="col-6" markdown=1> ### Thunks ```scheme (define (thunk-repeat n th) (cond [(<= n 0) (void)] [else `(th)` (thunk-repeat (- n 1) th)])) (thunk-repeat 3 (`thunk` (sleep 1) 3)) ``` </div> <div class="col-6" markdown=1> ### Promises ```scheme (define (promise-repeat n prom) (cond [(<= n 0) (void)] [else `(force prom)` (promise-repeat (- n 1) prom)])) (promise-repeat 3 (`delay` (sleep 1) 3)) ``` </div> --- # Promises versus thunks ### Accessor * Promises: must call function `force` * Thunks: call the object itself ### Evaluation count * `(force p)` evaluates the promise at most **once**; subsequent calls are cached * `(th)` calling a thunk evaluates its contents **each and every time** --- class: impact # Implementing promises --- # Implementing promises: state > Promises are usually implemented with mutable references. > Can we get away with implementing promises without using mutation? A promise has two states: 1. when the thunk has not been run yet 2. when the thunk has been run at least once A promise must hold: * the thunk we want to cache * the empty/full status We need to separate the operations that mutate the state, from the ones that query the state. --- # Implementing promises: operations Function `(force p)` can be thought of as a few smaller operations: 1. checking if the promise is empty 2. if the promise is empty, update the promise state to full and store the result of the thunk 3. if the promise is full, does nothing to the promise state, and returns the cached result Let us separate the operations that change the state from the ones that return the value. * Function `(promise-sync p)` returns a new promise state. When the promise is empty, it computes the thunk and stores the result in a full promise. When the promise is full, it just returns the promise given. * Function `(promise-get p)` can only be called when the promise is full and returns the result of the promise. --- # Immutable promise implementation ```scheme (struct promise (empty? result)) (define (make-promise thunk) (promise #t thunk)) (define (promise-run w) (define th (promise-result w)) (th)) (define (promise-get p) (cond [(promise-empty? p) (error "promise: call (promise-sync p) first.")] [else (promise-result p)])) (define (promise-sync p) (cond [(not (promise-empty? p)) p] [else (promise #f (promise-run p))])) ``` --- # Example of immutable promises ### Immutable Promises ```scheme (define (promise-repeat n prom) (cond [(<= n 0) (void)] [else (promise-repeat (- n 1) (`promise-sync` prom))])) (promise-repeat 3 (make-promise (`thunk` (sleep 1) 3))) ``` ### Standard promises ```scheme (define (promise-repeat n prom) (cond [(<= n 0) (void)] [else `(force prom)` (promise-repeat (- n 1) prom)])) (promise-repeat 3 (`delay` (sleep 1) 3)) ```