From f1e7cbbd47b27d3888c9a7a8ba1435969d07eefa Mon Sep 17 00:00:00 2001
From: Justin Ethier <justin.ethier@gmail.com>
Date: Fri, 21 Jun 2019 13:29:03 -0400
Subject: [PATCH] Merged into (cyclone concurrent)

---
 libs/cyclone/futures.sld | 75 ----------------------------------------
 1 file changed, 75 deletions(-)
 delete mode 100644 libs/cyclone/futures.sld

diff --git a/libs/cyclone/futures.sld b/libs/cyclone/futures.sld
deleted file mode 100644
index 7fa51af0..00000000
--- a/libs/cyclone/futures.sld
+++ /dev/null
@@ -1,75 +0,0 @@
-;; Temporary test file for futures
-;; See:
-;; https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/future?
-;; https://purelyfunctional.tv/guide/clojure-concurrency/#future
-
-(define-library (futures)
-  (import (scheme base)
-          (scheme write)
-          ;(cyclone concurrent)
-          (srfi 18)
-  )
-  (export
-    future?
-    future
-    future-call
-    future-deref
-  )
-  (begin
-
-  (define-record-type <future>
-    (make-future done result lock)
-    future?
-    (done get-done set-done!)
-    (result get-result set-result!)
-    (lock get-lock set-lock!))
-
-  ;; macro: (future expr ...)
-  (define-syntax future
-    (er-macro-transformer
-      (lambda (expr rename compare)
-        `(future-call (lambda () ,@(cdr expr))))))
-
-;; From the clojure docs:
-;;
-;; Takes a function of no args and yields a future object that will
-;; invoke the function in another thread, and will cache the result and
-;; return it on all subsequent calls to deref/@. If the computation has
-;; not yet finished, calls to deref/@ will block, unless the variant
-;; of deref with timeout is used. See also - realized?.
-(define (future-call thunk)
-  (let* (
-         (lock (make-mutex))
-         (ftr (make-future #f #f lock))
-         (tfnc (lambda ()
-                 (mutex-lock! lock) 
-                 (let ((result (thunk))) ;; TODO: Catch exceptions (?)
-                   (set-result! ftr result)
-                   (set-done! ftr #t)
-                   (mutex-unlock! lock) 
-                 )))
-         (t (make-thread tfnc))
-        )
-    (thread-start! t)
-    ftr))
-
-;;(define (future-done? ftr)
-;;  (when (not (future? ftr))
-;;    (error "Expected future but received" ftr))
-;; TODO: may be a good candidate for a timed mutex lock, just return #f if minimum timeout is exceeded
-;;)
-
-;; TODO: (future-cancel ftr)
-;; TODO: (future-cancelled? ftr)
-
-;;TODO: custom deref but eventually need to fold this functionality back into the main one
-(define (future-deref ftr)
-  (when (not (future? ftr))
-    (error "Expected future but received" ftr))
-  (let ((result #f))
-    (mutex-lock! (get-lock ftr))
-    (set! result (get-result ftr))
-    (mutex-unlock! (get-lock ftr))
-    result))
-
-))