Promises

(define (test/delay-and-make-promise _)
  (let* ((count (let1 (counter 0)
                      (λ () (set! counter (add1 counter)) counter)))
         (delayed_count (delay (count))))
    (⊦= 1 (force delayed_count))
    (⊦= 1 (force delayed_count))
    (⊦= 1 (force delayed_count))
    (⊦= 1 (force delayed_count))
    (⊦= 1 (force delayed_count))
    (let1 (promised_count (make-promise (count)))
          (⊦= 2 (force promised_count))
          (⊦= 2 (force promised_count))
          (let1 (promised_ccount (make-promise (count)))
                (⊦= 2 (force promised_count))
                (⊦= 3 (force promised_ccount))
                (⊦= 4 (count))))))

((eta 0.0) (memory #(6291456 1866032 1048576)) (stdout "") (stderr ""))

(define (test/promise? _)
  (⊨ (promise? (delay (+ 3 4))))
  (⊨ (promise? (delay-force (+ 3 4)))))

((eta 0.0) (memory #(6291456 1867224 1048576)) (stdout "") (stderr ""))

(define (test/delay-force-filter _)
  (letrec ((stream-filter/tailcall
             (λ (p? s)
                (delay-force
                  (let1 (s-mature (force s))
                        (if (null? s-mature)
                          (delay '())
                          (let-values
                            (((h t) (car+cdr s-mature)))
                            (if (p? h)
                              (delay (cons h (stream-filter/tailcall p? t)))
                              (stream-filter/tailcall p? t))))))))
           (stream-filter/stackfull
             (λ (p? s)
                (delay (force (let1 (s-mature (force s))
                                    (if (null? s-mature)
                                      (delay '())
                                      (let-values
                                        (((h t) (car+cdr s-mature)))
                                        (if (p? h)
                                          (delay (cons h (stream-filter/stackfull p? t)))
                                          (stream-filter/stackfull p? t)))))))))
           (from (λ (n) (delay-force (cons n (from (+ n 1))))))
           (large-number 10000))
    (⊦= large-number
        (car (force (stream-filter/tailcall
                      (λ (n) (= n large-number))
                      (from 0)))))))

((eta 0.031) (memory #(6291456 1869432 1048576)) (stdout "") (stderr ""))

(define (test/force-non-promises _)
  (⊨ (procedure? (force (τ 3))))
  (⊦= '3 (force (make-promise 3))))

((eta 0.0) (memory #(6291456 1870696 1048576)) (stdout "") (stderr ""))