package piaf

You can search for identifiers within the package.

in-package search v0.2.0

package piaf

piaf
- Piaf
  - Body
  - Cert
  - Client
    
    Oneshot
  - Config
  - Cookies
    
    Cookie
    
    Set_cookie
  - Error
  - Form
    
    Multipart
  - Headers
    
    Well_known
    
    HTTP1
    
    HTTP2
    
    Values
  - IOVec
  - Method
  - Request
  - Request_info
  - Response
    
    Upgrade
  - Scheme
  - Server
    
    Command
    
    Config
    
    HTTPS
    
    Error_response
    
    Handler
    
    Middleware
    
    Service
  - Status
  - Versions
    
    ALPN
    
    HTTP
    
    Raw
    
    TLS
  - Ws
    
    Descriptor
    
    Message
piaf.multipart
- Multipart
  - Pp
piaf.multipart_form
- Piaf_multipart_form
  - Content_disposition
    
    Decoder
    
    Encoder
  - Content_encoding
    
    Decoder
    
    Encoder
  - Content_type
    
    Decoder
    
    Encoder
    
    Parameters
    
    Map
    
    Subtype
    
    Type
  - Field
    
    Decoder
    
    Encoder
  - Field_name
    
    Decoder
    
    Encoder
    
    Map
    
    Set
  - Header
    
    Decoder
    
    Encoder
  - Multipart_form
    
    Content_disposition
    
    Content_encoding
    
    Content_type
    
    Parameters
    
    Map
    
    Subtype
    
    Type
    
    Field
    
    Field_name
    
    Header
    
    Decoder
  - Rfc2046
piaf.sendfile
- Sendfile
piaf.stream
- Piaf_stream

Legend:
Library
Module
Module type
Parameter
Class
Class type

include module type of struct include Prettym end

type ppf = Prettym.ppf

Abstract data corresponding to the encoder state and all its machinery.

type 'a t = ppf -> 'a -> ppf

The type for formatters of values of type 'a.

type ('ty, 'v) order = ('ty, 'v) Prettym.order

val keval_order : (ppf -> 'v) -> ppf -> ('ty, 'v) order -> 'ty

val break : indent:int -> len:int -> ('v, 'v) order

break ~indent ~len tries to add len spaces into the current line. If it fails - if we overflow the current line - we insert a new_line and fill the beginning of the new line with indent space characters.

val fws : ('v, 'v) order

fws is a specialization of break with indent = 1 and spaces = 1. This is the most used token to express an opportunity to break the line and be conform to RFC 822 and the folding-whitespace token.

val spaces : int -> ('v, 'v) order

spaces n is a specialization of break with spaces = n.

val cut : ('v, 'v) order

cut gives an opportunity to add a break line without indentation and spaces.

val const : 'a t -> 'a -> ('v, 'v) order

const pp v serialize v with pp.

val atom : 'a t -> ('a -> 'v, 'v) order

atom pp expects a value 'a and serialize it with pp.

val a : ('a t -> 'a -> 'v, 'v) order

a expects a serializer pp and a value to serialize it then.

val (!!) : 'a t -> ('a -> 'v, 'v) order

Alias of atom.

val ($) : 'a t -> 'a -> ('v, 'v) order

Alias of const.

val new_line : ('v, 'v) order

new_line inserts a new line regardless how many bytes the current line has.

val tbox : int -> ('v, 'v) order

tbox indent creates a new box to indent any contents inside with indent spaces.

val bbox : ('v, 'v) order

bbox creates a new box to indent any contents at the current position of the serializer.

val box : ('v, 'v) order

val close : ('v, 'v) order

close closes any boxes.

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

using f pp apply f on the value and use pp then to serialize the result.

val string : string t

string permits to serialize a string.

val bytes : Bytes.t t

bytes permits to serialize a bytes.

val bigstring : Bigstringaf.t t

bigstring permits to serialize a bigstring.

val breakable : string t

breakable permits to serialize a breakable string. If the given string is larger than the margin, the serializer is able to break the string to fit under the margin instead of to wait an opportunity (such as cut or fws) to break the line.

val char : char t

char permits to serialize a char.

val list : sep:('x t * 'x) -> 'v t -> 'v list t

list ~sep pp permits to serialize a list of values which can be serialized with pp. Between each values, we apply sep.

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

type ('ty, 'v) fmt = ('ty, 'v) Prettym.fmt =

| [] : ('v, 'v) fmt
| :: : ('x, 'v) order * ('v, 'r) fmt -> ('x, 'r) fmt

val concat : ('a, 'b) fmt -> ('b, 'c) fmt -> ('a, 'c) fmt

val keval : (ppf -> 'v) -> ppf -> ('ty, 'v) fmt -> 'ty

val eval : ppf -> ('ty, ppf) fmt -> 'ty

module Buffer = Prettym.Buffer

module IOVec = Prettym.IOVec

val io_buffer_size : int

val create : 
  ?margin:int ->
  ?new_line:string ->
  emitter:(IOVec.t list -> int) ->
  int ->
  ppf

create ?margin ?new_line ~emitter weight creates a serializer bounded to weight elements. The serializer is limiter to emit margin bytes per lines and break the line with new_line (default to "\r\n").

emitter is called when the serializer is full. It gives to user what it needs to transmit to the output and it asks how many bytes the user was able to transmit.

val is_empty : ppf -> bool

is_empty ppf returns true if the serializer is empty. Otherwise, it returns false.

val flush : ppf -> ppf

flush ppf enforces the serializer to call the internal emitter to transmit out what is serialized - even if ppf is not full.

val kflush : (ppf -> 'v) -> ppf -> 'v

kflush is flush with a kontinuation.

val to_string : ?margin:int -> ?new_line:string -> 'a t -> 'a -> string

to_string ?margin ?new_line pp v serializes a value v with the serializer pp into a string.

val to_stream : 
  ?margin:int ->
  ?new_line:string ->
  'a t ->
  'a ->
  unit ->
  string option

to_stream ?margin ?new_line pp v serializes a value v with the serializer pp and it returns a function unit -> string option to transmit out the result chunk by chunk of the serialization.

val noop : ('a -> unit -> 'a) * unit

val field : Prettym.ppf -> Piaf_multipart_form__Field.field -> Prettym.ppf

val header : ppf -> Piaf_multipart_form__Field.field list -> ppf