refactored `with-fut-resolve' to accept more use-cases.

src/fcomputation.lisp

@@ -49,14 +49,14 @@ Example:
 (with-fut-resolve
   (bt:make-thread
    (lambda ()
-     (fresolve (do-some-lengthy-calculation)))))
+     (let ((result (do-some-lengthy-calculation)))
+       (fresolve result)))))
 ```
 "
-  `(macrolet ((fresolve (resolve-form)
-                `(make-future (lambda (resolve-fun)
-                                (let ((resolved ,resolve-form))
-                                  (funcall resolve-fun resolved))))))
-     ,@body))
+  `(make-future (lambda (resolve-fun)
+                  (macrolet ((fresolve (resolve-value)
+                               `(funcall resolve-fun ,resolve-value)))
+                     ,@body))))
 
 (defun make-future (execute-fun)
   "Creates a future. `execute-fun` is the lambda that is executed when the future is created.
@@ -101,14 +101,15 @@ Create a future with:
 (defun %fcompleted (future completed-fun)
   (with-slots (promise) future
     (attach promise completed-fun))
-  nil)
+  future)
 
 (defmacro fcompleted (future (result) &body body)
   "Completion handler on the given `future`.
 
 If the `future` is already complete then the `body` executed immediately.  
 `result` represents the future result.
 `body` is executed when future completed.
+Returns the future.
 
 Example:
 

src/timeutils.lisp

@@ -15,11 +15,13 @@
   "Waits until `cond-fun' is not `nil' or `max-time' elapsed.
 This blocks the calling thread."
   (loop
-    :with wait-acc = 0
-    :unless (or (funcall cond-fun) (> wait-acc max-time))
+    :for fun-result := (funcall cond-fun)
+    :with wait-acc := 0
+    :while (and (not fun-result) (< wait-acc max-time))
       :do (progn
             (sleep sleep-time)
-            (incf wait-acc sleep-time))))
+            (incf wait-acc sleep-time))
+    :finally (return fun-result)))
 
 (define-condition ask-timeout (serious-condition)
   ((wait-time :initform nil