package plebeia

You can search for identifiers within the package.

in-package search v0.2.0

package plebeia

plebeia
- Plebeia
  - Commit
  - Commit_db
  - Commit_hash
  - Commit_tree
    
    Internal
    
    Node
    
    View
  - Context
  - Copy
  - Cursor
    
    Cursor_storage
    
    Internal
    
    Monad
    
    Infix
    
    Syntax
  - Cursor_stat
  - Cursor_tools
    
    GenTraverse
  - Data_encoding_tools
  - Debug
  - Deep
  - Diff
  - Error
  - Fs
    
    Merkle_proof
    
    Op
    
    Infix
    
    Syntax
    
    Op_lwt
    
    Infix
    
    Syntax
    
    Vc
  - Fs_impl
    
    Merkle_proof
    
    Op
    
    Loose
    
    Monad
    
    Infix
    
    Syntax
    
    Op_lwt
    
    Monad
    
    Infix
    
    Syntax
    
    Vc
  - Fs_nameenc
  - Fs_nameenc_impl
    
    Bits6
    
    Bits8
    
    Compressed
    
    Arg
    
    B
    
    Record
    
    Lock
    
    Test
    
    Compressed'
    
    Compressed''
  - Fs_tree
    
    Merkle_proof
    
    Op
    
    Infix
    
    Syntax
    
    Op_lwt
    
    Infix
    
    Syntax
    
    Vc
  - Fs_types
    
    FsError
    
    NAMEENC
    
    Name
    
    Path
  - Gen
    
    Infix
    
    Syntax
  - Hash
    
    Hasher
    
    Prefix
  - Hashcons
  - Hashfunc
    
    Blake2B
    
    A
    
    Blake3
    
    A
  - Index
    
    Unsafe
  - Info
  - Internal
  - Key
  - Limit
  - Lock
  - Log
  - Merkle_proof
    
    Tree
  - Mmap
    
    Arch64
    
    Buffer
    
    Buffer
  - Monad
    
    Make1
    
    A
    
    Infix
    
    Syntax
    
    Make2
    
    A
    
    Infix
    
    Syntax
    
    S1
    
    Infix
    
    Syntax
    
    S2
    
    Infix
    
    Syntax
  - Node
  - Node_cache
  - Node_hash
  - Node_offsets
  - Node_storage
    
    Internal
  - Node_tools
  - Node_type
    
    Fold
    
    Fold'
    
    Mapper
  - Option
    
    Infix
    
    Syntax
  - Path
  - Result
    
    Infix
    
    Syntax
  - Result_lwt
    
    Infix
    
    Syntax
  - Segment
    
    Segs
    
    Serialization
    
    StringEnc
  - Segment_int_array
    
    Bits
    
    Type
    
    Int63
    
    Internal
    
    Segs
    
    Serialization
    
    StringEnc
    
    Vector
  - Snapshot
    
    Internal
    
    Elem
    
    Stat
  - Stat
  - Storage
    
    Chunk
    
    Internal
    
    Header
    
    Stat
  - Traverse
    
    Iter
    
    Map
  - Utils
    
    Array
    
    Syntax
    
    Exn
    
    Format
    
    Int
    
    List
    
    Open
    
    Int
    
    String
  - Value
  - Vc
  - Xcstruct
plebeia.msync
- Plebeia_msync
  - Msync
    
    Lwt
plebeia.test_utils
- Test_utils
  - Do_random
    
    Deep
    
    Flat
    
    Vc
  - Dumb
  - Fs_simulation
    
    Simulation
    
    Context
    
    Map
    
    Op
    
    Infix
    
    Syntax
    
    Op_lwt
    
    Infix
    
    Syntax
    
    WithSimulation
    
    Op
    
    Monad
    
    Infix
    
    Syntax
    
    Op_lwt
    
    Infix
    
    Syntax
  - SegmentListSet
  - SegmentSet

Legend:
Library
Module
Module type
Parameter
Class
Class type

type 'a t = Fs_tree.tree -> (Fs_tree.tree * 'a, Error.t) Stdlib.result Lwt.t

Monad for asynchronous file system operations

include Monad.S1 with type 'a t := 'a t

val return : 'a -> 'a t

val bind : 'a t -> ('a -> 'b t) -> 'b t

val map : ('a -> 'b) -> 'a t -> 'b t

val mapM : ('a -> 'b t) -> 'a list -> 'b list t

val mapM_ : ('a -> unit t) -> 'a list -> unit t

val iterM : ('a -> unit t) -> 'a list -> unit t

alias of mapM_

val fold_leftM : ('a -> 'b -> 'a t) -> 'a -> 'b list -> 'a t

val parseM : ('a -> 'b list -> ('a * 'b list) t) -> 'a -> 'b list -> 'a t

module Infix : sig ... end

module Syntax : sig ... end

val lift : 'a Fs_tree.Op.t -> 'a t

Convert Op monad to Op_lwt

val lift_op : 'a Fs_tree.Op.t -> 'a t

val lift_lwt : 'a Lwt.t -> 'a t

Monad lifters

val lift_result : ('a, Error.t) Stdlib.result -> 'a t

val lift_result_lwt : ('a, Error.t) Stdlib.result Lwt.t -> 'a t

val fail : Fs_tree.error -> 'a t

Lifted versions of Op functions

val raw_cursor : Fs_tree.raw_cursor t

val copy : Fs_types.Path.t -> Fs_types.Path.t -> unit t

val cat : Fs_types.Path.t -> Value.t t

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

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

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

val compute_hash : Fs_types.Path.t -> Fs_tree.hash t

val may_forget : Fs_types.Path.t -> unit t

val get_tree : Fs_types.Path.t -> (Fs_tree.tree * Fs_tree.view) t

val set_tree : Fs_types.Path.t -> Fs_tree.tree -> unit t

val tree : Fs_tree.tree t

val do_then : (Fs_tree.tree -> unit) -> 'a t -> 'a t

val fold : 
  'a ->
  Fs_types.Path.t ->
  ('a ->
    Fs_types.Path.t ->
    Fs_tree.tree ->
    ([ `Continue | `Exit | `Up ] * 'a, Error.t) Stdlib.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

val 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_tree.tree -> ('a, Error.t) Stdlib.result Lwt.t) ->
  'a t

Folding with a depth specification

val ls : Fs_types.Path.t -> (Fs_tree.name * Fs_tree.tree) list t

List the directory specified by the path

val ls2 : 
  offset:int ->
  length:int ->
  Fs_types.Path.t ->
  (Fs_tree.name * Fs_tree.tree) list t

val count : Fs_types.Path.t -> int 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.

val run : 
  Fs_tree.tree ->
  'a t ->
  (Fs_tree.tree * 'a, Error.t) Stdlib.result Lwt.t

Monad runner