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_tools
    
    GenTraverse
  - Data_encoding_tools
  - Debug
  - Deep
  - Diff
  - Error
  - Fs
    
    Make
    
    Merkle_proof
    
    Name
    
    Op
    
    Infix
    
    Syntax
    
    Op_lwt
    
    Infix
    
    Syntax
    
    Path
    
    MakeError
    
    Path
    
    Name6bits
    
    Name8bits
    
    NameCompressed
    
    NameCompressed'
    
    NameCompressed''
    
    Path
    
    Name
  - Fs_impl
    
    Make
    
    Merkle_proof
    
    Name
    
    Op
    
    Loose
    
    Monad
    
    Infix
    
    Syntax
    
    Op_lwt
    
    Monad
    
    Infix
    
    Syntax
    
    Path
    
    Vc
    
    MakeError
    
    Path
    
    Name6bits
    
    Name8bits
    
    NameCompressed
    
    B
    
    NameCompressed'
    
    NameCompressed''
    
    Path
    
    Name
  - Fs_intf
    
    NAME
    
    PATH
    
    S
    
    Merkle_proof
    
    Op
    
    Infix
    
    Syntax
    
    Op_lwt
    
    Infix
    
    Syntax
    
    Path
    
    Vc
  - Fs_tree
    
    Make
    
    Merkle_proof
    
    Name
    
    Op
    
    Infix
    
    Syntax
    
    Op_lwt
    
    Infix
    
    Syntax
    
    Path
    
    Vc
  - 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_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
  - 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
    
    Name
    
    Op
    
    Infix
    
    Syntax
    
    Op_lwt
    
    Infix
    
    Syntax
    
    Path
    
    WithSimulation
    
    F
    
    Merkle_proof
    
    Name
    
    Op
    
    Loose
    
    Monad
    
    Infix
    
    Syntax
    
    Op_lwt
    
    Monad
    
    Infix
    
    Syntax
    
    Path
    
    Vc
    
    Name
    
    Op
    
    Monad
    
    Infix
    
    Syntax
    
    Op_lwt
    
    Infix
    
    Syntax
    
    S
    
    Context
    
    Map
    
    Op
    
    Infix
    
    Syntax
    
    Op_lwt
    
    Infix
    
    Syntax
    
    Path
  - NameStringSegment
  - SegmentListSet
  - SegmentSet

Legend:
Library
Module
Module type
Parameter
Class
Class type

include sig ... end

type 'a t = cursor -> (cursor * 'a, Plebeia.Error.t) Stdlib.result

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

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 fail : error -> 'a -> ('b, Plebeia.Error.t) Stdlib.result

val get_raw_cursor : 'a -> 'a

val raw_cursor : 'a -> ('a * 'a, 'b) Stdlib.result

val context : 'a -> 'b

val get_path : raw_cursor -> name list

val path : raw_cursor -> (raw_cursor * name list, 'a) Stdlib.result

val view : raw_cursor -> (raw_cursor * model_tree, 'a) Stdlib.result

val chdir_parent : raw_cursor -> (raw_cursor * unit, 'a) Stdlib.result

val chdir_root : raw_cursor -> (raw_cursor * unit, 'a) Stdlib.result

val seek : Path.t -> (cursor * view) t

val seek' : Map.key list -> Path.t t

val chdir : ?dig:bool -> Map.key list -> unit t

val with_pushd : 
  (raw_cursor -> (raw_cursor * 'a, 'b) Stdlib.result) ->
  raw_cursor ->
  (raw_cursor * 'a, 'b) Stdlib.result

val get : 
  Path.t ->
  cursor ->
  (cursor * (cursor * view), Plebeia.Error.t) Stdlib.result

val cat : 
  Path.t ->
  cursor ->
  (cursor * Plebeia.Value.t, Plebeia.Error.t) Stdlib.result

val write : 
  Map.key list ->
  Plebeia.Value.t ->
  cursor ->
  (raw_cursor * unit, Plebeia.Error.t) Stdlib.result

val unlink : 
  Map.key list ->
  ([> `Bud of model_tree | `Leaf of model_tree ] ->
    (unit, Plebeia.Error.t) Stdlib.result) ->
  cursor ->
  (cursor * bool, Plebeia.Error.t) Stdlib.result

val set : 
  Map.key list ->
  raw_cursor ->
  cursor ->
  (cursor * unit, Plebeia.Error.t) Stdlib.result

val copy : Path.t -> Map.key list -> unit t

val rm : 
  ?recursive:bool ->
  ?ignore_error:bool ->
  Path.t ->
  cursor ->
  (cursor * bool, Plebeia.Error.t) Stdlib.result

val rmdir : 
  ?ignore_error:bool ->
  Path.t ->
  cursor ->
  (cursor * bool, Plebeia.Error.t) Stdlib.result

val ls_no_lwt : Path.t -> (Name.t * cursor) list t

val do_then : 
  (cursor -> 'b) ->
  'a t ->
  cursor ->
  (cursor * 'a, Plebeia.Error.t) Stdlib.result

val run : 'a -> ('a -> 'b) -> 'b

val compute_hash : 'a -> ('a * string, 'b) Stdlib.result

val may_forget : 'a -> ('a * unit, 'b) Stdlib.result