NAME

       StdLabels.Bytes - no description

Module

       Module   StdLabels.Bytes

Documentation

       Module Bytes
        : (module BytesLabels)

       val length : bytes -> int

       Return the length (number of bytes) of the argument.

       val get : bytes -> int -> char

       get s n returns the byte at index n in argument s .

       Raise Invalid_argument if n not a valid index in s .

       val set : bytes -> int -> char -> unit

       set s n c modifies s in place, replacing the byte at index n with c .

       Raise Invalid_argument if n is not a valid index in s .

       val create : int -> bytes

       create  n  returns a new byte sequence of length n . The sequence is uninitialized and contains arbitrary
       bytes.

       Raise Invalid_argument if n < 0 or n > Sys.max_string_length .

       val make : int -> char -> bytes

       make n c returns a new byte sequence of length n , filled with the byte c .

       Raise Invalid_argument if n < 0 or n > Sys.max_string_length .

       val init : int -> f:(int -> char) -> bytes

       init n f returns a fresh byte sequence of length n , with character i initialized to the result of f i .

       Raise Invalid_argument if n < 0 or n > Sys.max_string_length .

       val empty : bytes

       A byte sequence of size 0.

       val copy : bytes -> bytes

       Return a new byte sequence that contains the same bytes as the argument.

       val of_string : string -> bytes

       Return a new byte sequence that contains the same bytes as the given string.

       val to_string : bytes -> string

       Return a new string that contains the same bytes as the given byte sequence.

       val sub : bytes -> pos:int -> len:int -> bytes

       sub s start len returns a new byte sequence of length len , containing the subsequence of s  that  starts
       at position start and has length len .

       Raise Invalid_argument if start and len do not designate a valid range of s .

       val sub_string : bytes -> int -> int -> string

       Same as sub but return a string instead of a byte sequence.

       val fill : bytes -> pos:int -> len:int -> char -> unit

       fill s start len c modifies s in place, replacing len characters with c , starting at start .

       Raise Invalid_argument if start and len do not designate a valid range of s .

       val blit : src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit

       blit  src  srcoff  dst  dstoff  len  copies  len  bytes from sequence src , starting at index srcoff , to
       sequence dst , starting at index dstoff . It works correctly even if  src  and  dst  are  the  same  byte
       sequence, and the source and destination intervals overlap.

       Raise  Invalid_argument if srcoff and len do not designate a valid range of src , or if dstoff and len do
       not designate a valid range of dst .

       val concat : sep:bytes -> bytes list -> bytes

       concat sep sl concatenates the list of byte sequences sl , inserting  the  separator  byte  sequence  sep
       between each, and returns the result as a new byte sequence.

       val iter : f:(char -> unit) -> bytes -> unit

       iter  f  s  applies function f in turn to all the bytes of s .  It is equivalent to f (get s 0); f (get s
       1); ...; f (get s (length s - 1)); () .

       val iteri : f:(int -> char -> unit) -> bytes -> unit

       Same as Bytes.iter , but the function is applied to the index of the byte as first argument and the  byte
       itself as second argument.

       val map : f:(char -> char) -> bytes -> bytes

       map f s applies function f in turn to all the bytes of s and stores the resulting bytes in a new sequence
       that is returned as the result.

       val mapi : f:(int -> char -> char) -> bytes -> bytes

       mapi  f  s  calls  f  with  each  character of s and its index (in increasing index order) and stores the
       resulting bytes in a new sequence that is returned as the result.

       val trim : bytes -> bytes

       Return a copy of the argument, without leading and trailing whitespace. The bytes regarded as  whitespace
       are the ASCII characters ' ' , '\012' , '\n' , '\r' , and '\t' .

       val escaped : bytes -> bytes

       Return  a  copy  of  the argument, with special characters represented by escape sequences, following the
       lexical conventions of OCaml.

       val index : bytes -> char -> int

       index s c returns the index of the first occurrence of byte c in s .

       Raise Not_found if c does not occur in s .

       val rindex : bytes -> char -> int

       rindex s c returns the index of the last occurrence of byte c in s .

       Raise Not_found if c does not occur in s .

       val index_from : bytes -> int -> char -> int

       index_from s i c returns the index of the first occurrence of byte c in s after position i .  Bytes.index
       s c is equivalent to Bytes.index_from s 0 c .

       Raise Invalid_argument if i is not a valid position in s .  Raise Not_found if c  does  not  occur  in  s
       after position i .

       val rindex_from : bytes -> int -> char -> int

       rindex_from s i c returns the index of the last occurrence of byte c in s before position i+1 .  rindex s
       c is equivalent to rindex_from s (Bytes.length s - 1) c .

       Raise  Invalid_argument  if  i+1 is not a valid position in s .  Raise Not_found if c does not occur in s
       before position i+1 .

       val contains : bytes -> char -> bool

       contains s c tests if byte c appears in s .

       val contains_from : bytes -> int -> char -> bool

       contains_from s start c tests if byte c appears in s after position start .  contains s c  is  equivalent
       to contains_from s 0 c .

       Raise Invalid_argument if start is not a valid position in s .

       val rcontains_from : bytes -> int -> char -> bool

       rcontains_from s stop c tests if byte c appears in s before position stop+1 .

       Raise Invalid_argument if stop < 0 or stop+1 is not a valid position in s .

       val uppercase : bytes -> bytes

       Return  a  copy  of  the argument, with all lowercase letters translated to uppercase, including accented
       letters of the ISO Latin-1 (8859-1) character set.

       val lowercase : bytes -> bytes

       Return a copy of the argument, with all uppercase letters translated  to  lowercase,  including  accented
       letters of the ISO Latin-1 (8859-1) character set.

       val capitalize : bytes -> bytes

       Return a copy of the argument, with the first byte set to uppercase.

       val uncapitalize : bytes -> bytes

       Return a copy of the argument, with the first byte set to lowercase.

       type t = bytes

       An alias for the type of byte sequences.

       val compare : t -> t -> int

       The  comparison  function  for byte sequences, with the same specification as Pervasives.compare .  Along
       with the type t , this function compare allows the module Bytes to be passed as argument to the  functors
       Set.Make and Map.Make .

2016-02-07                                           source:                                 StdLabels.Bytes(3o)