Remove #:keep-scheduler? arg

* fibers.scm (run-fibers): Remove #:keep-scheduler? argument; instead,
  only destroy schedulers that we create.
* fibers.texi (Using Fibers): Update run-fibers docs.
* web/server/fibers.scm (server-read): Adapt.

3 files changed, 27 insertions, 32 deletions

diff --git a/fibers.scm b/fibers.scm
index 43ad403..03a0214 100644
--- a/fibers.scm
+++ b/fibers.scm
@@ -41,26 +41,26 @@
      (resume-on-writable-fd (port-read-wait-fd port) fiber))))
 
 (define* (run-fibers #:optional (init #f)
-                     #:key (hz 0) (scheduler (make-scheduler))
-                     (install-suspendable-ports? #t)
-                     (keep-scheduler?
-                      (->bool (scheduler-kernel-thread scheduler))))
+                     #:key (hz 0) (scheduler #f)
+                     (install-suspendable-ports? #t))
   (when install-suspendable-ports? (install-suspendable-ports!))
-  (with-scheduler
-   scheduler
-   (parameterize ((current-read-waiter wait-for-readable)
-                  (current-write-waiter wait-for-writable))
-     (with-interrupts
-      hz yield-current-fiber
-      (lambda ()
-        (let ((ret (make-atomic-box #f)))
-          (spawn-fiber (lambda ()
-                         (call-with-values (or init values)
-                           (lambda vals (atomic-box-set! ret vals))))
-                       scheduler)
-          (run-scheduler scheduler (lambda () (atomic-box-ref ret)))
-          (unless keep-scheduler? (destroy-scheduler scheduler))
-          (apply values (atomic-box-ref ret))))))))
+  (let ((keep-scheduler? (->bool scheduler))
+        (scheduler (or scheduler (make-scheduler))))
+    (with-scheduler
+     scheduler
+     (parameterize ((current-read-waiter wait-for-readable)
+                    (current-write-waiter wait-for-writable))
+       (with-interrupts
+        hz yield-current-fiber
+        (lambda ()
+          (let ((ret (make-atomic-box #f)))
+            (spawn-fiber (lambda ()
+                           (call-with-values (or init values)
+                             (lambda vals (atomic-box-set! ret vals))))
+                         scheduler)
+            (run-scheduler scheduler (lambda () (atomic-box-ref ret)))
+            (unless keep-scheduler? (destroy-scheduler scheduler))
+            (apply values (atomic-box-ref ret)))))))))
 
 (define (current-fiber-scheduler)
   (match (current-fiber)
diff --git a/fibers.texi b/fibers.texi
index 7ed3ae9..b7dc7a7 100644
--- a/fibers.texi
+++ b/fibers.texi
@@ -405,7 +405,7 @@ import the @code{(fibers)} module:
 To create a new fibers scheduler and run it in the current Guile
 thread, use @code{run-fibers}.
 
-@defun run-fibers [init-thunk=@code{#f}] [#:install-suspendable-ports?=@code{#t}] [#:scheduler=@code{(make-scheduler)}] [#:keep-scheduler?] [#:hz=0]
+@defun run-fibers [init-thunk=@code{#f}] [#:install-suspendable-ports?=@code{#t}] [#:scheduler=@code{#f}] [#:hz=0]
 Run @var{init-thunk} within a fiber in a fresh scheduler, blocking
 until the scheduler has no more runnable fibers.  Return the value(s)
 returned by the call to @var{init-thunk}.
@@ -428,10 +428,12 @@ details on suspendable ports.  If for some reason you want port reads
 or writes to prevent other fibers from running, pass @code{#f} as the
 @code{#:install-suspendable-ports?} keyword argument.
 
-By default, @code{run-fibers} will create a fresh scheduler.  If you
-happen to have a pre-existing scheduler (because you used the
-internals interface to create one), you can pass it to
-@code{run-fibers} using the @code{#:scheduler} keyword argument.
+By default, @code{run-fibers} will create a fresh scheduler, and
+destroy it after @code{run-fibers} finishes.  If you happen to have a
+pre-existing scheduler (because you used the internals interface to
+create one), you can pass it to @code{run-fibers} using the
+@code{#:scheduler} keyword argument.  In that case the scheduler will
+not be destroyed when @code{run-fibers} finishes.
 
 By default @var{hz} is 0, indicating that running fibers should never
 be preempted, and should instead run until they need to wait on some
@@ -440,12 +442,6 @@ cooperative.  Pass a higher value to cause computationally expensive
 tasks to be preempted if possible.  Note that preemption will only
 occur if the fiber can actually be suspended; @xref{Barriers}, for
 more information.
-
-The scheduler will be destroyed when @code{run-fibers} finishes,
-unless the scheduler was already ``current'' (@pxref{Internals}).  If
-you need to keep the scheduler, either make sure it is current or
-explicitly pass @code{#t} as the @code{#:keep-scheduler?} keyword
-argument.
 @end defun
 
 @defun spawn-fiber thunk [scheduler=@code{(require-current-scheduler)}] @
diff --git a/web/server/fibers.scm b/web/server/fibers.scm
index f8d6ae2..fac0e00 100644
--- a/web/server/fibers.scm
+++ b/web/server/fibers.scm
@@ -158,8 +158,7 @@
    (server-have-request-prompt server)
    (lambda ()
      (run-fibers #:scheduler (server-scheduler server)
-                 #:install-suspendable-ports? #f
-                 #:keep-scheduler? #t))
+                 #:install-suspendable-ports? #f))
    (lambda (k client request body)
      (values client request body))))