refactor: add [{Fiber,Memo}.of_thunk_apply]

src/memo/memo.mli

@@ -57,8 +57,15 @@ val of_reproducible_fiber : 'a Fiber.t -> 'a t
     therefore be re-executed on every build run. *)
 val of_non_reproducible_fiber : 'a Fiber.t -> 'a t
 
+(** Convert a thunk to a Memo computation, making sure the thunk runs in the context of
+    the Memo computation rather than in the current context.
+
+    [of_thunk f] is equivalent to [return () >> f] but is more explicit. *)
 val of_thunk : (unit -> 'a t) -> 'a t
 
+(** Like [of_thunk] but accepts functions of any argument. *)
+val of_thunk_apply : ('a -> 'b t) -> 'a -> 'b t
+
 (** Combine results of two computations executed in sequence. *)
 val both : 'a t -> 'b t -> ('a * 'b) t
 

vendor/fiber/src/core.ml

@@ -245,6 +245,7 @@ module Var = struct
 end
 
 let of_thunk f k = f () k
+let of_thunk_apply f x k = f x k
 
 module O = struct
   let ( >>> ) a b k = a (fun () -> b k)

vendor/fiber/src/fiber.mli

@@ -18,12 +18,15 @@ type 'a fiber := 'a t
 (** Create a fiber that has already terminated. *)
 val return : 'a -> 'a t
 
-(** Converts a thunk to a fiber, making sure the thunk runs in the context of
-    the fiber (rather than applied in the current context).
+(** Convert a thunk to a fiber, making sure the thunk runs in the context of the fiber
+    rather than in the current context.
 
-    Equivalent to [(>>=) (return ())], but more explicit. *)
+    [of_thunk f] is equivalent to [return () >>= f] but is more explicit. *)
 val of_thunk : (unit -> 'a t) -> 'a t
 
+(** Like [of_thunk] but accepts functions of any argument. *)
+val of_thunk_apply : ('a -> 'b t) -> 'a -> 'b t
+
 (** Fiber that never completes. *)
 val never : 'a t