I am confused by Mirage_kv.S.batch

[Mindy <mindy@xxxxxxxxxxxxxxxxxxx>]

Hi all,

I've been working on a block-backed Mirage_kv.S implementation inspired 
by (and largely interoperable with) littlefs[1] . I'm approaching 
readiness for release, but there remains one large unimplemented piece 
of Mirage_kv.S : `batch`. The relevant excerpt of mirage_kv.mli is 
reproduced below:
```

  val batch: t -> ?retries:int -> (t -> 'a Lwt.t) -> 'a Lwt.t
  (** [batch t f] run [f] in batch. Ensure the durability of
     operations.

      Since a batch is applied at once, the readings inside a batch
     will return the state before the entire batch. Concurrent
     operations will not affect other ones executed during the batch.

      Batch applications can fail to apply if other operations are
     happening concurrently. In case of failure, [f] will run again
     with the most recent version of [t]. The result is
     [Error `Too_many_retries] if [f] is run for more then [retries] 
attemps
     (default is [13]). *)
```

I confess to being uncertain how to implement the "readings inside a 
batch" portion of this. Given an arbitrary function `t -> 'a Lwt.t`, how 
is the implementer expected to differentiate between operations within 
such a function, possibly implemented as a series of sequential binds?
Currently my implementation simply runs the given function against the 
filesystem, but this is clearly semantically wrong given the explanation 
in the docstring.
I see `wodan` implements this by differentiating between a `t` used for 
read operations and one used for write operations[2] , but I lack the 
understanding of `wodan` necessary to understand how this can work for a 
`t -> 'a Lwt.t` that mixes read and write operations, which I think the 
docstring implies to be an expected use of `batch`.
Thanks for your help,

Mindy

[1] https://github.com/littlefs-project/littlefs

[2] 
https://github.com/mirage/wodan/blob/main/src/wodan-irmin/wodan_irmin.ml#L345