Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
Pervasives(3)			   OCamldoc			 Pervasives(3)

NAME
       Pervasives - The	initially opened module.

Module
       Module	Pervasives

Documentation
       Module Pervasives
	: sig end

       The initially opened module.

       This module provides the	basic operations over the built-in types (num-
       bers, booleans, byte sequences, strings,	exceptions, references,	lists,
       arrays, input-output channels, ...).

       This  module  is	automatically opened at	the beginning of each compila-
       tion.  All components of	this module can	therefore be referred by their
       short name, without prefixing them by Pervasives	.

       === Exceptions ===

       val raise : exn -> 'a

       Raise the given exception value

       val raise_notrace : exn -> 'a

       A faster	version	raise which does not record the	backtrace.

       Since 4.02.0

       val invalid_arg : string	-> 'a

       Raise exception Invalid_argument	with the given string.

       val failwith : string ->	'a

       Raise exception Failure with the	given string.

       exception Exit

       The  Exit  exception is not raised by any library function.  It is pro-
       vided for use in	your programs.

       === Comparisons ===

       val (=) : 'a -> 'a -> bool

       e1 = e2 tests for structural equality of	e1 and e2  .   Mutable	struc-
       tures  (e.g. references and arrays) are equal if	and only if their cur-
       rent contents are structurally equal, even if the two  mutable  objects
       are  not	 the same physical object.  Equality between functional	values
       raises Invalid_argument .  Equality between cyclic data structures  may
       not terminate.

       val (__)	: 'a ->	'a -> bool

       Negation	of Pervasives.(=) .

       val (_) : 'a -> 'a -> bool

       See Pervasives.(>=) .

       val (_) : 'a -> 'a -> bool

       See Pervasives.(>=) .

       val (_=)	: 'a ->	'a -> bool

       See Pervasives.(>=) .

       val (_=)	: 'a ->	'a -> bool

       Structural  ordering functions. These functions coincide	with the usual
       orderings over integers,	characters, strings, byte sequences and	float-
       ing-point  numbers, and extend them to a	total ordering over all	types.
       The ordering is compatible with ( = ) . As in the case of ( = ) , muta-
       ble structures are compared by contents.	 Comparison between functional
       values raises Invalid_argument .	 Comparison between cyclic  structures
       may not terminate.

       val compare : 'a	-> 'a -> int

       compare	x  y returns 0 if x is equal to	y , a negative integer if x is
       less than y , and a positive integer if x is greater than y .  The  or-
       dering  implemented by compare is compatible with the comparison	predi-
       cates = , < and > defined above,	 with one difference on	the  treatment
       of  the float value Pervasives.nan .  Namely, the comparison predicates
       treat nan as different from any other float  value,  including  itself;
       while  compare  treats  nan  as equal to	itself and less	than any other
       float value.  This treatment of nan ensures that	compare	defines	a  to-
       tal ordering relation.

       compare applied to functional values may	raise Invalid_argument .  com-
       pare applied to cyclic structures may not terminate.

       The compare function can	be used	as the comparison function required by
       the  Set.Make  and  Map.Make functors, as well as the List.sort and Ar-
       ray.sort	functions.

       val min : 'a -> 'a -> 'a

       Return the smaller of the two arguments.	 The result is unspecified  if
       one of the arguments contains the float value nan .

       val max : 'a -> 'a -> 'a

       Return  the greater of the two arguments.  The result is	unspecified if
       one of the arguments contains the float value nan .

       val (==)	: 'a ->	'a -> bool

       e1 == e2	tests for physical equality of e1 and e2 .  On	mutable	 types
       such as references, arrays, byte	sequences, records with	mutable	fields
       and objects with	mutable	instance variables, e1 == e2 is	 true  if  and
       only  if	 physical modification of e1 also affects e2 .	On non-mutable
       types, the behavior of (	== ) is	implementation-dependent; however,  it
       is guaranteed that e1 ==	e2 implies compare e1 e2 = 0 .

       val (!=)	: 'a ->	'a -> bool

       Negation	of Pervasives.(==) .

       === Boolean operations ===

       val not : bool -> bool

       The boolean negation.

       val (__)	: bool -> bool -> bool

       The boolean 'and'. Evaluation is	sequential, left-to-right: in e1 && e2
       , e1 is evaluated first,	and if it returns false	, e2 is	not  evaluated
       at all.

       val (_) : bool -> bool -> bool

       Deprecated.

       Pervasives.(&&) should be used instead.

       val (||)	: bool -> bool -> bool

       The  boolean 'or'. Evaluation is	sequential, left-to-right: in e1 || e2
       , e1 is evaluated first,	and if it returns true , e2 is	not  evaluated
       at all.

       val (or)	: bool -> bool -> bool

       Deprecated.

       Pervasives.(||) should be used instead.

       === Debugging ===

       val __LOC__ : string

       __LOC__	returns	 the  location at which	this expression	appears	in the
       file currently being parsed by the compiler, with  the  standard	 error
       format of OCaml:	"File %S, line %d, characters %d-%d".

       Since 4.02.0

       val __FILE__ : string

       __FILE__	 returns  the  name  of	the file currently being parsed	by the
       compiler.

       Since 4.02.0

       val __LINE__ : int

       __LINE__	returns	the line number	at which this  expression  appears  in
       the file	currently being	parsed by the compiler.

       Since 4.02.0

       val __MODULE__ :	string

       __MODULE__ returns the module name of the file being parsed by the com-
       piler.

       Since 4.02.0

       val __POS__ : string * int * int	* int

       __POS__ returns a tuple (file,lnum,cnum,enum) ,	corresponding  to  the
       location	 at  which this	expression appears in the file currently being
       parsed by the compiler.	file is	the current filename,  lnum  the  line
       number, cnum the	character position in the line and enum	the last char-
       acter position in the line.

       Since 4.02.0

       val __LOC_OF__ :	'a -> string * 'a

       __LOC_OF__ expr returns a pair (loc, expr) where	loc is the location of
       expr in the file	currently being	parsed by the compiler,	with the stan-
       dard error format of OCaml: "File %S, line %d, characters %d-%d".

       Since 4.02.0

       val __LINE_OF__ : 'a -> int * 'a

       __LINE__	expr returns a pair (line, expr) , where line is the line num-
       ber  at	which  the expression expr appears in the file currently being
       parsed by the compiler.

       Since 4.02.0

       val __POS_OF__ :	'a -> (string *	int * int * int) * 'a

       __POS_OF__ expr returns a pair  (loc,expr)  ,  where  loc  is  a	 tuple
       (file,lnum,cnum,enum)  corresponding  to	 the location at which the ex-
       pression	expr appears in	the file currently being parsed	 by  the  com-
       piler.	file  is  the current filename,	lnum the line number, cnum the
       character position in the line and enum the last	character position  in
       the line.

       Since 4.02.0

       === Composition operators ===

       val (|_)	: 'a ->	('a -> 'b) -> 'b

       Reverse-application operator: x |> f |> g is exactly equivalent to g (f
       (x)) .

       Since 4.01

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

       Application operator: g @@ f @@ x is exactly equivalent to g (f (x)) .

       Since 4.01

       === Integer arithmetic ===

       === Integers are	31 bits	wide (or 63 bits on 64-bit  processors).   All
       operations  are	taken  modulo 2^{31} (or 2^{63}).  They	do not fail on
       overflow. ===

       val (~-)	: int -> int

       Unary negation. You can also write - e instead of ~- e .

       val (~+)	: int -> int

       Unary addition. You can also write + e instead of ~+ e .

       Since 3.12.0

       val succ	: int -> int

       succ x is x + 1 .

       val pred	: int -> int

       pred x is x - 1 .

       val (+) : int ->	int -> int

       Integer addition.

       val (-) : int ->	int -> int

       Integer subtraction.

       val ( * ) : int -> int -> int

       Integer multiplication.

       val (/) : int ->	int -> int

       Integer division.  Raise	Division_by_zero if the	second argument	is  0.
       Integer	division  rounds  the  real  quotient of its arguments towards
       zero.  More precisely, if x >= 0	and y >	0 , x /	y is the greatest  in-
       teger less than or equal	to the real quotient of	x by y .  Moreover, (-
       x) / y =	x / (- y) = - (x / y) .

       val (mod) : int -> int -> int

       Integer remainder.  If y	is not zero, the result	of x mod  y  satisfies
       the following properties: x = (x	/ y) * y + x mod y and abs(x mod y) <=
       abs(y) -	1 .  If	y = 0 ,	x mod y	raises Division_by_zero	.  Note	that x
       mod y is	negative only if x < 0 .  Raise	Division_by_zero if y is zero.

       val abs : int ->	int

       Return the absolute value of the	argument.  Note	that this may be nega-
       tive if the argument is min_int .

       val max_int : int

       The greatest representable integer.

       val min_int : int

       The smallest representable integer.

       === Bitwise operations ===

       val (land) : int	-> int -> int

       Bitwise logical and.

       val (lor) : int -> int -> int

       Bitwise logical or.

       val (lxor) : int	-> int -> int

       Bitwise logical exclusive or.

       val lnot	: int -> int

       Bitwise logical negation.

       val (lsl) : int -> int -> int

       n lsl m shifts n	to the left by m bits.	The result is unspecified if m
       <  0  or	m >= bitsize , where bitsize is	32 on a	32-bit platform	and 64
       on a 64-bit platform.

       val (lsr) : int -> int -> int

       n lsr m shifts n	to the right by	m bits.	 This is a logical shift:  ze-
       roes are	inserted regardless of the sign	of n .	The result is unspeci-
       fied if m < 0 or	m >= bitsize .

       val (asr) : int -> int -> int

       n asr m shifts n	to the right by	m bits.	 This is an arithmetic	shift:
       the sign	bit of n is replicated.	 The result is unspecified if m	< 0 or
       m >= bitsize .

       === Floating-point arithmetic OCaml's floating-point numbers follow the
       IEEE  754  standard,  using double precision (64	bits) numbers.	Float-
       ing-point operations never raise	an exception on	 overflow,  underflow,
       division	 by  zero,  etc. Instead, special IEEE numbers are returned as
       appropriate, such as infinity for 1.0 /.	0.0, neg_infinity for -1.0  /.
       0.0,  and  nan  ('not  a	number') for 0.0 /. 0.0. These special numbers
       then propagate through floating-point computations as expected: for in-
       stance,	1.0  /.	infinity is 0.0, and any arithmetic operation with nan
       as argument returns nan as result. ===

       val (~-.)  : float -> float

       Unary negation. You can also write -. e instead of ~-. e	.

       val (~+.)  : float -> float

       Unary addition. You can also write +. e instead of ~+. e	.

       Since 3.12.0

       val (+.)	 : float -> float -> float

       Floating-point addition

       val (-.)	 : float -> float -> float

       Floating-point subtraction

       val ( *.	) : float -> float -> float

       Floating-point multiplication

       val (/.)	 : float -> float -> float

       Floating-point division.

       val ( **	) : float -> float -> float

       Exponentiation.

       val sqrt	: float	-> float

       Square root.

       val exp : float -> float

       Exponential.

       val log : float -> float

       Natural logarithm.

       val log10 : float -> float

       Base 10 logarithm.

       val expm1 : float -> float

       expm1 x computes	exp x -. 1.0  ,	 giving	 numerically-accurate  results
       even if x is close to 0.0 .

       Since 3.12.0

       val log1p : float -> float

       log1p  x	 computes  log(1.0  +.	x) (natural logarithm),	giving numeri-
       cally-accurate results even if x	is close to 0.0	.

       Since 3.12.0

       val cos : float -> float

       Cosine.	Argument is in radians.

       val sin : float -> float

       Sine.  Argument is in radians.

       val tan : float -> float

       Tangent.	 Argument is in	radians.

       val acos	: float	-> float

       Arc cosine.  The	argument must fall within the range [-1.0, 1.0]	.  Re-
       sult is in radians and is between 0.0 and pi .

       val asin	: float	-> float

       Arc  sine.   The	argument must fall within the range [-1.0, 1.0]	.  Re-
       sult is in radians and is between -pi/2 and pi/2	.

       val atan	: float	-> float

       Arc tangent.  Result is in radians and is between -pi/2 and pi/2	.

       val atan2 : float -> float -> float

       atan2 y x returns the arc tangent of y /. x .  The signs	of x and y are
       used to determine the quadrant of the result.  Result is	in radians and
       is between -pi and pi .

       val hypot : float -> float -> float

       hypot x y returns sqrt(x	*. x + y *. y) , that is, the  length  of  the
       hypotenuse  of  a  right-angled triangle	with sides of length x and y ,
       or, equivalently, the distance of the point (x,y) to origin.  If	one of
       x or y is infinite, returns infinity even if the	other is nan .

       Since 4.00.0

       val cosh	: float	-> float

       Hyperbolic cosine.  Argument is in radians.

       val sinh	: float	-> float

       Hyperbolic sine.	 Argument is in	radians.

       val tanh	: float	-> float

       Hyperbolic tangent.  Argument is	in radians.

       val ceil	: float	-> float

       Round  above  to	 an  integer  value.  ceil f returns the least integer
       value greater than or equal to f	.  The result is returned as a float.

       val floor : float -> float

       Round below to an integer value.	 floor f returns the greatest  integer
       value less than or equal	to f .	The result is returned as a float.

       val abs_float : float ->	float

       abs_float f returns the absolute	value of f .

       val copysign : float -> float ->	float

       copysign	 x  y  returns	a  float whose absolute	value is that of x and
       whose sign is that of y .  If x is nan ,	returns	nan .  If y is	nan  ,
       returns either x	or -. x	, but it is not	specified which.

       Since 4.00.0

       val mod_float : float ->	float -> float

       mod_float  a  b returns the remainder of	a with respect to b .  The re-
       turned value is a -. n *. b , where n is	the quotient a	/.  b  rounded
       towards zero to an integer.

       val frexp : float -> float * int

       frexp  f	 returns  the  pair of the significant and the exponent	of f .
       When f is zero, the significant x and the exponent n of f are equal  to
       zero.   When f is non-zero, they	are defined by f = x *.	2 ** n and 0.5
       <= x < 1.0 .

       val ldexp : float -> int	-> float

       ldexp x n returns x *. 2	** n .

       val modf	: float	-> float * float

       modf f returns the pair of the fractional and integral part of f	.

       val float : int -> float

       Same as Pervasives.float_of_int .

       val float_of_int	: int -> float

       Convert an integer to floating-point.

       val truncate : float -> int

       Same as Pervasives.int_of_float .

       val int_of_float	: float	-> int

       Truncate	the given floating-point number	to an integer.	The result  is
       unspecified if the argument is nan or falls outside the range of	repre-
       sentable	integers.

       val infinity : float

       Positive	infinity.

       val neg_infinity	: float

       Negative	infinity.

       val nan : float

       A special floating-point	value denoting the result of an	undefined  op-
       eration	such  as  0.0 /. 0.0 .	Stands for 'not	a number'.  Any	float-
       ing-point operation with	nan as argument	returns	nan as result.	As for
       floating-point  comparisons,  = , < , <=	, > and	>= return false	and <>
       returns true if one or both of their arguments is nan .

       val max_float : float

       The largest positive finite value of type float .

       val min_float : float

       The smallest positive, non-zero,	non-denormalized value of type float .

       val epsilon_float : float

       The difference between  1.0  and	 the  smallest	exactly	 representable
       floating-point number greater than 1.0 .

       type fpclass =
	| FP_normal  (*	Normal number, none of the below
	*)
	| FP_subnormal	(* Number very close to	0.0, has reduced precision
	*)
	| FP_zero  (* Number is	0.0 or -0.0
	*)
	| FP_infinite  (* Number is positive or	negative infinity
	*)
	| FP_nan  (* Not a number: result of an	undefined operation
	*)

       The five	classes	of floating-point numbers, as determined by the	Perva-
       sives.classify_float function.

       val classify_float : float -> fpclass

       Return the class	of the given floating-point number: normal, subnormal,
       zero, infinite, or not a	number.

       ===  String  operations	More  string operations	are provided in	module
       String. ===

       val (^) : string	-> string -> string

       String concatenation.

       === Character operations	More character operations are provided in mod-
       ule Char. ===

       val int_of_char : char -> int

       Return the ASCII	code of	the argument.

       val char_of_int : int ->	char

       Return the character with the given ASCII code.	Raise Invalid_argument
       char_of_int if the argument is outside the range	0--255.

       === Unit	operations ===

       val ignore : 'a -> unit

       Discard the value of its	argument and return () .   For	instance,  ig-
       nore(f x) discards the result of	the side-effecting function f .	 It is
       equivalent to f x; () , except that the latter may generate a  compiler
       warning;	writing	ignore(f x) instead avoids the warning.

       === String conversion functions ===

       val string_of_bool : bool -> string

       Return  the  string representation of a boolean.	As the returned	values
       may be shared, the user should not modify them directly.

       val bool_of_string : string -> bool

       Convert	the  given  string  to	a  boolean.   Raise   Invalid_argument
       bool_of_string if the string is not true	or false .

       val bool_of_string_opt :	string -> bool option

       Convert	the  given  string to a	boolean.  Return None if the string is
       not true	or false .

       Since 4.05

       val string_of_int : int -> string

       Return the string representation	of an integer, in decimal.

       val int_of_string : string -> int

       Convert the given string	to an integer.	The string is read in  decimal
       (by  default),  in  hexadecimal (if it begins with 0x or	0X ), in octal
       (if it begins with 0o or	0O ), or in binary (if it begins with 0b or 0B
       ).   The	_ (underscore) character can appear anywhere in	the string and
       is ignored.  Raise Failure int_of_string	if the given string is	not  a
       valid  representation  of an integer, or	if the integer represented ex-
       ceeds the range of integers representable in type int .

       val int_of_string_opt : string -> int option

       Same as int_of_string , but returs None instead of raising.

       Since 4.05

       val string_of_float : float -> string

       Return the string representation	of a floating-point number.

       val float_of_string : string -> float

       Convert the given string	to a float.  The string	is read	in decimal (by
       default)	 or in hexadecimal (marked by 0x or 0X ).  The format of deci-
       mal floating-point numbers is [-] dd.ddd	 (e|E)	[+|-]  dd  ,  where  d
       stands  for  a decimal digit.  The format of hexadecimal	floating-point
       numbers is [-] 0(x|X) hh.hhh (p|P) [+|-]	dd , where  h  stands  for  an
       hexadecimal  digit  and d for a decimal digit.  In both cases, at least
       one of the integer and fractional parts must  be	 given;	 the  exponent
       part  is	optional.  The _ (underscore) character	can appear anywhere in
       the string and is ignored.  Depending on	the execution platforms, other
       representations	of  floating-point numbers can be accepted, but	should
       not be relied upon.  Raise Failure float_of_string if the given	string
       is not a	valid representation of	a float.

       val float_of_string_opt : string	-> float option

       Same as float_of_string , but returns None instead of raising.

       Since 4.05

       === Pair	operations ===

       val fst : 'a * 'b -> 'a

       Return the first	component of a pair.

       val snd : 'a * 'b -> 'b

       Return the second component of a	pair.

       ===  List  operations More list operations are provided in module List.
       ===

       val (@) : 'a list -> 'a list -> 'a list

       List concatenation.  Not	tail-recursive (length of the first argument).

       === Input/output	Note: all input/output functions can  raise  Sys_error
       when the	system calls they invoke fail. ===

       type in_channel

       The type	of input channel.

       type out_channel

       The type	of output channel.

       val stdin : in_channel

       The standard input for the process.

       val stdout : out_channel

       The standard output for the process.

       val stderr : out_channel

       The standard error output for the process.

       === Output functions on standard	output ===

       val print_char :	char ->	unit

       Print a character on standard output.

       val print_string	: string -> unit

       Print a string on standard output.

       val print_bytes : bytes -> unit

       Print a byte sequence on	standard output.

       Since 4.02.0

       val print_int : int -> unit

       Print an	integer, in decimal, on	standard output.

       val print_float : float -> unit

       Print a floating-point number, in decimal, on standard output.

       val print_endline : string -> unit

       Print a string, followed	by a newline character,	on standard output and
       flush standard output.

       val print_newline : unit	-> unit

       Print a newline character on standard output, and flush	standard  out-
       put. This can be	used to	simulate line buffering	of standard output.

       === Output functions on standard	error ===

       val prerr_char :	char ->	unit

       Print a character on standard error.

       val prerr_string	: string -> unit

       Print a string on standard error.

       val prerr_bytes : bytes -> unit

       Print a byte sequence on	standard error.

       Since 4.02.0

       val prerr_int : int -> unit

       Print an	integer, in decimal, on	standard error.

       val prerr_float : float -> unit

       Print a floating-point number, in decimal, on standard error.

       val prerr_endline : string -> unit

       Print  a	 string, followed by a newline character on standard error and
       flush standard error.

       val prerr_newline : unit	-> unit

       Print a newline character on standard error, and	flush standard error.

       === Input functions on standard input ===

       val read_line : unit -> string

       Flush standard output, then read	characters from	standard input until a
       newline	character  is encountered. Return the string of	all characters
       read, without the newline character at the end.

       val read_int : unit -> int

       Flush standard output, then read	one line from standard input and  con-
       vert  it	to an integer. Raise Failure int_of_string if the line read is
       not a valid representation of an	integer.

       val read_int_opt	: unit -> int option

       Same as read_int_opt , but returs None instead of raising.

       Since 4.05

       val read_float :	unit ->	float

       Flush standard output, then read	one line from standard input and  con-
       vert  it	 to a floating-point number.  The result is unspecified	if the
       line read is not	a valid	representation of a floating-point number.

       val read_float_opt : unit -> float option

       Flush standard output, then read	one line from standard input and  con-
       vert  it	 to a floating-point number.  Returns None if the line read is
       not a valid representation of a floating-point number.

       Since 4.05.0

       === General output functions ===

       type open_flag =
	| Open_rdonly  (* open for reading.
	*)
	| Open_wronly  (* open for writing.
	*)
	| Open_append  (* open for appending: always write at end of file.
	*)
	| Open_creat  (* create	the file if it does not	exist.
	*)
	| Open_trunc  (* empty the file	if it already exists.
	*)
	| Open_excl  (*	fail if	Open_creat and the file	already	exists.
	*)
	| Open_binary  (* open in binary mode (no conversion).
	*)
	| Open_text  (*	open in	text mode (may perform conversions).
	*)
	| Open_nonblock	 (* open in non-blocking mode.
	*)

       Opening modes for Pervasives.open_out_gen and Pervasives.open_in_gen .

       val open_out : string ->	out_channel

       Open the	named file for writing,	and return a  new  output  channel  on
       that  file,  positioned at the beginning	of the file. The file is trun-
       cated to	zero length if it already exists. It is	created	if it does not
       already exists.

       val open_out_bin	: string -> out_channel

       Same as Pervasives.open_out , but the file is opened in binary mode, so
       that no translation takes place during  writes.	On  operating  systems
       that  do	 not distinguish between text mode and binary mode, this func-
       tion behaves like Pervasives.open_out .

       val open_out_gen	: open_flag list -> int	-> string -> out_channel

       open_out_gen mode perm filename opens the named file  for  writing,  as
       described  above.  The  extra argument mode specifies the opening mode.
       The extra argument perm specifies the file  permissions,	 in  case  the
       file  must be created.  Pervasives.open_out and Pervasives.open_out_bin
       are special cases of this function.

       val flush : out_channel -> unit

       Flush the buffer	associated with	the given output  channel,  performing
       all pending writes on that channel.  Interactive	programs must be care-
       ful about flushing standard output and  standard	 error	at  the	 right
       time.

       val flush_all : unit -> unit

       Flush all open output channels; ignore errors.

       val output_char : out_channel ->	char ->	unit

       Write the character on the given	output channel.

       val output_string : out_channel -> string -> unit

       Write the string	on the given output channel.

       val output_bytes	: out_channel -> bytes -> unit

       Write the byte sequence on the given output channel.

       Since 4.02.0

       val output : out_channel	-> bytes -> int	-> int -> unit

       output  oc  buf	pos len	writes len characters from byte	sequence buf ,
       starting	at offset pos ,	to the given output channel oc	.   Raise  In-
       valid_argument  output if pos and len do	not designate a	valid range of
       buf .

       val output_substring : out_channel -> string -> int -> int -> unit

       Same as output but take a string	as argument  instead  of  a  byte  se-
       quence.

       Since 4.02.0

       val output_byte : out_channel ->	int -> unit

       Write one 8-bit integer (as the single character	with that code)	on the
       given output channel. The given integer is taken	modulo 256.

       val output_binary_int : out_channel -> int -> unit

       Write one integer in binary format (4 bytes, big-endian)	on  the	 given
       output channel.	The given integer is taken modulo 2^{32.  The only re-
       liable way to read it back is through  the  Pervasives.input_binary_int
       function. The format is compatible across all machines for a given ver-
       sion of OCaml.

       val output_value	: out_channel -> 'a -> unit

       Write the representation	of a structured	value of any type to  a	 chan-
       nel.  Circularities  and	sharing	inside the value are detected and pre-
       served. The object can be read back,  by	 the  function	Pervasives.in-
       put_value . See the description of module Marshal for more information.
       Pervasives.output_value is equivalent  to  Marshal.to_channel  with  an
       empty list of flags.

       val seek_out : out_channel -> int -> unit

       seek_out	 chan pos sets the current writing position to pos for channel
       chan . This works only for regular files. On files of other kinds (such
       as terminals, pipes and sockets), the behavior is unspecified.

       val pos_out : out_channel -> int

       Return  the  current  writing position for the given channel.  Does not
       work on channels	opened with the	Open_append flag (returns  unspecified
       results).

       val out_channel_length :	out_channel -> int

       Return the size (number of characters) of the regular file on which the
       given channel is	opened.	 If the	channel	is opened on a	file  that  is
       not a regular file, the result is meaningless.

       val close_out : out_channel -> unit

       Close  the given	channel, flushing all buffered write operations.  Out-
       put functions raise a Sys_error exception when they are	applied	 to  a
       closed  output  channel,	 except	close_out and flush , which do nothing
       when applied to an already closed channel.   Note  that	close_out  may
       raise  Sys_error	if the operating system	signals	an error when flushing
       or closing.

       val close_out_noerr : out_channel -> unit

       Same as close_out , but ignore all errors.

       val set_binary_mode_out : out_channel ->	bool ->	unit

       set_binary_mode_out oc true sets	the channel  oc	 to  binary  mode:  no
       translations  take  place  during output.  set_binary_mode_out oc false
       sets the	channel	oc to text mode: depending on  the  operating  system,
       some  translations  may	take place during output.  For instance, under
       Windows,	end-of-lines will be translated	from \n	to \r\n	.  This	 func-
       tion  has no effect under operating systems that	do not distinguish be-
       tween text mode and binary mode.

       === General input functions ===

       val open_in : string -> in_channel

       Open the	named file for reading,	and return a new input channel on that
       file, positioned	at the beginning of the	file.

       val open_in_bin : string	-> in_channel

       Same  as	Pervasives.open_in , but the file is opened in binary mode, so
       that no translation takes place during reads. On	operating systems that
       do not distinguish between text mode and	binary mode, this function be-
       haves like Pervasives.open_in .

       val open_in_gen : open_flag list	-> int -> string -> in_channel

       open_in_gen mode	perm filename opens the	named file for reading,	as de-
       scribed	above.	The  extra arguments mode and perm specify the opening
       mode   and   file   permissions.	   Pervasives.open_in	 and	Perva-
       sives.open_in_bin are special cases of this function.

       val input_char :	in_channel -> char

       Read  one character from	the given input	channel.  Raise	End_of_file if
       there are no more characters to read.

       val input_line :	in_channel -> string

       Read characters from the	given input channel, until a newline character
       is  encountered.	 Return	the string of all characters read, without the
       newline character at the	end.  Raise End_of_file	if the end of the file
       is reached at the beginning of line.

       val input : in_channel -> bytes -> int -> int ->	int

       input  ic buf pos len reads up to len characters	from the given channel
       ic , storing them in byte sequence buf ,	starting at  character	number
       pos  .	It returns the actual number of	characters read, between 0 and
       len (inclusive).	 A return value	of 0 means that	the end	 of  file  was
       reached.	 A return value	between	0 and len exclusive means that not all
       requested len characters	were read, either because no  more  characters
       were  available	at  that  time,	or because the implementation found it
       convenient to do	a partial read;	input must be called again to read the
       remaining  characters,  if  desired.  (See also Pervasives.really_input
       for reading exactly len characters.)  Exception Invalid_argument	 input
       is raised if pos	and len	do not designate a valid range of buf .

       val really_input	: in_channel ->	bytes -> int ->	int -> unit

       really_input  ic	 buf  pos  len	reads len characters from channel ic ,
       storing them in byte sequence buf , starting at character number	pos  .
       Raise  End_of_file  if the end of file is reached before	len characters
       have been read.	Raise Invalid_argument really_input if pos and len  do
       not designate a valid range of buf .

       val really_input_string : in_channel -> int -> string

       really_input_string ic len reads	len characters from channel ic and re-
       turns them in a new string.  Raise End_of_file if the end  of  file  is
       reached before len characters have been read.

       Since 4.02.0

       val input_byte :	in_channel -> int

       Same as Pervasives.input_char , but return the 8-bit integer represent-
       ing the character.  Raise End_of_file if	an end of file was reached.

       val input_binary_int : in_channel -> int

       Read an integer encoded in binary format	(4 bytes, big-endian) from the
       given   input   channel.	  See  Pervasives.output_binary_int  .	 Raise
       End_of_file if an end of	file was reached while reading the integer.

       val input_value : in_channel -> 'a

       Read the	representation of a structured value, as  produced  by	Perva-
       sives.output_value , and	return the corresponding value.	 This function
       is identical to Marshal.from_channel ; see the  description  of	module
       Marshal for more	information, in	particular concerning the lack of type
       safety.

       val seek_in : in_channel	-> int -> unit

       seek_in chan pos	sets the current reading position to pos  for  channel
       chan  . This works only for regular files. On files of other kinds, the
       behavior	is unspecified.

       val pos_in : in_channel -> int

       Return the current reading position for the given channel.

       val in_channel_length : in_channel -> int

       Return the size (number of characters) of the regular file on which the
       given  channel  is  opened.  If the channel is opened on	a file that is
       not a regular file, the result is meaningless.  The returned size  does
       not  take  into	account	 the end-of-line translations that can be per-
       formed when reading from	a channel opened in text mode.

       val close_in : in_channel -> unit

       Close the given channel.	 Input functions raise a  Sys_error  exception
       when  they  are	applied	 to  a closed input channel, except close_in ,
       which does nothing when applied to an already closed channel.

       val close_in_noerr : in_channel -> unit

       Same as close_in	, but ignore all errors.

       val set_binary_mode_in :	in_channel -> bool -> unit

       set_binary_mode_in ic true sets the  channel  ic	 to  binary  mode:  no
       translations  take  place  during  input.  set_binary_mode_out ic false
       sets the	channel	ic to text mode: depending on  the  operating  system,
       some  translations  may	take  place during input.  For instance, under
       Windows,	end-of-lines will be translated	from \r\n to \n	.  This	 func-
       tion  has no effect under operating systems that	do not distinguish be-
       tween text mode and binary mode.

       === Operations on large files ===

       module LargeFile	: sig end

       Operations on large files.  This	sub-module provides 64-bit variants of
       the  channel  functions	that manipulate	file positions and file	sizes.
       By representing positions and sizes by 64-bit integers  (type  int64  )
       instead	of regular integers (type int ), these alternate functions al-
       low operating on	files whose sizes are greater than max_int .

       === References ===

       type 'a ref = {

       mutable contents	: 'a ;
	}

       The type	of references (mutable indirection cells) containing  a	 value
       of type 'a .

       val ref : 'a -> 'a ref

       Return a	fresh reference	containing the given value.

       val (!)	: 'a ref -> 'a

       !r  returns  the	current	contents of reference r	.  Equivalent to fun r
       -> r.contents .

       val (:=)	: 'a ref -> 'a -> unit

       r := a stores the value of a in reference r .  Equivalent to fun	r v ->
       r.contents <- v .

       val incr	: int ref -> unit

       Increment  the integer contained	in the given reference.	 Equivalent to
       fun r ->	r := succ !r .

       val decr	: int ref -> unit

       Decrement the integer contained in the given reference.	Equivalent  to
       fun r ->	r := pred !r .

       === Result type ===

       type ('a, 'b) result =
	| Ok of	'a
	| Error	of 'b

       Since 4.03.0

       === Operations on format	strings	===

       ===  Format  strings are	character strings with special lexical conven-
       tions that defines the functionality of	formatted  input/output	 func-
       tions.  Format strings are used to read data with formatted input func-
       tions from module Scanf and to print data with formatted	 output	 func-
       tions from modules Printf and Format.  Format strings are made of three
       kinds of	entities: - conversions	specifications,	introduced by the spe-
       cial  character	'%' followed by	one or more characters specifying what
       kind of argument	to read	or print, - formatting indications, introduced
       by  the special character '@' followed by one or	more characters	speci-
       fying how to read or print the argument,	- plain	 characters  that  are
       regular	characters  with  usual	 lexical conventions. Plain characters
       specify string literals to be read in the input or printed in the  out-
       put.  There is an additional lexical rule to escape the special charac-
       ters '%'	and '@'	in format strings: if a	special	 character  follows  a
       '%'  character,	it is treated as a plain character. In other words, %%
       is considered as	a plain	'%' and	%@ as a	plain '@'.  For	more  informa-
       tion  about conversion specifications and formatting indications	avail-
       able, read the documentation of modules Scanf, Printf and Format. ===

       === Format strings have a general and highly polymorphic	type ('a,  'b,
       'c,  'd,	'e, 'f)	format6.  The two simplified types, format and format4
       below are included for backward compatibility with earlier releases  of
       OCaml.	The  meaning of	format string type parameters is as follows: -
       'a is the type of the parameters	of the	format	for  formatted	output
       functions  (printf-style	 functions); 'a	is the type of the values read
       by the format for formatted input functions (scanf-style	functions).  -
       'b  is  the  type of input source for formatted input functions and the
       type of output target for formatted output functions.  For printf-style
       functions   from	 module	 Printf,  'b  is  typically  out_channel;  for
       printf-style functions from module Format, 'b is	typically  Format.for-
       matter;	for  scanf-style  functions from module	Scanf, 'b is typically
       Scanf.Scanning.in_channel.  Type	argument 'b is also the	 type  of  the
       first argument given to user's defined printing functions for %a	and %t
       conversions, and	user's defined reading functions for %r	conversion.  -
       'c  is  the type	of the result of the %a	and %t printing	functions, and
       also the	type of	the argument transmitted  to  the  first  argument  of
       kprintf-style  functions	or to the kscanf-style functions.  - 'd	is the
       type of parameters for the scanf-style functions.  - 'e is the type  of
       the receiver function for the scanf-style functions.  - 'f is the final
       result type of a	formatted input/output function	 invocation:  for  the
       printf-style functions, it is typically unit; for the scanf-style func-
       tions, it is typically the result type of the receiver function.	 ===

       type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b,	'c, 'd,	'e,  'f)  Cam-
       linternalFormatBasics.format6

       type ('a, 'b, 'c, 'd) format4 = ('a, 'b,	'c, 'c,	'c, 'd)	format6

       type ('a, 'b, 'c) format	= ('a, 'b, 'c, 'c) format4

       val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string

       Converts	a format string	into a string.

       val format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c,
       'd, 'e, 'f) format6

       format_of_string	s returns a format string read from the	string literal
       s  .   Note: format_of_string can not convert a string argument that is
       not a literal. If you need this functionality,  use  the	 more  general
       Scanf.format_from_string	function.

       val (^^)	: ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('f, 'b, 'c, 'e, 'g, 'h)
       format6 -> ('a, 'b, 'c, 'd, 'g, 'h) format6

       f1 ^^ f2	catenates format strings f1 and	f2 . The result	 is  a	format
       string  that behaves as the concatenation of format strings f1 and f2 :
       in case of formatted output, it accepts arguments from f1 , then	 argu-
       ments  from f2 ;	in case	of formatted input, it returns results from f1
       , then results from f2 .

       === Program termination ===

       val exit	: int -> 'a

       Terminate the process, returning	the given status code to the operating
       system:	usually	 0 to indicate no errors, and a	small positive integer
       to indicate  failure.   All  open  output  channels  are	 flushed  with
       flush_all .  An implicit	exit 0 is performed each time a	program	termi-
       nates normally.	An implicit exit 2 is performed	if the program	termi-
       nates early because of an uncaught exception.

       val at_exit : (unit -> unit) -> unit

       Register	 the  given function to	be called at program termination time.
       The functions registered	with at_exit will be called when  the  program
       executes	Pervasives.exit	, or terminates, either	normally or because of
       an uncaught exception.  The functions are called	 in  'last  in,	 first
       out'  order:  the  function  most recently added	with at_exit is	called
       first.

2020-08-11			    source:			 Pervasives(3)

NAME | Module | Documentation

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=Pervasives&sektion=3o&manpath=FreeBSD+12.2-RELEASE+and+Ports>

home | help