package plebeia

  1. Overview
  2. Docs
package plebeia
Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module Fs.Op_lwtSource

Sourcetype 'a t = Fs.cursor -> (Fs.cursor * 'a, Error.t) result Lwt.t

Monad for asynchronous file system operations

include Monad.S1 with type 'a t := 'a t
Sourceval return : 'a -> 'a t
Sourceval bind : 'a t -> ('a -> 'b t) -> 'b t
Sourceval map : ('a -> 'b) -> 'a t -> 'b t
Sourceval mapM : ('a -> 'b t) -> 'a list -> 'b list t
Sourceval mapM_ : ('a -> unit t) -> 'a list -> unit t
Sourceval iterM : ('a -> unit t) -> 'a list -> unit t

alias of mapM_

Sourceval fold_leftM : ('a -> 'b -> 'a t) -> 'a -> 'b list -> 'a t
Sourceval parseM : ('a -> 'b list -> ('a * 'b list) t) -> 'a -> 'b list -> 'a t
Sourcemodule Infix : sig ... end
Sourcemodule Syntax : sig ... end
Sourceval lift : 'a Fs.Op.t -> 'a t

Convert Op monad to Op_lwt

Sourceval lift_op : 'a Fs.Op.t -> 'a t
Sourceval lift_lwt : 'a Lwt.t -> 'a t
Sourceval lift_result : ('a, Error.t) Result.t -> 'a t
Sourceval lift_result_lwt : ('a, Error.t) Result_lwt.t -> 'a t
Sourceval fail : Fs.error -> 'a t

Fail with the given error

Sourceval raw_cursor : Fs.raw_cursor t

Get the current underlying cursor

Sourceval chdir_parent : unit t

Moves the cursor up 1 directory level. If the cursor is already at the root, it does nothing.

Sourceval chdir_root : unit t

Moves the cursor up to the root directory. If the cursor is already at the root, it does nothing.

Sourceval chdir : ?dig:bool -> Fs_types.Path.t -> unit t

Moves the cursor to a sub-directory specified by the path. If dig=true, subdirectories are created if necessary.

Get the current path of the cursor

File and directory access. It returns the current cursor and its view.

Sourceval set : Fs_types.Path.t -> Fs.cursor -> unit t

Set the tree pointed by the cursor at the specified path.

The path must not be empty.

Note: there is no loop detection. It is the user's responsibility not to introduce a loop by this function.

copy src dst sets the tree at src to dst. dst must not be empty.

If the copy creates a loop, the function fails.

Regular file read access.

Sourceval write : Fs_types.Path.t -> Value.t -> unit t

Create or update a regular file. Directories are created if necessary. The path must not be empty.

Sourceval rm : ?recursive:bool -> ?ignore_error:bool -> Fs_types.Path.t -> bool t

Remove a regular file or a directory, then returns Ok true. The path must not be empty.

recursive=false : fails when the target is a directory recursive=true : removes the target recursively if it is a directory ignore_error=false : fails when the target does not exist ignore_error=true : does not fail even if the target does not exist

Returns true if the target is really removed. Returns false if the target does not exist.

Sourceval rmdir : ?ignore_error:bool -> Fs_types.Path.t -> bool t

Recursive removal of a directory The path must not be empty.

ignore_error=false : fails when the target does not exist ignore_error=true : does not fail even if the target does not exist

Returns true if the target is really removed. Returns false if the target does not exist.

Sourceval compute_hash : Fs.hash t

Compute the Merkle hash of the cursor

Sourceval may_forget : unit t

Clear the memory cache of the tree under the current cursor, if it is already persisted on the disk.

Sourceval do_then : (Fs.cursor -> unit) -> 'a t -> 'a t

do_then f op executes f against the current cursor, then performs op.

Sourceval run : Fs.cursor -> 'a t -> (Fs.cursor * 'a, Error.t) result Lwt.t

Monad runner

Sourceval fold : 'a -> Fs_types.Path.t -> ('a -> Fs_types.Path.t -> Fs.cursor -> ([ `Continue | `Exit | `Up ] * 'a, Error.t) result Lwt.t) -> 'a t

folding

  • `Continue: if the item is a directory, its items are recursively folded
  • `Up: if the item is a directory, its items are skipped
  • `Exit: terminate the folding immediately and returns the accumulator as the final result of fold
Sourceval fold' : ?depth:[ `Eq of int | `Ge of int | `Gt of int | `Le of int | `Lt of int ] -> 'a -> Fs_types.Path.t -> ('a -> Fs_types.Path.t -> Fs.cursor -> ('a, Error.t) result Lwt.t) -> 'a t

folding with a depth specification

List the directory specified by the path

Sourceval ls2 : offset:int -> length:int -> Fs_types.Path.t -> (Fs.name * Fs.cursor) list t
Sourceval count : Fs_types.Path.t -> int option t

count the leaves and buds, loading nodes on demand.

count path, if path points to a Bud, it returns the number of the leaves and buds under path.

OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct