Promises that refer to themselves

[soegaard]

Hi,

I was looking for examples of Julia macros and decided to
look for delay and force macros. The one in promises.jl
looks like this:

    force(p::Promise) -> Any
To 'force' a promise means to run its code.
The results will be saved, which means forcing twice will run only once.
See also: `@delay`
"""

force(p::Promise) = begin
    if p.evaluated
        p.value
    else
        p.value = p.value()
        p.evaluated = true
        p.value
    end
end

There is a potential problem for promises that refer to themselves.
Forcing such a promise could lead to the promise being forced (and the value being set).
In such a case, the value from first evaluation of the promise ought to be used.

Compare with this definition from the R5RS report:

define make-promise
  (lambda (proc)
    (let ((result-ready? #f)
          (result #f))
      (lambda ()
        (if result-ready?
            result
            (let ((x (proc)))
              (if result-ready?
                  result
                  (begin (set! result-ready? #t)
                         (set! result x)
                         result))))))))

Rationale:   A promise may refer to its own value, as in the last example above. Forcing such a promise may cause the promise to be forced a second time before the value of the first force has been computed. This complicates the definition of make-promise.

[ftxi]

Thank you for your reply!

It's a pity that the code was written 6yrs ago (and based on Julia 0.6 or so). I did not plan to implement it in the way that a promise may refer its own value and I am not coming up with a useful example in which this may happen. Perhaps this is an example (found in r5rs) in which two definitions above may differ:

(define count 0)
    (define p
      (delay (begin (set! count (+ count 1))
                    (if (> count x)
                         count
                         (force p)))))

and you should reimplement the whole thing as in r5rs in your own julia project.