manpagez: man pages & more
man StdLabels.Bytes(3)
Home | html | info | man
StdLabels.Bytes(3)               OCaml library              StdLabels.Bytes(3)




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  argu-
       ment.



       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) char-
       acter 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) char-
       acter 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 .





OCamldoc                          2014-10-18                StdLabels.Bytes(3)

ocaml 4.02.1 - Generated Tue Oct 21 06:29:09 CDT 2014
© manpagez.com 2000-2024
Individual documents may contain additional copyright information.