Remove lwt from low level finalise

src/irmin-pack/unix/async.ml

@@ -71,14 +71,14 @@ module Unix = struct
         { pid; status = `Running }
 
   let status_of_process_outcome = function
-    | Lwt_unix.WSIGNALED x when x = Sys.sigkill ->
+    | Unix.WSIGNALED x when x = Sys.sigkill ->
         (* x is actually -7; -7 is the Sys.sigkill definition (not the OS' 9 as
            might be expected) *)
         `Success
         (* the child is killing itself when it's done *)
-    | Lwt_unix.WSIGNALED n -> `Failure (Fmt.str "Signaled %d" n)
-    | Lwt_unix.WEXITED n -> `Failure (Fmt.str "Exited %d" n)
-    | Lwt_unix.WSTOPPED n -> `Failure (Fmt.str "Stopped %d" n)
+    | Unix.WSIGNALED n -> `Failure (Fmt.str "Signaled %d" n)
+    | Unix.WEXITED n -> `Failure (Fmt.str "Exited %d" n)
+    | Unix.WSTOPPED n -> `Failure (Fmt.str "Stopped %d" n)
 
   let cancel t =
     let () =
@@ -108,10 +108,10 @@ module Unix = struct
   let await t =
     match t.status with
     | `Running ->
-        let+ pid, status = Lwt_unix.waitpid [] t.pid in
+        let pid, status = Unix.waitpid [] t.pid in
         let s = status_of_process_outcome status in
         Exit.remove pid;
         t.status <- s;
         s
-    | #outcome as s -> Lwt.return s
+    | #outcome as s -> s
 end

src/irmin-pack/unix/async_intf.ml

@@ -28,7 +28,7 @@ module type S = sig
   val async : (unit -> unit) -> t
   (** Start a task. *)
 
-  val await : t -> [> outcome ] Lwt.t
+  val await : t -> [> outcome ]
   (** If running, wait for a task to finish and return its outcome.
 
       If not running, return the oucome of the task. *)

src/irmin-pack/unix/ext.ml

@@ -291,7 +291,7 @@ module Maker (Config : Conf.S) = struct
               | Some { gc; _ } ->
                   if t.during_batch then
                     Lwt.return_error `Gc_forbidden_during_batch
-                  else Gc.finalise ~wait gc
+                  else Gc.finalise ~wait gc |> Lwt.return
             in
             match result with
             | Ok (`Finalised _ as x) ->

src/irmin-pack/unix/gc.ml

@@ -547,7 +547,7 @@ module Make (Args : Args) = struct
 
   let finalise ~wait t =
     match t.stats with
-    | Some stats -> Lwt.return_ok (`Finalised stats)
+    | Some stats -> Ok (`Finalised stats)
     | None -> (
         let go status =
           let start = t.elapsed () in
@@ -614,14 +614,14 @@ module Make (Args : Args) = struct
                 let () = Lwt.wakeup_later t.resolver err in
                 err
           in
-          Lwt.return result
+          result
         in
         if wait then
-          let* status = Async.await t.task in
+          let status = Async.await t.task in
           go status
         else
           match Async.status t.task with
-          | `Running -> Lwt.return_ok `Running
+          | `Running -> Ok `Running
           | status -> go status)
 
   let on_finalise t f =

src/irmin-pack/unix/gc_intf.ml

@@ -109,9 +109,7 @@ module type S = sig
   (** Creates and starts a new GC process. *)
 
   val finalise :
-    wait:bool ->
-    t ->
-    ([> `Running | `Finalised of stats ], Args.Errs.t) result Lwt.t
+    wait:bool -> t -> ([> `Running | `Finalised of stats ], Args.Errs.t) result
   (** [finalise ~wait t] returns the state of the GC process.
 
       If [wait = true], the call will block until GC finishes. *)

src/irmin-pack/unix/s.ml

@@ -81,9 +81,9 @@ module type S = sig
         Finalising consists of mutating [repo] so that it points to the new file
         and to flush the internal caches that could be referencing GCed objects.
 
-        If [wait = true] (the default), the call blocks until the GC process
-        finishes. If [wait = false], finalisation will occur if the process has
-        ended.
+        If [wait = true] (the default), the calling process blocks until the GC
+        process finishes. If [wait = false], finalisation will occur if the
+        process has ended.
 
         If there are no running GCs, the call is a no-op and it returns [`Idle].
 
@@ -119,7 +119,7 @@ module type S = sig
         messages should be used only for informational purposes, like logging. *)
 
     val wait : repo -> (stats option, msg) result Lwt.t
-    (** [wait repo] blocks until GC is finished or is idle.
+    (** [wait repo] blocks the process until GC is finished or is idle.
 
         If a GC finalises, its stats are returned.