package b0

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Encoders
Decoders
Codecs
Base codecs
1. Magic numbers
2. Bytes
3. unit
4. bool
5. int
6. int64
7. string
8. Fpath.t
9. list
10. option
11. result
12. Set.t
13. Hash.t
14. Time.span
15. Time.cpu_span

package b0

b0
- B0_build
- B0_cli
  - Arg
- B0_cmdlet
  - Env
  - Map
  - Set
- B0_def
  - Make
    
    Map
    
    Set
    
    V
  - S
    
    Map
    
    Set
  - Scope
  - VALUE
- B0_dir
- B0_driver
  - Cli
  - Compile
  - Conf
  - Env
  - Exit
- B0_file
- B0_meta
  - Key
- B0_pack
  - Map
  - Set
- B0_unit
  - Action
  - Map
  - Set
b0.b0
- B0_b0
  - Cli
  - Def
- B0_cmd_build
- B0_cmd_cmd
- B0_cmd_cmdlet
- B0_cmd_delete
- B0_cmd_file
- B0_cmd_list
- B0_cmd_log
- B0_cmd_pack
- B0_cmd_root
- B0_cmd_scope
- B0_cmd_unit
- B0_main
b0.b00
- B00
  - Env
  - Memo
  - Store
  - Tool
- B000
  - Exec
  - File_cache
  - Guard
  - Op
    
    Copy
    
    Delete
    
    Map
    
    Mkdir
    
    Notify
    
    Read
    
    Set
    
    Spawn
    
    Wait_files
    
    Write
  - Reviver
  - Trash
- B000_conv
  - Op
b0.b00.kit
- B00_base64
- B00_cli
  - Arg
  - B0_std
  - Exit
  - File_cache
  - Memo
    
    Log
  - Op
- B00_cmark
- B00_editor
  - Env
- B00_fexts
- B00_findex
- B00_github
  - Auth
  - Issue
  - Pages
  - Release
  - Repo
- B00_htmlg
  - At
    
    Name
  - El
- B00_http
  - Http
  - Httpr
  - Uri
- B00_jsoo
- B00_lines
- B00_ocaml
  - Archive
  - Cobj
    
    Map
    
    Set
  - Compile
  - Conf
  - Crunch
  - Lib
    
    Name
    
    Map
    
    Set
    
    Resolver
  - Link
  - Mod
    
    Name
    
    Ref
    
    Map
    
    Set
    
    Src
    
    Deps
  - Ocamlpath
  - Tool
- B00_odoc
  - Compile
    
    Dep
    
    Writes
  - Html
    
    Dep
    
    Writes
  - Html_fragment
  - Support_files
    
    Writes
  - Theme
- B00_os
- B00_pager
  - Env
- B00_pdf_viewer
  - Env
- B00_rsync
- B00_serialk_json
  - Json
  - Jsong
  - Jsonq
- B00_serialk_sexp
  - Sexp
  - Sexpg
  - Sexpq
- B00_serialk_text
  - Tdec
  - Tloc
- B00_trace
  - Compilation_database
  - Trace_event
- B00_vcs
  - Git
  - Hg
- B00_www_browser
  - Env
b0.kit
- B0_expect
  - Outcome
- B0_jsoo
- B0_kit
  - V000
- B0_ocaml
  - Meta
- B0_ocaml_eco
- B0_opam
  - Cmdlet
  - File
  - Meta
- B0_release
  - Cmdlet
  - Meta
- B0_srcs
b0.std
- B0_std
  - Bincode
  - Char
    
    Ascii
  - Cmd
  - Fmt
  - Fpath
    
    Map
    
    Set
  - Fut
    
    Syntax
  - Hash
    
    T
    
    Xxh3_128
    
    Xxh3_64
  - List
  - Log
  - Mtime
    
    Span
  - Os
    
    Cmd
    
    Cpu
    
    Time
    
    Dir
    
    Env
    
    Exit
    
    Fd
    
    File
    
    Mtime
    
    Path
  - Result
    
    Syntax
  - Rqueue
  - String
    
    Ascii
    
    Map
    
    Set
  - Tty
  - Type
    
    Id

Legend:
Library
Module
Module type
Parameter
Class
Class type

Binary coding of values.

Encoders

type 'a enc = Buffer.t -> 'a -> unit

The type for encoders of values of type 'a. The call enc b v must encode v in buffer b.

Decoders

type 'a dec = string -> int -> int * 'a

The type for decoders of values of type 'a. The call dec s i must decode a value in s starting at i (which may be String.length s) and return the index of the byte in s after the decoded value (this can be String.length s). The function must raise Failure in case of error, use err for this.

val err : int -> ('a, Format.formatter, unit, 'b) format4 -> 'a

err i fmt reports a decoding error for position i formatted according to fmt.

val err_byte : kind:string -> int -> int -> 'a

err_byte ~kind i byte report an error for the unexpected byte byte at position i for decoding a value of type kind.

val get_byte : string -> int -> int

get_byte s i is the byte s.[i]. Does not check that i is in bounds.

val dec_eoi : string -> int -> unit

dec_eoi s i asserts that i is exactly at the end of input, i.e. String.length s.

Codecs

type 'a t

The type for encoding and decoding values of type 'a.

val v : 'a enc -> 'a dec -> 'a t

v enc dec is a decoder using enc to encode and dec to decode.

val enc : 'a t -> 'a enc

enc c is c's encoder.

val dec : 'a t -> 'a dec

dec c is c's decoder.

val to_string : ?buf:Buffer.t -> 'a t -> 'a -> string

encode c v encodes v using c (and buf if provided, it is the client's duty to reset it before an encoding).

val of_string : ?file:Fpath.t -> 'a t -> string -> ('a, string) result

of_string ~file c s decodes a value from s using c and dec_eoi. In case of error file is mentioned in the error message (defaults to Os.File.dash).

Base codecs

Magic numbers

val enc_magic : string -> unit enc

enc_magic m encodes string m as a magic number.

val dec_magic : string -> unit dec

dec_magic m decodes magic number m and returns the next index to read from.

val magic : string -> unit t

magic m is a codec for magic number m.

Bytes

val enc_byte : int enc

enc_byte is a byte encoder. Values larger than 0xFF are truncated.

val dec_byte : kind:string -> int dec

dec_byte decodes a byte for a value of type kind (used with err_byte)

val byte : kind:string -> int t

byte codecs a byte for a value of type kind (used with err_byte).

`unit`

val enc_unit : unit enc

enc_unit encodes unit.

val dec_unit : unit dec

dec_unit decodes unit.

val unit : unit t

unti is a codec for unit.

`bool`

val enc_bool : bool enc

enc_bool encodes a boolean.

val dec_bool : bool dec

dec_bool decodes a boolean.

val bool : bool t

bool is a codec for bool.

`int`

val enc_int : int enc

enc_int encodes an integer. The encoding does not depend on Sys.word_size.

val dec_int : int dec

dec_int dedodes an integer. Warning. An int encoded on a 64-bit platform may end up being truncated if read back on 32-bit platform.

val int : int t

int is a codec for integers.

`int64`

val enc_int64 : int64 enc

enc_int64 encodes an int64.

val dec_int64 : int64 dec

dec_int64 decodes an int64.

val int64 : int64 t

int64 is a coded for int64.

`string`

val enc_string : string enc

enc_string encodes a string.

val dec_string : string dec

dec_string decodes a string.

val string : string t

string is a codec for string.

`Fpath.t`

val enc_fpath : Fpath.t enc

enc_fpath encodes an Fpath.t.

val dec_fpath : Fpath.t dec

dec_fpath decodes an Fpath.t.

val fpath : Fpath.t t

fpath is a coded for !Fpath.t.

`list`

val enc_list : 'a enc -> 'a list enc

enc_list enc encodes the elements of a list using enc.

val dec_list : 'a dec -> 'a list dec

dec_list dec decodes the lements of a list using dec.

val list : 'a t -> 'a list t

list c is a codec for lists of elements coded with c.

`option`

val enc_option : 'a enc -> 'a option enc

enc_option enc encodes an option using enc for the Some case value.

val dec_option : 'a dec -> 'a option dec

dec_option dec decodes an option using dec for the Some case value.

val option : 'a t -> 'a option t

option c is a codec for options with Some elements coded with c.

`result`

val enc_result : ok:'a enc -> error:'b enc -> ('a, 'b) result enc

enc_result ~ok ~error encodes a result value with the corresponding case encoders.

val dec_result : ok:'a dec -> error:'b dec -> ('a, 'b) result dec

dec_result ~ok ~error decodes a result value with the corresponding case decoders.

val result : ok:'a t -> error:'b t -> ('a, 'b) result t

result is a codec for results with Ok elements coded with ok and Error elements coded with error.

`Set.t`

val enc_set : 
  (module Set.S with type elt = 'a and type t = 'set) ->
  'a enc ->
  'set enc

enc_set (module S) enc encodes S.t sets using enc for its elements.

val dec_set : 
  (module Set.S with type elt = 'a and type t = 'set) ->
  'a dec ->
  'set dec

dec_set (module S) dec decodes S.t sets with dec for its elements.

val set : (module Set.S with type elt = 'a and type t = 'set) -> 'a t -> 'set t

set (module S) c is a codec for S.t sets using c for its elements.

`Hash.t`

val enc_hash : Hash.t enc

enc_hash encodes a Hash.t.

val dec_hash : Hash.t dec

dec_hash decodes a Hash.t.

val hash : Hash.t t

hash is a codec for Hash.t

`Time.span`

val enc_time_span : Mtime.span enc

enc_time_span encodes a Mtime.span.

val dec_time_span : Mtime.span dec

dec_time_span decodes a Mtime.span.

val time_span : Mtime.span t

time_span is a codec for Mtime.span.

`Time.cpu_span`

val enc_cpu_time_span : Os.Cpu.Time.span enc

enc_cpu_time_span encodes a Os.Cpu.Time.span.

val dec_cpu_time_span : Os.Cpu.Time.span dec

dec_cpu_time_span decodes a Os.Cpu.Time.span.

val cpu_time_span : Os.Cpu.Time.span t

cpu_time_span is a codec for Os.Cpu.Time.span.