diff --git a/unstable/api/ml/index.html b/unstable/api/ml/index.html index 40c62c0fa..e85c1ca54 100644 --- a/unstable/api/ml/index.html +++ b/unstable/api/ml/index.html @@ -11,7 +11,7 @@
diff --git a/unstable/api/ml/melange/Ast_compatible/index.html b/unstable/api/ml/melange/Ast_compatible/index.html deleted file mode 100644 index 1442ca9cf..000000000 --- a/unstable/api/ml/melange/Ast_compatible/index.html +++ /dev/null @@ -1,12 +0,0 @@ - -Ast_compatible
val const_exp_string :
- ?loc:Melange_compiler_libs.Location.t ->
- ?attrs:Melange_compiler_libs.Parsetree.attribute list ->
- ?delimiter:string ->
- string ->
- Melange_compiler_libs.Parsetree.expression
val apply_simple :
- ?loc:Melange_compiler_libs.Location.t ->
- ?attrs:Melange_compiler_libs.Parsetree.attribute list ->
- Melange_compiler_libs.Parsetree.expression ->
- Melange_compiler_libs.Parsetree.expression list ->
- Melange_compiler_libs.Parsetree.expression
Ast_config
val add_structure :
- string ->
- (Melange_compiler_libs.Parsetree.expression option -> unit) ->
- unit
val add_signature :
- string ->
- (Melange_compiler_libs.Parsetree.expression option -> unit) ->
- unit
val iter_on_bs_config_stru : Melange_compiler_libs.Parsetree.structure -> unit
val iter_on_bs_config_sigi : Melange_compiler_libs.Parsetree.signature -> unit
Ast_extract
module Set_string = Melange_compiler_libs.Depend.String.Set
val read_parse_and_extract : 'a Ml_binary.kind -> 'a -> Set_string.t
Ast_payload
A utility module used when destructuring parsetree attributes, used for compiling FFI attributes and built-in ppx
type label_expr = lid * Melange_compiler_libs.Parsetree.expression
type action = lid * Melange_compiler_libs.Parsetree.expression option
val ident_or_record_as_config :
- Melange_compiler_libs.Location.t ->
- t ->
- action list
val assert_bool_lit : Melange_compiler_libs.Parsetree.expression -> bool
val table_dispatch :
- (Melange_compiler_libs.Parsetree.expression option -> 'a) Map_string.t ->
- action ->
- 'a option
Ast_utf8_string
val classify : char -> byte
Belt.Result
Utilities for result data type.
Belt.Result
is a data type with two variants: Ok
and Error
. Each of these variants can contain data, and those two pieces of data need not have the same data type. Belt.Result
is useful when you need to not only determine whether some data is valid or not (use Belt.Option
for that), but also keep information about the invalid data.
In the examples, we presume the existence of two variables:
let good = Ok 42
-let bad = Error "Invalid data"
val getExn : ('a, 'b) t -> 'a
getExn res
when res
is Ok n
, returns n
when res
is Error m
, raise an exception
getExn good = 42;;
+let bad = Error "Invalid data"
val getExn : ('a, 'b) t -> 'a
getExn res
when res
is Ok n
, returns n
when res
is Error m
, raise an exception
getExn good = 42;;
getExn bad;; (* raises exception *)
val mapWithDefaultU : ('a, 'c) t -> 'b -> ('a -> 'b) Js.Fn.arity1 -> 'b
val mapWithDefault : ('a, 'c) t -> 'b -> ('a -> 'b) -> 'b
mapWithDefault res default f
When res
is Ok n
, returns f n
, otherwise default
.
mapWithDefault good 0 (fun x -> x / 2) = 21
mapWithDefault bad 0 (fun x -> x / 2) = 0
val mapU : ('a, 'c) t -> ('a -> 'b) Js.Fn.arity1 -> ('b, 'c) t
map res f
When res
is Ok n
, returns Ok (f n)
. Otherwise returns res
unchanged. Function f
takes a value of the same type as n
and returns an ordinary value.
let f x = sqrt (float_of_int x)
map (Ok 64) f = Ok 8.0
diff --git a/unstable/api/ml/melange/Belt/Set/index.html b/unstable/api/ml/melange/Belt/Set/index.html
index 90cdec6a6..1fd1b94f8 100644
--- a/unstable/api/ml/melange/Belt/Set/index.html
+++ b/unstable/api/ml/melange/Belt/Set/index.html
@@ -48,7 +48,7 @@
let acc = ref [] ;;
forEach s0 (fun x -> acc := x !acc);;
!acc = [6;5;3;2];;
val reduceU : ('value, 'id) t -> 'a -> ('a -> 'value -> 'a) Js.Fn.arity2 -> 'a
val reduce : ('value, 'id) t -> 'a -> ('a -> 'value -> 'a) -> 'a
In increasing order.
let s0 = fromArray ~id:(module IntCmp) [|5;2;3;5;6|]];;
-reduce s0 [] Bs.List.add = [6;5;3;2];;
val everyU : ('value, 'id) t -> ('value -> bool) Js.Fn.arity1 -> bool
val every : ('value, 'id) t -> ('value -> bool) -> bool
every p s
checks if all elements of the set satisfy the predicate p
. Order unspecified.
val someU : ('value, 'id) t -> ('value -> bool) Js.Fn.arity1 -> bool
val some : ('value, 'id) t -> ('value -> bool) -> bool
some p s
checks if at least one element of the set satisfies the predicate p
.
val keepU : ('value, 'id) t -> ('value -> bool) Js.Fn.arity1 -> ('value, 'id) t
keep m p
returns the set of all elements in s
that satisfy predicate p
.
val everyU : ('value, 'id) t -> ('value -> bool) Js.Fn.arity1 -> bool
val every : ('value, 'id) t -> ('value -> bool) -> bool
every p s
checks if all elements of the set satisfy the predicate p
. Order unspecified.
val someU : ('value, 'id) t -> ('value -> bool) Js.Fn.arity1 -> bool
val some : ('value, 'id) t -> ('value -> bool) -> bool
some p s
checks if at least one element of the set satisfies the predicate p
.
val keepU : ('value, 'id) t -> ('value -> bool) Js.Fn.arity1 -> ('value, 'id) t
keep m p
returns the set of all elements in s
that satisfy predicate p
.
val partitionU :
('value, 'id) t ->
('value -> bool) Js.Fn.arity1 ->
('value, 'id) t * ('value, 'id) t
val partition :
diff --git a/unstable/api/ml/melange/Bs_ast_invariant/index.html b/unstable/api/ml/melange/Bs_ast_invariant/index.html
deleted file mode 100644
index 7bbcf999b..000000000
--- a/unstable/api/ml/melange/Bs_ast_invariant/index.html
+++ /dev/null
@@ -1,6 +0,0 @@
-
-Bs_ast_invariant (melange.Bs_ast_invariant) Module Bs_ast_invariant
val iter_warnings_on_stru : Melange_compiler_libs.Parsetree.structure -> unit
val iter_warnings_on_sigi : Melange_compiler_libs.Parsetree.signature -> unit
val emit_external_warnings_on_structure :
- Melange_compiler_libs.Parsetree.structure ->
- unit
val emit_external_warnings_on_signature :
- Melange_compiler_libs.Parsetree.signature ->
- unit
diff --git a/unstable/api/ml/melange/Bs_flow_ast_utils/index.html b/unstable/api/ml/melange/Bs_flow_ast_utils/index.html
deleted file mode 100644
index 874745e7f..000000000
--- a/unstable/api/ml/melange/Bs_flow_ast_utils/index.html
+++ /dev/null
@@ -1,6 +0,0 @@
-
-Bs_flow_ast_utils (melange.Bs_flow_ast_utils) Module Bs_flow_ast_utils
val check_flow_errors :
- loc:Melange_compiler_libs.Location.t ->
- offset:int ->
- (Js_parser.Loc.t * Js_parser.Parse_error.t) list ->
- unit
diff --git a/unstable/api/ml/melange/Build_reserved/SSet/index.html b/unstable/api/ml/melange/Build_reserved/SSet/index.html
deleted file mode 100644
index f634f43d4..000000000
--- a/unstable/api/ml/melange/Build_reserved/SSet/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-SSet (melange.Build_reserved.SSet) Module Build_reserved.SSet
diff --git a/unstable/api/ml/melange/Build_reserved/index.html b/unstable/api/ml/melange/Build_reserved/index.html
deleted file mode 100644
index 23e387494..000000000
--- a/unstable/api/ml/melange/Build_reserved/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Build_reserved (melange.Build_reserved) Module Build_reserved
diff --git a/unstable/api/ml/melange/Classify_function/index.html b/unstable/api/ml/melange/Classify_function/index.html
deleted file mode 100644
index 17c9a6823..000000000
--- a/unstable/api/ml/melange/Classify_function/index.html
+++ /dev/null
@@ -1,7 +0,0 @@
-
-Classify_function (melange.Classify_function) Module Classify_function
val classify :
- ?check:(Melange_compiler_libs.Location.t * int) ->
- string ->
- Js_raw_info.exp
val classify_exp :
- (Js_parser.Loc.t, Js_parser.Loc.t) Js_parser.Flow_ast.Expression.t ->
- Js_raw_info.exp
val classify_stmt : string -> Js_raw_info.stmt
diff --git a/unstable/api/ml/melange/Ext_list/index.html b/unstable/api/ml/melange/Ext_list/index.html
index ba76d9456..e2e8d025f 100644
--- a/unstable/api/ml/melange/Ext_list/index.html
+++ b/unstable/api/ml/melange/Ext_list/index.html
@@ -1,18 +1,12 @@
-Ext_list (melange.Ext_list) Module Ext_list
val combine_array_append :
+Ext_list (melange.Ext_list) Module Ext_list
map_last f xs
will pass true
to f
for the last element, false
otherwise. For empty list, it returns empty
map_last f xs
will pass true
to f
for the last element, false
otherwise. For empty list, it returns empty
split_at n l
will split l
into two lists a,b
, a
will be of length n
, otherwise, it will raise
split_at_last l
It is equivalent to split_at (List.length l - 1) l
length xs = length ys + n
input n should be positive TODO: input checking
stable_group eq lst
Example: Input:
stable_group (=) [1;2;3;4;3]
Output:
[[1];[2];[4];[3;3]]
TODO: this is O(n^2) behavior which could be improved later
find_first_not p lst
if all elements in lst
pass, return None
otherwise return the first element e
as Some e
which fails the predicate
find_opt f l
returns None
if all return None
, otherwise returns the first one.
for_all2_no_exn p xs ys
return true
if all satisfied, false
otherwise or length not equal
assoc_by_string default key lst
if key
is found in the list return that val, other unbox the default
, otherwise assert false
+ 'acc
split_at n l
will split l
into two lists a,b
, a
will be of length n
, otherwise, it will raise
split_at_last l
is equivalent to split_at (List.length l - 1) l
length xs = length ys + n
input n should be positive TODO: input checking
stable_group eq lst
Example: Input:
stable_group (=) [1;2;3;4;3]
Output:
[[1];[2];[4];[3;3]]
TODO: this is O(n^2) behavior which could be improved later
for_all2_no_exn p xs ys
returns true
if all predicates satisfied, false
otherwise or when the list lengths are not equal.
diff --git a/unstable/api/ml/melange/Ext_log/index.html b/unstable/api/ml/melange/Ext_log/index.html
deleted file mode 100644
index 7a046f31d..000000000
--- a/unstable/api/ml/melange/Ext_log/index.html
+++ /dev/null
@@ -1,4 +0,0 @@
-
-Ext_log (melange.Ext_log) Module Ext_log
A Poor man's logging utility
Example:
err __LOC__ "xx"
val dwarn : ?__POS__:(string * int * int * int) -> 'a logging
diff --git a/unstable/api/ml/melange/Ext_path/index.html b/unstable/api/ml/melange/Ext_path/index.html
index 62f800f71..1b0b96603 100644
--- a/unstable/api/ml/melange/Ext_path/index.html
+++ b/unstable/api/ml/melange/Ext_path/index.html
@@ -1,5 +1,5 @@
-Ext_path (melange.Ext_path) Module Ext_path
combine path1 path2
1. add some simplifications when concatenating 2. when path2
is absolute, return path2
get_extension "a.txt" = ".txt"
+Ext_path (melange.Ext_path) Module Ext_path
get_extension "a.txt" = ".txt"
get_extension "a" = ""
TODO: could be highly optimized if from
and to
resolve to the same path, a zero-length string is returned Given that two paths are directory
A typical use case is
Filename.concat
(rel_normalized_absolute_path cwd (Filename.dirname a))
(Filename.basename a)
diff --git a/unstable/api/ml/melange/Ext_string/index.html b/unstable/api/ml/melange/Ext_string/index.html
index 1335ef5d4..e4d0ccc1a 100644
--- a/unstable/api/ml/melange/Ext_string/index.html
+++ b/unstable/api/ml/melange/Ext_string/index.html
@@ -1,3 +1,2 @@
-Ext_string (melange.Ext_string) Module Ext_string
Extension to the standard library String
module, fixed some bugs like avoiding locale sensitivity
ends_with_then_chop name ext
ends_with_then_chop "a.cmj" ".cmj"
-"a"
This is useful in controlled or file case sensitve system
for_all_from s start p
if start
is negative, it raises, if start
is too large, it returns true
+Ext_string (melange.Ext_string) Module Ext_string
Extension to the standard library String
module, fixed some bugs like avoiding locale sensitivity
for_all_from s start p
if start
is negative, it raises, if start
is too large, it returns true
diff --git a/unstable/api/ml/melange/External_arg_spec/index.html b/unstable/api/ml/melange/External_arg_spec/index.html
deleted file mode 100644
index d5e4f816b..000000000
--- a/unstable/api/ml/melange/External_arg_spec/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-External_arg_spec (melange.External_arg_spec) Module External_arg_spec
type attr =
| Poly_var_string of {
}
| Poly_var of {
}
| Int of (string * int) list
| Arg_cst of cst
| Fn_uncurry_arity of int
| Extern_unit
| Nothing
| Ignore
| Unwrap
type obj_params = obj_param list
type params = param list
val cst_obj_literal : string -> cst
val cst_int : int -> cst
val cst_string : string -> cst
val empty_label : label
val obj_label : string -> label
val optional : bool -> string -> label
val dummy : param
diff --git a/unstable/api/ml/melange/External_ffi_types/index.html b/unstable/api/ml/melange/External_ffi_types/index.html
deleted file mode 100644
index fd6423cb4..000000000
--- a/unstable/api/ml/melange/External_ffi_types/index.html
+++ /dev/null
@@ -1,6 +0,0 @@
-
-External_ffi_types (melange.External_ffi_types) Module External_ffi_types
type arg_type = External_arg_spec.attr
type arg_label = External_arg_spec.label
type external_spec =
| Js_var of {
name : string;
external_module_name : external_module_name option;
scopes : string list;
}
| Js_module_as_var of external_module_name
| Js_module_as_fn of {
external_module_name : external_module_name;
splice : bool;
}
| Js_module_as_class of external_module_name
| Js_call of {
name : string;
external_module_name : external_module_name option;
splice : bool;
scopes : string list;
}
| Js_send of {
name : string;
splice : bool;
pipe : pipe;
js_send_scopes : string list;
}
| Js_new of {
name : string;
external_module_name : external_module_name option;
splice : bool;
scopes : string list;
}
| Js_set of {
}
| Js_get of {
}
| Js_get_index of {
}
| Js_set_index of {
}
type t = private
| Ffi_bs of params * return_wrapper * external_spec
| Ffi_obj_create of External_arg_spec.obj_params
| Ffi_inline_const of Lam_constant.t
| Ffi_normal
val check_ffi : ?loc:Melange_compiler_libs.Location.t -> external_spec -> bool
val to_string : t -> string
val from_string : string -> t
Note
val ffi_bs : External_arg_spec.params -> return_wrapper -> external_spec -> t
val ffi_bs_as_prims :
- External_arg_spec.params ->
- return_wrapper ->
- external_spec ->
- string list
val ffi_obj_create : External_arg_spec.obj_params -> t
val ffi_obj_as_prims : External_arg_spec.obj_params -> string list
diff --git a/unstable/api/ml/melange/Git_commit/index.html b/unstable/api/ml/melange/Git_commit/index.html
deleted file mode 100644
index 200c8262c..000000000
--- a/unstable/api/ml/melange/Git_commit/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Git_commit (melange.Git_commit) Module Git_commit
diff --git a/unstable/api/ml/melange/Hash_set_poly/index.html b/unstable/api/ml/melange/Hash_set_poly/index.html
index 63a100d14..f63cb921b 100644
--- a/unstable/api/ml/melange/Hash_set_poly/index.html
+++ b/unstable/api/ml/melange/Hash_set_poly/index.html
@@ -1,2 +1,2 @@
-Hash_set_poly (melange.Hash_set_poly) Module Hash_set_poly
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val add : 'a t -> 'a -> unit
val remove : 'a t -> 'a -> unit
val mem : 'a t -> 'a -> bool
val iter : 'a t -> ('a -> unit) -> unit
val to_list : 'a t -> 'a list
val length : 'a t -> int
+Hash_set_poly (melange.Hash_set_poly) Module Hash_set_poly
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val add : 'a t -> 'a -> unit
val remove : 'a t -> 'a -> unit
val mem : 'a t -> 'a -> bool
val iter : 'a t -> ('a -> unit) -> unit
val to_list : 'a t -> 'a list
val length : 'a t -> int
val fold : 'a t -> 'b -> ('a -> 'b -> 'b) -> 'b
val of_array : 'a array -> 'a t
val check_add : 'a t -> 'a -> bool
diff --git a/unstable/api/ml/melange/Int_vec_util/index.html b/unstable/api/ml/melange/Int_vec_util/index.html
deleted file mode 100644
index a0f115740..000000000
--- a/unstable/api/ml/melange/Int_vec_util/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Int_vec_util (melange.Int_vec_util) Module Int_vec_util
val mem : int -> Vec_int.t -> bool
diff --git a/unstable/api/ml/melange/Js/List/index.html b/unstable/api/ml/melange/Js/List/index.html
deleted file mode 100644
index cb8b008ad..000000000
--- a/unstable/api/ml/melange/Js/List/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-List (melange.Js.List) Module Js.List
Provide utilities for list
val length : 'a t -> int
val isEmpty : 'a t -> bool
val hd : 'a t -> 'a option
val nth : 'a t -> int -> 'a option
val mapRev : ('a -> 'b) Js.Fn.arity1 -> 'a t -> 'b t
val map : ('a -> 'b) Js.Fn.arity1 -> 'a t -> 'b t
val iter : ('a -> unit) Js.Fn.arity1 -> 'a t -> unit
val iteri : (int -> 'a -> unit) Js.Fn.arity2 -> 'a t -> unit
val foldLeft : ('a -> 'b -> 'a) Js.Fn.arity2 -> 'a -> 'b list -> 'a
Application order is left to right, tail recurisve
val foldRight : ('a -> 'b -> 'b) Js.Fn.arity2 -> 'a list -> 'b -> 'b
Application order is right to left tail-recursive.
val filter : ('a -> bool) Js.Fn.arity1 -> 'a t -> 'a t
val filterMap : ('a -> 'b option) Js.Fn.arity1 -> 'a t -> 'b t
val countBy : ('a -> bool) Js.Fn.arity1 -> 'a list -> int
val init : int -> (int -> 'a) Js.Fn.arity1 -> 'a t
val toVector : 'a t -> 'a array
val equal : ('a -> 'a -> bool) Js.Fn.arity2 -> 'a list -> 'a list -> bool
diff --git a/unstable/api/ml/melange/Js/Null_undefined/index.html b/unstable/api/ml/melange/Js/Null_undefined/index.html
deleted file mode 100644
index 112fed0ea..000000000
--- a/unstable/api/ml/melange/Js/Null_undefined/index.html
+++ /dev/null
@@ -1,15 +0,0 @@
-
-Null_undefined (melange.Js.Null_undefined) Module Js.Null_undefined
Contains functionality for dealing with values that can be both null
and undefined
val return : 'a -> 'a t
Constructs a value of 'a Js.null_undefined
containing a value of 'a
val isNullable : 'a t -> bool
Returns true
if the given value is null
or undefined
, false
otherwise
val null : 'a t
The null
value of type 'a Js.null_undefined
val undefined : 'a t
The undefined
value of type 'a Js.null_undefined
val bind : 'a t -> ('a -> 'b) Js.Fn.arity1 -> 'b t
Maps the contained value using the given function
If 'a Js.null_undefined
contains a value, that value is unwrapped, mapped to a 'b
using the given function a' -> 'b
, then wrapped back up and returned as 'b Js.null_undefined
let maybeGreetWorld (maybeGreeting: string Js.null_undefined) =
- Js.Undefined.bind maybeGreeting (fun greeting -> greeting ^ " world!")
val iter : 'a t -> ('a -> unit) Js.Fn.arity1 -> unit
Iterates over the contained value with the given function
If 'a Js.null_undefined
contains a value, that value is unwrapped and applied to the given function.
let maybeSay (maybeMessage: string Js.null_undefined) =
- Js.Null_undefined.iter maybeMessage (fun message -> Js.log message)
val fromOption : 'a option -> 'a t
Maps 'a option
to 'a Js.null_undefined
-
- Some a -> return a
- None -> undefined
-
-val from_opt : 'a option -> 'a t
val toOption : 'a t -> 'a option
Maps 'a Js.null_undefined
to 'a option
-
- return a -> Some a
- undefined -> None
- null -> None
-
-val to_opt : 'a t -> 'a option
diff --git a/unstable/api/ml/melange/Js/Option/index.html b/unstable/api/ml/melange/Js/Option/index.html
deleted file mode 100644
index b48a4db28..000000000
--- a/unstable/api/ml/melange/Js/Option/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Option (melange.Js.Option) Module Js.Option
Provide utilities for option
val isSomeValue : ('a -> 'a -> bool) Js.Fn.arity2 -> 'a -> 'a option -> bool
val equal : ('a -> 'b -> bool) Js.Fn.arity2 -> 'a option -> 'b option -> bool
val andThen : ('a -> 'b option) Js.Fn.arity1 -> 'a option -> 'b option
val map : ('a -> 'b) Js.Fn.arity1 -> 'a option -> 'b option
val filter : ('a -> bool) Js.Fn.arity1 -> 'a option -> 'a option
diff --git a/unstable/api/ml/melange/Js/Result/index.html b/unstable/api/ml/melange/Js/Result/index.html
deleted file mode 100644
index 16bcf618c..000000000
--- a/unstable/api/ml/melange/Js/Result/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Result (melange.Js.Result) Module Js.Result
Define the interface for result
diff --git a/unstable/api/ml/melange/Js/index.html b/unstable/api/ml/melange/Js/index.html
index 3964dc2f4..e100ea48c 100644
--- a/unstable/api/ml/melange/Js/index.html
+++ b/unstable/api/ml/melange/Js/index.html
@@ -2,4 +2,4 @@
Js (melange.Js) Module Js
This library provides bindings and necessary support for JS FFI. It contains all bindings into Js
namespace.
[| 1;2;3;4|]
|. Js.Array2.map (fun x -> x + 1 )
|. Js.Array2.reduce (+) 0
-|. Js.log
module Fn : sig ... end
The same as empty
in Js.Null
will be compiled as null
The same as empty
Js.Undefined
will be compiled as undefined
typeof x
will be compiled as typeof x
in JS Please consider functions in Types
for a type safe way of reflection
operators
unsafe_lt a b
will be compiled as a < b
. It is marked as unsafe, since it is impossible to give a proper semantics for comparision which applies to any type
unsafe_le a b
will be compiled as a <= b
. See also unsafe_lt
unsafe_gt a b
will be compiled as a > b
. See also unsafe_lt
unsafe_ge a b
will be compiled as a >= b
. See also unsafe_lt
Types for JS objects
nullable, value of this type can be either null
or 'a
this type is the same as type t
in Null
value of this type can be either undefined
or 'a
this type is the same as type t
in Undefined
value of this type can be undefined
, null
or 'a
this type is the same as type t
n Null_undefined
type +'a null_undefined = 'a nullable
module Array2 : sig ... end
Provide bindings to Js array
module Exn : sig ... end
Provide utilities for dealing with Js exceptions
module Vector : sig ... end
module String : sig ... end
Provide bindings to JS string
module TypedArray2 : sig ... end
Provide bindings for JS typed array
nested modules
module Null : sig ... end
Provide utilities around 'a null
module Nullable : sig ... end
Provide utilities around null_undefined
module Null_undefined : sig ... end
module Array : sig ... end
Provide bindings to Js array
module String2 : sig ... end
Provide bindings to JS string
module Re : sig ... end
Provide bindings to Js regex expression
module Promise : sig ... end
Provide bindings to JS promise
module Date : sig ... end
Provide bindings for JS Date
module Dict : sig ... end
Provide utilities for JS dictionary object
module Global : sig ... end
Provide bindings to JS global functions in global namespace
module Json : sig ... end
Provide utilities for json
module Math : sig ... end
Provide bindings for JS Math
object
module Obj : sig ... end
module Typed_array : sig ... end
Provide bindings for JS typed array
module Types : sig ... end
Provide utilities for manipulating JS types
module Float : sig ... end
Provide utilities for JS float
module Int : sig ... end
Provide utilities for int
module Bigint : sig ... end
Provide utilities for bigint
module Option : sig ... end
Provide utilities for option
module Result : sig ... end
Define the interface for result
module List : sig ... end
Provide utilities for list
module Console : sig ... end
module Set : sig ... end
Provides bindings for ES6 Set
module WeakSet : sig ... end
Provides bindings for ES6 WeakSet
module Map : sig ... end
Provides bindings for ES6 Map
module WeakMap : sig ... end
Provides bindings for ES6 WeakMap
+|. Js.log
module Fn : sig ... end
The same as empty
in Js.Null
will be compiled as null
The same as empty
Js.Undefined
will be compiled as undefined
typeof x
will be compiled as typeof x
in JS Please consider functions in Types
for a type safe way of reflection
operators
unsafe_lt a b
will be compiled as a < b
. It is marked as unsafe, since it is impossible to give a proper semantics for comparision which applies to any type
unsafe_le a b
will be compiled as a <= b
. See also unsafe_lt
unsafe_gt a b
will be compiled as a > b
. See also unsafe_lt
unsafe_ge a b
will be compiled as a >= b
. See also unsafe_lt
Types for JS objects
nullable, value of this type can be either null
or 'a
this type is the same as type t
in Null
value of this type can be either undefined
or 'a
this type is the same as type t
in Undefined
value of this type can be undefined
, null
or 'a
this type is the same as type t
n Null_undefined
type +'a null_undefined = 'a nullable
module Array2 : sig ... end
Provide bindings to Js array
module Exn : sig ... end
Provide utilities for dealing with Js exceptions
module Vector : sig ... end
module String : sig ... end
Provide bindings to JS string
module TypedArray2 : sig ... end
Provide bindings for JS typed array
nested modules
module Null : sig ... end
Provide utilities around 'a null
module Nullable : sig ... end
Provide utilities around null_undefined
module Array : sig ... end
Provide bindings to Js array
module String2 : sig ... end
Provide bindings to JS string
module Re : sig ... end
Provide bindings to Js regex expression
module Promise : sig ... end
Provide bindings to JS promise
module Date : sig ... end
Provide bindings for JS Date
module Dict : sig ... end
Provide utilities for JS dictionary object
module Global : sig ... end
Provide bindings to JS global functions in global namespace
module Json : sig ... end
Provide utilities for json
module Math : sig ... end
Provide bindings for JS Math
object
module Obj : sig ... end
module Typed_array : sig ... end
Provide bindings for JS typed array
module Types : sig ... end
Provide utilities for manipulating JS types
module Float : sig ... end
Provide utilities for JS float
module Int : sig ... end
Provide utilities for int
module Bigint : sig ... end
Provide utilities for bigint
module Console : sig ... end
module Set : sig ... end
Provides bindings for ES6 Set
module WeakSet : sig ... end
Provides bindings for ES6 WeakSet
module Map : sig ... end
Provides bindings for ES6 Map
module WeakMap : sig ... end
Provides bindings for ES6 WeakMap
diff --git a/unstable/api/ml/melange/Js_config/index.html b/unstable/api/ml/melange/Js_config/index.html
deleted file mode 100644
index 9f34d2f2b..000000000
--- a/unstable/api/ml/melange/Js_config/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Js_config (melange.Js_config) Module Js_config
return package_name
and path
when in script mode:
diff --git a/unstable/api/ml/melange/Js_raw_info/index.html b/unstable/api/ml/melange/Js_raw_info/index.html
deleted file mode 100644
index f5185d5b6..000000000
--- a/unstable/api/ml/melange/Js_raw_info/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Js_raw_info (melange.Js_raw_info) Module Js_raw_info
diff --git a/unstable/api/ml/melange/Lam/index.html b/unstable/api/ml/melange/Lam/index.html
deleted file mode 100644
index cea916f73..000000000
--- a/unstable/api/ml/melange/Lam/index.html
+++ /dev/null
@@ -1,28 +0,0 @@
-
-Lam (melange.Lam) Module Lam
type ap_info = {
ap_loc : Melange_compiler_libs.Location.t;
ap_inlined : Melange_compiler_libs.Lambda.inline_attribute;
ap_status : apply_status;
}
type lambda_switch = {
sw_consts_full : bool;
sw_consts : (int * t) list;
sw_blocks_full : bool;
sw_blocks : (int * t) list;
sw_failaction : t option;
sw_names : Melange_compiler_libs.Lambda.switch_names option;
}
and lfunction = {
arity : int;
params : ident list;
body : t;
attr : Melange_compiler_libs.Lambda.function_attribute;
}
and prim_info = private {
primitive : Lam_primitive.t;
args : t list;
loc : Melange_compiler_libs.Location.t;
}
and t = private
| Lvar of ident
| Lmutvar of ident
| Lglobal_module of ident
| Lconst of Lam_constant.t
| Lapply of apply
| Lfunction of lfunction
| Llet of Lam_compat.let_kind * ident * t * t
| Lmutlet of ident * t * t
| Lletrec of (ident * t) list * t
| Lprim of prim_info
| Lswitch of t * lambda_switch
| Lstringswitch of t * (string * t) list * t option
| Lstaticraise of int * t list
| Lstaticcatch of t * int * ident list * t
| Ltrywith of t * ident * t
| Lifthenelse of t * t * t
| Lsequence of t * t
| Lwhile of t * t
| Lfor of ident * t * t * Asttypes.direction_flag * t
| Lassign of ident * t
| Lsend of Melange_compiler_libs.Lambda.meth_kind
- * t
- * t
- * t list
- * Melange_compiler_libs.Location.t
| Lifused of ident * t
val handle_bs_non_obj_ffi :
- External_arg_spec.params ->
- External_ffi_types.return_wrapper ->
- External_ffi_types.external_spec ->
- t list ->
- Melange_compiler_libs.Location.t ->
- string ->
- t
val const : Lam_constant.t -> t
val function_ :
- attr:Melange_compiler_libs.Lambda.function_attribute ->
- arity:int ->
- params:ident list ->
- body:t ->
- t
val let_ : Lam_compat.let_kind -> ident -> t -> t -> t
val switch : t -> lambda_switch -> t
constant folding
val false_ : t
val unit : t
val not_ : Melange_compiler_libs.Location.t -> t -> t
constant folding
val send :
- Melange_compiler_libs.Lambda.meth_kind ->
- t ->
- t ->
- t list ->
- Melange_compiler_libs.Location.t ->
- t
val prim :
- primitive:Lam_primitive.t ->
- args:t list ->
- Melange_compiler_libs.Location.t ->
- t
constant folding
diff --git a/unstable/api/ml/melange/Lam_compat/index.html b/unstable/api/ml/melange/Lam_compat/index.html
deleted file mode 100644
index 8fa656dec..000000000
--- a/unstable/api/ml/melange/Lam_compat/index.html
+++ /dev/null
@@ -1,5 +0,0 @@
-
-Lam_compat (melange.Lam_compat) Module Lam_compat
type integer_comparison = Melange_compiler_libs.Lambda.integer_comparison =
type float_comparison = Melange_compiler_libs.Lambda.float_comparison =
type field_dbg_info = Melange_compiler_libs.Lambda.field_dbg_info =
val str_of_field_info : field_dbg_info -> string option
type set_field_dbg_info = Melange_compiler_libs.Lambda.set_field_dbg_info =
val cmp_int32 : integer_comparison -> int32 -> int32 -> bool
val cmp_int64 : integer_comparison -> int64 -> int64 -> bool
val cmp_nativeint : integer_comparison -> nativeint -> nativeint -> bool
val cmp_float : float_comparison -> float -> float -> bool
val cmp_int : integer_comparison -> int -> int -> bool
val eq_comparison : integer_comparison -> integer_comparison -> bool
val eq_float_comparison : float_comparison -> float_comparison -> bool
val eq_boxed_integer : boxed_integer -> boxed_integer -> bool
val eq_compile_time_constant :
- compile_time_constant ->
- compile_time_constant ->
- bool
diff --git a/unstable/api/ml/melange/Lam_constant/index.html b/unstable/api/ml/melange/Lam_constant/index.html
deleted file mode 100644
index 70dce557a..000000000
--- a/unstable/api/ml/melange/Lam_constant/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Lam_constant (melange.Lam_constant) Module Lam_constant
val string_of_pointer_info : pointer_info -> string option
type t =
| Const_js_null
| Const_js_undefined
| Const_js_true
| Const_js_false
| Const_int of {
i : int32;
comment : pointer_info;
}
| Const_char of char
| Const_string of {
}
| Const_float of string
| Const_int64 of int64
| Const_pointer of string
| Const_block of int * Lam_tag_info.t * t list
| Const_float_array of string list
| Const_some of t
| Const_module_alias
val lam_none : t
diff --git a/unstable/api/ml/melange/Lam_methname/index.html b/unstable/api/ml/melange/Lam_methname/index.html
deleted file mode 100644
index 1c8004e18..000000000
--- a/unstable/api/ml/melange/Lam_methname/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Lam_methname (melange.Lam_methname) Module Lam_methname
diff --git a/unstable/api/ml/melange/Lam_primitive/index.html b/unstable/api/ml/melange/Lam_primitive/index.html
deleted file mode 100644
index f0472f910..000000000
--- a/unstable/api/ml/melange/Lam_primitive/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Lam_primitive (melange.Lam_primitive) Module Lam_primitive
type t =
| Pbytes_to_string
| Pbytes_of_string
| Pmakeblock of int * Lam_tag_info.t * Asttypes.mutable_flag
| Pfield of int * Melange_compiler_libs.Lambda.field_dbg_info
| Psetfield of int * Melange_compiler_libs.Lambda.set_field_dbg_info
| Pduprecord of record_representation
| Plazyforce
| Pccall of {
}
| Pjs_call of {
prim_name : string;
arg_types : External_arg_spec.params;
ffi : External_ffi_types.external_spec;
}
| Pjs_object_create of External_arg_spec.obj_params
| Praise
| Psequand
| Psequor
| Pnot
| Pnegint
| Paddint
| Psubint
| Pmulint
| Pdivint
| Pmodint
| Pandint
| Porint
| Pxorint
| Plslint
| Plsrint
| Pasrint
| Poffsetint of int
| Poffsetref of int
| Pintoffloat
| Pfloatofint
| Pnegfloat
| Paddfloat
| Psubfloat
| Pmulfloat
| Pdivfloat
| Pintcomp of Lam_compat.integer_comparison
| Pfloatcomp of Lam_compat.float_comparison
| Pjscomp of Lam_compat.integer_comparison
| Pint64comp of Lam_compat.integer_comparison
| Pjs_apply
| Pjs_runtime_apply
| Pstringlength
| Pstringrefu
| Pstringrefs
| Pstringadd
| Pbyteslength
| Pbytesrefu
| Pbytessetu
| Pbytesrefs
| Pbytessets
| Pbytes_load_16 of bool
| Pbytes_load_32 of bool
| Pbytes_load_64 of bool
| Pbytes_set_16 of bool
| Pbytes_set_32 of bool
| Pbytes_set_64 of bool
| Pmakearray
| Parraylength
| Parrayrefu
| Parraysetu
| Parrayrefs
| Parraysets
| Pisint
| Pis_poly_var_const
| Pisout of int
| Pint64ofint
| Pintofint64
| Pnegint64
| Paddint64
| Psubint64
| Pmulint64
| Pdivint64
| Pmodint64
| Pandint64
| Porint64
| Pxorint64
| Plslint64
| Plsrint64
| Pasrint64
| Pctconst of Lam_compat.compile_time_constant
| Pbswap16
| Pbbswap of Lam_compat.boxed_integer
| Pdebugger
| Pjs_unsafe_downgrade of {
name : string;
setter : bool;
loc : Melange_compiler_libs.Location.t;
}
| Pinit_mod
| Pupdate_mod
| Praw_js_code of Js_raw_info.t
| Pjs_fn_make of int
| Pvoid_run
| Pfull_apply
| Pjs_fn_method
| Pundefined_to_opt
| Pnull_to_opt
| Pnull_undefined_to_opt
| Pis_null
| Pis_undefined
| Pis_null_undefined
| Pjs_typeof
| Pjs_function_length
| Pcaml_obj_length
| Pwrap_exn
| Pcreate_extension of string
| Pis_not_none
| Pval_from_option
| Pval_from_option_not_nest
| Psome
| Psome_not_nest
| Pfield_computed
| Psetfield_computed
diff --git a/unstable/api/ml/melange/Lam_tag_info/index.html b/unstable/api/ml/melange/Lam_tag_info/index.html
deleted file mode 100644
index f964b0f60..000000000
--- a/unstable/api/ml/melange/Lam_tag_info/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Lam_tag_info (melange.Lam_tag_info) Module Lam_tag_info
diff --git a/unstable/api/ml/melange/Literals/index.html b/unstable/api/ml/melange/Literals/index.html
deleted file mode 100644
index d89e065ea..000000000
--- a/unstable/api/ml/melange/Literals/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Literals (melange.Literals) Module Literals
diff --git a/unstable/api/ml/melange/Mel_exception/index.html b/unstable/api/ml/melange/Mel_exception/index.html
deleted file mode 100644
index bd7349a9b..000000000
--- a/unstable/api/ml/melange/Mel_exception/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Mel_exception (melange.Mel_exception) Module Mel_exception
val error : error -> 'a
diff --git a/unstable/api/ml/melange/Melange_ffi/Classify_function/index.html b/unstable/api/ml/melange/Melange_ffi/Classify_function/index.html
new file mode 100644
index 000000000..6d895c5e1
--- /dev/null
+++ b/unstable/api/ml/melange/Melange_ffi/Classify_function/index.html
@@ -0,0 +1,7 @@
+
+Classify_function (melange.Melange_ffi.Classify_function) Module Melange_ffi.Classify_function
val classify :
+ ?check:(Melange_compiler_libs.Location.t * int) ->
+ string ->
+ Js_raw_info.exp
val classify_exp :
+ (Js_parser.Loc.t, Js_parser.Loc.t) Js_parser.Flow_ast.Expression.t ->
+ Js_raw_info.exp
val classify_stmt : string -> Js_raw_info.stmt
diff --git a/unstable/api/ml/melange/Melange_ffi/External_arg_spec/index.html b/unstable/api/ml/melange/Melange_ffi/External_arg_spec/index.html
new file mode 100644
index 000000000..8566134c4
--- /dev/null
+++ b/unstable/api/ml/melange/Melange_ffi/External_arg_spec/index.html
@@ -0,0 +1,2 @@
+
+External_arg_spec (melange.Melange_ffi.External_arg_spec) Module Melange_ffi.External_arg_spec
type attr =
| Poly_var_string of {
}
| Poly_var of {
}
| Int of (string * int) list
| Arg_cst of cst
| Fn_uncurry_arity of int
| Extern_unit
| Nothing
| Ignore
| Unwrap
type obj_params = obj_param list
type params = param list
val cst_obj_literal : string -> cst
val cst_int : int -> cst
val cst_string : string -> cst
val empty_label : label
val obj_label : string -> label
val optional : bool -> string -> label
val dummy : param
diff --git a/unstable/api/ml/melange/Melange_ffi/External_ffi_types/Literals/index.html b/unstable/api/ml/melange/Melange_ffi/External_ffi_types/Literals/index.html
new file mode 100644
index 000000000..1d5d07365
--- /dev/null
+++ b/unstable/api/ml/melange/Melange_ffi/External_ffi_types/Literals/index.html
@@ -0,0 +1,2 @@
+
+Literals (melange.Melange_ffi.External_ffi_types.Literals) Module External_ffi_types.Literals
diff --git a/unstable/api/ml/melange/Melange_ffi/External_ffi_types/index.html b/unstable/api/ml/melange/Melange_ffi/External_ffi_types/index.html
new file mode 100644
index 000000000..d438263f7
--- /dev/null
+++ b/unstable/api/ml/melange/Melange_ffi/External_ffi_types/index.html
@@ -0,0 +1,6 @@
+
+External_ffi_types (melange.Melange_ffi.External_ffi_types) Module Melange_ffi.External_ffi_types
module Literals : sig ... end
type arg_type = External_arg_spec.attr
type arg_label = External_arg_spec.label
type external_spec =
| Js_var of {
name : string;
external_module_name : external_module_name option;
scopes : string list;
}
| Js_module_as_var of external_module_name
| Js_module_as_fn of {
external_module_name : external_module_name;
splice : bool;
}
| Js_module_as_class of external_module_name
| Js_call of {
name : string;
external_module_name : external_module_name option;
splice : bool;
scopes : string list;
}
| Js_send of {
name : string;
splice : bool;
pipe : pipe;
js_send_scopes : string list;
}
| Js_new of {
name : string;
external_module_name : external_module_name option;
splice : bool;
scopes : string list;
}
| Js_set of {
}
| Js_get of {
}
| Js_get_index of {
}
| Js_set_index of {
}
type t = private
| Ffi_bs of params * return_wrapper * external_spec
| Ffi_obj_create of External_arg_spec.obj_params
| Ffi_inline_const of Lam_constant.t
| Ffi_normal
val check_ffi : ?loc:Melange_compiler_libs.Location.t -> external_spec -> bool
val to_string : t -> string
val from_string : string -> t
Note
val ffi_bs : External_arg_spec.params -> return_wrapper -> external_spec -> t
val ffi_bs_as_prims :
+ External_arg_spec.params ->
+ return_wrapper ->
+ external_spec ->
+ string list
val ffi_obj_create : External_arg_spec.obj_params -> t
val ffi_obj_as_prims : External_arg_spec.obj_params -> string list
diff --git a/unstable/api/ml/melange/Melange_ffi/Flow_ast_utils/index.html b/unstable/api/ml/melange/Melange_ffi/Flow_ast_utils/index.html
new file mode 100644
index 000000000..629be1e5e
--- /dev/null
+++ b/unstable/api/ml/melange/Melange_ffi/Flow_ast_utils/index.html
@@ -0,0 +1,6 @@
+
+Flow_ast_utils (melange.Melange_ffi.Flow_ast_utils) Module Melange_ffi.Flow_ast_utils
val check_flow_errors :
+ loc:Melange_compiler_libs.Location.t ->
+ offset:int ->
+ (Js_parser.Loc.t * Js_parser.Parse_error.t) list ->
+ unit
diff --git a/unstable/api/ml/melange/Melange_ffi/Js_raw_info/index.html b/unstable/api/ml/melange/Melange_ffi/Js_raw_info/index.html
new file mode 100644
index 000000000..bbaf85daa
--- /dev/null
+++ b/unstable/api/ml/melange/Melange_ffi/Js_raw_info/index.html
@@ -0,0 +1,2 @@
+
+Js_raw_info (melange.Melange_ffi.Js_raw_info) Module Melange_ffi.Js_raw_info
diff --git a/unstable/api/ml/melange/Melange_ffi/Lam_constant/index.html b/unstable/api/ml/melange/Melange_ffi/Lam_constant/index.html
new file mode 100644
index 000000000..5cfb31d35
--- /dev/null
+++ b/unstable/api/ml/melange/Melange_ffi/Lam_constant/index.html
@@ -0,0 +1,2 @@
+
+Lam_constant (melange.Melange_ffi.Lam_constant) Module Melange_ffi.Lam_constant
val string_of_pointer_info : pointer_info -> string option
type t =
| Const_js_null
| Const_js_undefined
| Const_js_true
| Const_js_false
| Const_int of {
i : int32;
comment : pointer_info;
}
| Const_char of char
| Const_string of {
}
| Const_float of string
| Const_int64 of int64
| Const_pointer of string
| Const_block of int * Lam_tag_info.t * t list
| Const_float_array of string list
| Const_some of t
| Const_module_alias
val lam_none : t
diff --git a/unstable/api/ml/melange/Melange_ffi/Lam_methname/index.html b/unstable/api/ml/melange/Melange_ffi/Lam_methname/index.html
new file mode 100644
index 000000000..91cd09b16
--- /dev/null
+++ b/unstable/api/ml/melange/Melange_ffi/Lam_methname/index.html
@@ -0,0 +1,2 @@
+
+Lam_methname (melange.Melange_ffi.Lam_methname) Module Melange_ffi.Lam_methname
diff --git a/unstable/api/ml/melange/Melange_ffi/Lam_tag_info/index.html b/unstable/api/ml/melange/Melange_ffi/Lam_tag_info/index.html
new file mode 100644
index 000000000..889f14f57
--- /dev/null
+++ b/unstable/api/ml/melange/Melange_ffi/Lam_tag_info/index.html
@@ -0,0 +1,2 @@
+
+Lam_tag_info (melange.Melange_ffi.Lam_tag_info) Module Melange_ffi.Lam_tag_info
diff --git a/unstable/api/ml/melange/Melange_ffi/Utf8_string/index.html b/unstable/api/ml/melange/Melange_ffi/Utf8_string/index.html
new file mode 100644
index 000000000..13d618023
--- /dev/null
+++ b/unstable/api/ml/melange/Melange_ffi/Utf8_string/index.html
@@ -0,0 +1,2 @@
+
+Utf8_string (melange.Melange_ffi.Utf8_string) Module Melange_ffi.Utf8_string
val classify : char -> byte
diff --git a/unstable/api/ml/melange/Melange_ffi/index.html b/unstable/api/ml/melange/Melange_ffi/index.html
new file mode 100644
index 000000000..faedabb37
--- /dev/null
+++ b/unstable/api/ml/melange/Melange_ffi/index.html
@@ -0,0 +1,2 @@
+
+Melange_ffi (melange.Melange_ffi) Module Melange_ffi
module Classify_function : sig ... end
module External_arg_spec : sig ... end
module External_ffi_types : sig ... end
module Flow_ast_utils : sig ... end
module Js_raw_info : sig ... end
module Lam_constant : sig ... end
module Lam_methname : sig ... end
module Lam_tag_info : sig ... end
module Utf8_string : sig ... end
diff --git a/unstable/api/ml/melange/Melange_ppx/Ast_literal/index.html b/unstable/api/ml/melange/Melange_ppx/Ast_literal/index.html
index e5ba0068a..0ad9b7948 100644
--- a/unstable/api/ml/melange/Melange_ppx/Ast_literal/index.html
+++ b/unstable/api/ml/melange/Melange_ppx/Ast_literal/index.html
@@ -1,2 +1,2 @@
-Ast_literal (melange.Melange_ppx.Ast_literal) Module Melange_ppx.Ast_literal
val predef_prefix_ident : t
val predef_option : t
val predef_some : t
val predef_none : t
val js_fn : t
val js_internal_full_apply : t
val opaque : t
val js_oo : t
val js_meth : t
val js_meth_callback : t
val js_obj : t
val ignore_id : t
val js_null : t
val js_undefined : t
val js_null_undefined : t
val js_re_id : t
val js_internal : t
+Ast_literal (melange.Melange_ppx.Ast_literal) Module Melange_ppx.Ast_literal
val js_fn : t
val js_internal : t
val js_internal_full_apply : t
val js_meth : t
val js_meth_callback : t
val js_null : t
val js_null_undefined : t
val js_obj : t
val js_oo : t
val js_re_id : t
val js_undefined : t
val opaque : t
val predef_some : t
val predef_none : t
val unsafe_downgrade : t
diff --git a/unstable/api/ml/melange/Melange_version/index.html b/unstable/api/ml/melange/Melange_version/index.html
deleted file mode 100644
index c0d477922..000000000
--- a/unstable/api/ml/melange/Melange_version/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Melange_version (melange.Melange_version) Module Melange_version
diff --git a/unstable/api/ml/melange/Ml_binary/index.html b/unstable/api/ml/melange/Ml_binary/index.html
deleted file mode 100644
index 5bf806d80..000000000
--- a/unstable/api/ml/melange/Ml_binary/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Ml_binary (melange.Ml_binary) Module Ml_binary
val magic_of_kind : 'a kind -> string
diff --git a/unstable/api/ml/melange/Stdlib/index.html b/unstable/api/ml/melange/Stdlib/index.html
index 857a90d94..7a0e511e5 100644
--- a/unstable/api/ml/melange/Stdlib/index.html
+++ b/unstable/api/ml/melange/Stdlib/index.html
@@ -1,5 +1,5 @@
-Stdlib (melange.Stdlib) Module Stdlib
The OCaml Standard library.
This module is automatically opened at the beginning of each compilation. All components of this module can therefore be referred by their short name, without prefixing them by Stdlib
.
In particular, it provides the basic operations over the built-in types (numbers, booleans, byte sequences, strings, exceptions, references, lists, arrays, input-output channels, ...) and the standard library modules.
Exceptions
The Exit
exception is not raised by any library function. It is provided for use in your programs.
Exception raised when none of the cases of a pattern-matching apply. The arguments are the location of the match keyword in the source code (file name, line number, column number).
Exception raised when an assertion fails. The arguments are the location of the assert keyword in the source code (file name, line number, column number).
Exception raised by library functions to signal that the given arguments do not make sense. The string gives some information to the programmer. As a general rule, this exception should not be caught, it denotes a programming error and the code should be modified not to trigger it.
Exception raised by library functions to signal that they are undefined on the given arguments. The string is meant to give some information to the programmer; you must not pattern match on the string literal because it may change in future versions (use Failure _ instead).
Exception raised by the garbage collector when there is insufficient memory to complete the computation. (Not reliable for allocations on the minor heap.)
Exception raised by the bytecode interpreter when the evaluation stack reaches its maximal size. This often indicates infinite or excessively deep recursion in the user's program.
Before 4.10, it was not fully implemented by the native-code compiler.
Exception raised by the input/output functions to report an operating system error. The string is meant to give some information to the programmer; you must not pattern match on the string literal because it may change in future versions (use Sys_error _ instead).
Exception raised by input functions to signal that the end of file has been reached.
Exception raised by integer division and remainder operations when their second argument is zero.
A special case of Sys_error raised when no I/O is possible on a non-blocking I/O channel.
Exception raised when an ill-founded recursive module definition is evaluated. The arguments are the location of the definition in the source code (file name, line number, column number).
Comparisons
e1 = e2
tests for structural equality of e1
and e2
. Mutable structures (e.g. references and arrays) are equal if and only if their current 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. Left-associative operator, see Ocaml_operators
for more information.
Negation of Stdlib.(=)
. Left-associative operator, see Ocaml_operators
for more information.
See Stdlib.(>=)
. Left-associative operator, see Ocaml_operators
for more information.
See Stdlib.(>=)
. Left-associative operator, see Ocaml_operators
for more information.
See Stdlib.(>=)
. Left-associative operator, see Ocaml_operators
for more information.
Structural ordering functions. These functions coincide with the usual orderings over integers, characters, strings, byte sequences and floating-point numbers, and extend them to a total ordering over all types. The ordering is compatible with ( = )
. As in the case of ( = )
, mutable structures are compared by contents. Comparison between functional values raises Invalid_argument
. Comparison between cyclic structures may not terminate. Left-associative operator, see Ocaml_operators
for more information.
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 ordering implemented by compare
is compatible with the comparison predicates =
, <
and >
defined above, with one difference on the treatment of the float value Stdlib.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 total ordering relation.
compare
applied to functional values may raise Invalid_argument
. compare
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 Array.sort
functions.
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
. Left-associative operator, see Ocaml_operators
for more information.
Negation of Stdlib.(==)
. Left-associative operator, see Ocaml_operators
for more information.
Boolean operations
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. Right-associative operator, see Ocaml_operators
for more information.
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. Right-associative operator, see Ocaml_operators
for more information.
Debugging
__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".
__LINE__
returns the line number at which this expression appears in the file currently being parsed by the compiler.
__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 character position in the line.
__FUNCTION__
returns the name of the current function or method, including any enclosing modules or classes.
__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 standard error format of OCaml: "File %S, line %d, characters %d-%d".
__LINE_OF__ expr
returns a pair (line, expr)
, where line
is the line number at which the expression expr
appears in the file currently being parsed by the compiler.
__POS_OF__ expr
returns a pair (loc,expr)
, where loc
is a tuple (file,lnum,cnum,enum)
corresponding to the location at which the expression expr
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 character position in the line.
Composition operators
Reverse-application operator: x |> f |> g
is exactly equivalent to g (f (x))
. Left-associative operator, see Ocaml_operators
for more information.
Application operator: g @@ f @@ x
is exactly equivalent to g (f (x))
. Right-associative operator, see Ocaml_operators
for more information.
Integer arithmetic
Integers are Sys.int_size
bits wide. All operations are taken modulo 2Sys.int_size
. They do not fail on overflow.
Unary negation. You can also write - e
instead of ~- e
. Unary operator, see Ocaml_operators
for more information.
Unary addition. You can also write + e
instead of ~+ e
. Unary operator, see Ocaml_operators
for more information.
Integer addition. Left-associative operator, see Ocaml_operators
for more information.
Integer subtraction. Left-associative operator, , see Ocaml_operators
for more information.
Integer multiplication. Left-associative operator, see Ocaml_operators
for more information.
Integer division. Integer division rounds the real quotient of its arguments towards zero. More precisely, if x >= 0
and y > 0
, x / y
is the greatest integer less than or equal to the real quotient of x
by y
. Moreover, (- x) / y = x / (- y) = - (x / y)
. Left-associative operator, see Ocaml_operators
for more information.
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
. Left-associative operator, see Ocaml_operators
for more information.
abs x
is the absolute value of x
. On min_int
this is min_int
itself and thus remains negative.
Bitwise operations
Bitwise logical and. Left-associative operator, see Ocaml_operators
for more information.
Bitwise logical or. Left-associative operator, see Ocaml_operators
for more information.
Bitwise logical exclusive or. Left-associative operator, see Ocaml_operators
for more information.
n lsl m
shifts n
to the left by m
bits. The result is unspecified if m < 0
or m > Sys.int_size
. Right-associative operator, see Ocaml_operators
for more information.
n lsr m
shifts n
to the right by m
bits. This is a logical shift: zeroes are inserted regardless of the sign of n
. The result is unspecified if m < 0
or m > Sys.int_size
. Right-associative operator, see Ocaml_operators
for more information.
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 > Sys.int_size
. Right-associative operator, see Ocaml_operators
for more information.
Floating-point arithmetic
OCaml's floating-point numbers follow the IEEE 754 standard, using double precision (64 bits) numbers. Floating-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 instance, 1.0 /. infinity
is 0.0
, basic arithmetic operations (+.
, -.
, *.
, /.
) with nan
as an argument return nan
, ...
Unary negation. You can also write -. e
instead of ~-. e
. Unary operator, see Ocaml_operators
for more information.
Unary addition. You can also write +. e
instead of ~+. e
. Unary operator, see Ocaml_operators
for more information.
Floating-point addition. Left-associative operator, see Ocaml_operators
for more information.
Floating-point subtraction. Left-associative operator, see Ocaml_operators
for more information.
Floating-point multiplication. Left-associative operator, see Ocaml_operators
for more information.
Floating-point division. Left-associative operator, see Ocaml_operators
for more information.
expm1 x
computes exp x -. 1.0
, giving numerically-accurate results even if x
is close to 0.0
.
log1p x
computes log(1.0 +. x)
(natural logarithm), giving numerically-accurate results even if x
is close to 0.0
.
Arc cosine. The argument must fall within the range [-1.0, 1.0]
. Result is in radians and is between 0.0
and pi
.
Arc sine. The argument must fall within the range [-1.0, 1.0]
. Result is in radians and is between -pi/2
and pi/2
.
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
.
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.
Hyperbolic arc cosine. The argument must fall within the range [1.0, inf]
. Result is in radians and is between 0.0
and inf
.
Hyperbolic arc sine. The argument and result range over the entire real line. Result is in radians.
Hyperbolic arc tangent. The argument must fall within the range [-1.0, 1.0]
. Result is in radians and ranges over the entire real line.
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.
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.
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.
mod_float a b
returns the remainder of a
with respect to b
. The returned value is a -. n *. b
, where n
is the quotient a /. b
rounded towards zero to an integer.
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
.
Same as Stdlib.float_of_int
.
Same as Stdlib.int_of_float
.
Truncate the given floating-point number to an integer. The result is unspecified if the argument is nan
or falls outside the range of representable integers.
The difference between 1.0
and the smallest exactly representable floating-point number greater than 1.0
.
The five classes of floating-point numbers, as determined by the Stdlib.classify_float
function.
val classify_float : float -> fpclass
String operations
More string operations are provided in module String
.
String concatenation. Right-associative operator, see Ocaml_operators
for more information.
Character operations
More character operations are provided in module Char
.
Unit operations
Discard the value of its argument and return ()
. For instance, ignore(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
Return the string representation of a boolean. As the returned values may be shared, the user should not modify them directly.
Convert the given string to a boolean.
Return None
if the string is not "true"
or "false"
.
Same as Stdlib.bool_of_string_opt
, but raise Invalid_argument "bool_of_string"
instead of returning None
.
Return the string representation of an integer, in decimal.
Convert the given string to an integer. The string is read in decimal (by default, or if the string begins with 0u
), 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 0u
prefix reads the input as an unsigned integer in the range [0, 2*max_int+1]
. If the input exceeds max_int
it is converted to the signed integer min_int + input - max_int - 1
.
The _
(underscore) character can appear anywhere in the string and is ignored.
Return None
if the given string is not a valid representation of an integer, or if the integer represented exceeds the range of integers representable in type int
.
Same as Stdlib.int_of_string_opt
, but raise Failure "int_of_string"
instead of returning None
.
Return a string representation of a floating-point number.
This conversion can involve a loss of precision. For greater control over the manner in which the number is printed, see Printf
.
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 decimal 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.
Return None
if the given string is not a valid representation of a float.
Same as Stdlib.float_of_string_opt
, but raise Failure "float_of_string"
instead of returning None
.
Pair operations
List operations
More list operations are provided in module List
.
l0 @ l1
appends l1
to l0
. Same function as List.append
. Right-associative operator, see Ocaml_operators
for more information.
Input/output
Note: all input/output functions can raise Sys_error
when the system calls they invoke fail.
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
Print a floating-point number, in decimal, on standard output.
The conversion of the number to a string uses string_of_float
and can involve a loss of precision.
Print a string, followed by a newline character, on standard output and flush standard output.
Print a newline character on standard output, and flush standard output. This can be used to simulate line buffering of standard output.
Output functions on standard error
Print a floating-point number, in decimal, on standard error.
The conversion of the number to a string uses string_of_float
and can involve a loss of precision.
Print a string, followed by a newline character on standard error and flush standard error.
Print a newline character on standard error, and flush standard error.
Input functions on standard input
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.
Flush standard output, then read one line from standard input and convert it to an integer.
Return None
if the line read is not a valid representation of an integer.
Same as Stdlib.read_int_opt
, but raise Failure "int_of_string"
instead of returning None
.
Flush standard output, then read one line from standard input and convert it to a floating-point number.
Return None
if the line read is not a valid representation of a floating-point number.
Same as Stdlib.read_float_opt
, but raise Failure "float_of_string"
instead of returning None
.
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 Stdlib.open_out_gen
and Stdlib.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 truncated 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 Stdlib.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 function behaves like Stdlib.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. Stdlib.open_out
and Stdlib.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 careful about flushing standard output and standard error at the right time.
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.
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
.
val output_substring : out_channel -> string -> int -> int -> unit
Same as output
but take a string as argument instead of a byte sequence.
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 232. The only reliable way to read it back is through the Stdlib.input_binary_int
function. The format is compatible across all machines for a given version of OCaml.
val output_value : out_channel -> 'a -> unit
Write the representation of a structured value of any type to a channel. Circularities and sharing inside the value are detected and preserved. The object can be read back, by the function Stdlib.input_value
. See the description of module Marshal
for more information. Stdlib.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). For files opened in text mode under Windows, the returned position is approximate (owing to end-of-line conversion); in particular, saving the current position with pos_out
, then going back to this position using seek_out
will not work. For this programming idiom to work reliably and portably, the file must be opened in binary mode.
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. Output 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 function has no effect under operating systems that do not distinguish between 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 Stdlib.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 behaves like Stdlib.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 described above. The extra arguments mode
and perm
specify the opening mode and file permissions. Stdlib.open_in
and Stdlib.open_in_bin
are special cases of this function.
val input_char : in_channel -> char
Read one character from the given input channel.
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.
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 Stdlib.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
.
val really_input_string : in_channel -> int -> string
really_input_string ic len
reads len
characters from channel ic
and returns them in a new string.
val input_byte : in_channel -> int
Same as Stdlib.input_char
, but return the 8-bit integer representing the character.
val input_binary_int : in_channel -> int
Read an integer encoded in binary format (4 bytes, big-endian) from the given input channel. See Stdlib.output_binary_int
.
val input_value : in_channel -> 'a
Read the representation of a structured value, as produced by Stdlib.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. For files opened in text mode under Windows, the returned position is approximate (owing to end-of-line conversion); in particular, saving the current position with pos_in
, then going back to this position using seek_in
will not work. For this programming idiom to work reliably and portably, the file must be opened in binary mode.
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 performed 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 function has no effect under operating systems that do not distinguish between 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 allow operating on files whose sizes are greater than max_int
.
References
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
. Unary operator, see Ocaml_operators
for more information.
val (:=) : 'a ref -> 'a -> unit
r := a
stores the value of a
in reference r
. Equivalent to fun r v -> r.contents <- v
. Right-associative operator, see Ocaml_operators
for more information.
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
Operations on format strings
Format strings are character strings with special lexical conventions that defines the functionality of formatted input/output functions. Format strings are used to read data with formatted input functions from module Scanf
and to print data with formatted output functions from modules Printf
and Format
.
Format strings are made of three kinds of entities:
- conversions specifications, introduced by the special 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 specifying 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 output.
There is an additional lexical rule to escape the special characters '%'
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 information about conversion specifications and formatting indications available, 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.formatter
; 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 functions, it is typically the result type of the receiver function.
type ('a, 'b, 'c, 'd, 'e, 'f) format6 =
+Stdlib (melange.Stdlib) Module Stdlib
The OCaml Standard library.
This module is automatically opened at the beginning of each compilation. All components of this module can therefore be referred by their short name, without prefixing them by Stdlib
.
In particular, it provides the basic operations over the built-in types (numbers, booleans, byte sequences, strings, exceptions, references, lists, arrays, input-output channels, ...) and the standard library modules.
Exceptions
The Exit
exception is not raised by any library function. It is provided for use in your programs.
Exception raised when none of the cases of a pattern-matching apply. The arguments are the location of the match keyword in the source code (file name, line number, column number).
Exception raised when an assertion fails. The arguments are the location of the assert keyword in the source code (file name, line number, column number).
Exception raised by library functions to signal that the given arguments do not make sense. The string gives some information to the programmer. As a general rule, this exception should not be caught, it denotes a programming error and the code should be modified not to trigger it.
Exception raised by library functions to signal that they are undefined on the given arguments. The string is meant to give some information to the programmer; you must not pattern match on the string literal because it may change in future versions (use Failure _ instead).
Exception raised by the garbage collector when there is insufficient memory to complete the computation. (Not reliable for allocations on the minor heap.)
Exception raised by the bytecode interpreter when the evaluation stack reaches its maximal size. This often indicates infinite or excessively deep recursion in the user's program.
Before 4.10, it was not fully implemented by the native-code compiler.
Exception raised by the input/output functions to report an operating system error. The string is meant to give some information to the programmer; you must not pattern match on the string literal because it may change in future versions (use Sys_error _ instead).
Exception raised by input functions to signal that the end of file has been reached.
Exception raised by integer division and remainder operations when their second argument is zero.
A special case of Sys_error raised when no I/O is possible on a non-blocking I/O channel.
Exception raised when an ill-founded recursive module definition is evaluated. The arguments are the location of the definition in the source code (file name, line number, column number).
Comparisons
e1 = e2
tests for structural equality of e1
and e2
. Mutable structures (e.g. references and arrays) are equal if and only if their current 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. Left-associative operator, see Ocaml_operators
for more information.
Negation of Stdlib.(=)
. Left-associative operator, see Ocaml_operators
for more information.
See Stdlib.(>=)
. Left-associative operator, see Ocaml_operators
for more information.
See Stdlib.(>=)
. Left-associative operator, see Ocaml_operators
for more information.
See Stdlib.(>=)
. Left-associative operator, see Ocaml_operators
for more information.
Structural ordering functions. These functions coincide with the usual orderings over integers, characters, strings, byte sequences and floating-point numbers, and extend them to a total ordering over all types. The ordering is compatible with ( = )
. As in the case of ( = )
, mutable structures are compared by contents. Comparison between functional values raises Invalid_argument
. Comparison between cyclic structures may not terminate. Left-associative operator, see Ocaml_operators
for more information.
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 ordering implemented by compare
is compatible with the comparison predicates =
, <
and >
defined above, with one difference on the treatment of the float value Stdlib.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 total ordering relation.
compare
applied to functional values may raise Invalid_argument
. compare
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 Array.sort
functions.
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
. Left-associative operator, see Ocaml_operators
for more information.
Negation of Stdlib.(==)
. Left-associative operator, see Ocaml_operators
for more information.
Boolean operations
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. Right-associative operator, see Ocaml_operators
for more information.
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. Right-associative operator, see Ocaml_operators
for more information.
Debugging
__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".
__LINE__
returns the line number at which this expression appears in the file currently being parsed by the compiler.
__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 character position in the line.
__FUNCTION__
returns the name of the current function or method, including any enclosing modules or classes.
__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 standard error format of OCaml: "File %S, line %d, characters %d-%d".
__LINE_OF__ expr
returns a pair (line, expr)
, where line
is the line number at which the expression expr
appears in the file currently being parsed by the compiler.
__POS_OF__ expr
returns a pair (loc,expr)
, where loc
is a tuple (file,lnum,cnum,enum)
corresponding to the location at which the expression expr
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 character position in the line.
Composition operators
Reverse-application operator: x |> f |> g
is exactly equivalent to g (f (x))
. Left-associative operator, see Ocaml_operators
for more information.
Application operator: g @@ f @@ x
is exactly equivalent to g (f (x))
. Right-associative operator, see Ocaml_operators
for more information.
Integer arithmetic
Integers are Sys.int_size
bits wide. All operations are taken modulo 2Sys.int_size
. They do not fail on overflow.
Unary negation. You can also write - e
instead of ~- e
. Unary operator, see Ocaml_operators
for more information.
Unary addition. You can also write + e
instead of ~+ e
. Unary operator, see Ocaml_operators
for more information.
Integer addition. Left-associative operator, see Ocaml_operators
for more information.
Integer subtraction. Left-associative operator, , see Ocaml_operators
for more information.
Integer multiplication. Left-associative operator, see Ocaml_operators
for more information.
Integer division. Integer division rounds the real quotient of its arguments towards zero. More precisely, if x >= 0
and y > 0
, x / y
is the greatest integer less than or equal to the real quotient of x
by y
. Moreover, (- x) / y = x / (- y) = - (x / y)
. Left-associative operator, see Ocaml_operators
for more information.
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
. Left-associative operator, see Ocaml_operators
for more information.
abs x
is the absolute value of x
. On min_int
this is min_int
itself and thus remains negative.
Bitwise operations
Bitwise logical and. Left-associative operator, see Ocaml_operators
for more information.
Bitwise logical or. Left-associative operator, see Ocaml_operators
for more information.
Bitwise logical exclusive or. Left-associative operator, see Ocaml_operators
for more information.
n lsl m
shifts n
to the left by m
bits. The result is unspecified if m < 0
or m > Sys.int_size
. Right-associative operator, see Ocaml_operators
for more information.
n lsr m
shifts n
to the right by m
bits. This is a logical shift: zeroes are inserted regardless of the sign of n
. The result is unspecified if m < 0
or m > Sys.int_size
. Right-associative operator, see Ocaml_operators
for more information.
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 > Sys.int_size
. Right-associative operator, see Ocaml_operators
for more information.
Floating-point arithmetic
OCaml's floating-point numbers follow the IEEE 754 standard, using double precision (64 bits) numbers. Floating-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 instance, 1.0 /. infinity
is 0.0
, basic arithmetic operations (+.
, -.
, *.
, /.
) with nan
as an argument return nan
, ...
Unary negation. You can also write -. e
instead of ~-. e
. Unary operator, see Ocaml_operators
for more information.
Unary addition. You can also write +. e
instead of ~+. e
. Unary operator, see Ocaml_operators
for more information.
Floating-point addition. Left-associative operator, see Ocaml_operators
for more information.
Floating-point subtraction. Left-associative operator, see Ocaml_operators
for more information.
Floating-point multiplication. Left-associative operator, see Ocaml_operators
for more information.
Floating-point division. Left-associative operator, see Ocaml_operators
for more information.
expm1 x
computes exp x -. 1.0
, giving numerically-accurate results even if x
is close to 0.0
.
log1p x
computes log(1.0 +. x)
(natural logarithm), giving numerically-accurate results even if x
is close to 0.0
.
Arc cosine. The argument must fall within the range [-1.0, 1.0]
. Result is in radians and is between 0.0
and pi
.
Arc sine. The argument must fall within the range [-1.0, 1.0]
. Result is in radians and is between -pi/2
and pi/2
.
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
.
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.
Hyperbolic arc cosine. The argument must fall within the range [1.0, inf]
. Result is in radians and is between 0.0
and inf
.
Hyperbolic arc sine. The argument and result range over the entire real line. Result is in radians.
Hyperbolic arc tangent. The argument must fall within the range [-1.0, 1.0]
. Result is in radians and ranges over the entire real line.
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.
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.
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.
mod_float a b
returns the remainder of a
with respect to b
. The returned value is a -. n *. b
, where n
is the quotient a /. b
rounded towards zero to an integer.
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
.
Same as Stdlib.float_of_int
.
Same as Stdlib.int_of_float
.
Truncate the given floating-point number to an integer. The result is unspecified if the argument is nan
or falls outside the range of representable integers.
The difference between 1.0
and the smallest exactly representable floating-point number greater than 1.0
.
The five classes of floating-point numbers, as determined by the Stdlib.classify_float
function.
val classify_float : float -> fpclass
String operations
More string operations are provided in module String
.
String concatenation. Right-associative operator, see Ocaml_operators
for more information.
Character operations
More character operations are provided in module Char
.
Unit operations
Discard the value of its argument and return ()
. For instance, ignore(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
Return the string representation of a boolean. As the returned values may be shared, the user should not modify them directly.
Convert the given string to a boolean.
Return None
if the string is not "true"
or "false"
.
Same as Stdlib.bool_of_string_opt
, but raise Invalid_argument "bool_of_string"
instead of returning None
.
Return the string representation of an integer, in decimal.
Convert the given string to an integer. The string is read in decimal (by default, or if the string begins with 0u
), 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 0u
prefix reads the input as an unsigned integer in the range [0, 2*max_int+1]
. If the input exceeds max_int
it is converted to the signed integer min_int + input - max_int - 1
.
The _
(underscore) character can appear anywhere in the string and is ignored.
Return None
if the given string is not a valid representation of an integer, or if the integer represented exceeds the range of integers representable in type int
.
Same as Stdlib.int_of_string_opt
, but raise Failure "int_of_string"
instead of returning None
.
Return a string representation of a floating-point number.
This conversion can involve a loss of precision. For greater control over the manner in which the number is printed, see Printf
.
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 decimal 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.
Return None
if the given string is not a valid representation of a float.
Same as Stdlib.float_of_string_opt
, but raise Failure "float_of_string"
instead of returning None
.
Pair operations
List operations
More list operations are provided in module List
.
l0 @ l1
appends l1
to l0
. Same function as List.append
. Right-associative operator, see Ocaml_operators
for more information.
Input/output
Note: all input/output functions can raise Sys_error
when the system calls they invoke fail.
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
Print a floating-point number, in decimal, on standard output.
The conversion of the number to a string uses string_of_float
and can involve a loss of precision.
Print a string, followed by a newline character, on standard output and flush standard output.
Print a newline character on standard output, and flush standard output. This can be used to simulate line buffering of standard output.
Output functions on standard error
Print a floating-point number, in decimal, on standard error.
The conversion of the number to a string uses string_of_float
and can involve a loss of precision.
Print a string, followed by a newline character on standard error and flush standard error.
Print a newline character on standard error, and flush standard error.
Input functions on standard input
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.
Flush standard output, then read one line from standard input and convert it to an integer.
Return None
if the line read is not a valid representation of an integer.
Same as Stdlib.read_int_opt
, but raise Failure "int_of_string"
instead of returning None
.
Flush standard output, then read one line from standard input and convert it to a floating-point number.
Return None
if the line read is not a valid representation of a floating-point number.
Same as Stdlib.read_float_opt
, but raise Failure "float_of_string"
instead of returning None
.
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 Stdlib.open_out_gen
and Stdlib.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 truncated 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 Stdlib.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 function behaves like Stdlib.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. Stdlib.open_out
and Stdlib.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 careful about flushing standard output and standard error at the right time.
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.
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
.
val output_substring : out_channel -> string -> int -> int -> unit
Same as output
but take a string as argument instead of a byte sequence.
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 232. The only reliable way to read it back is through the Stdlib.input_binary_int
function. The format is compatible across all machines for a given version of OCaml.
val output_value : out_channel -> 'a -> unit
Write the representation of a structured value of any type to a channel. Circularities and sharing inside the value are detected and preserved. The object can be read back, by the function Stdlib.input_value
. See the description of module Marshal
for more information. Stdlib.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). For files opened in text mode under Windows, the returned position is approximate (owing to end-of-line conversion); in particular, saving the current position with pos_out
, then going back to this position using seek_out
will not work. For this programming idiom to work reliably and portably, the file must be opened in binary mode.
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. Output 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 function has no effect under operating systems that do not distinguish between 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 Stdlib.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 behaves like Stdlib.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 described above. The extra arguments mode
and perm
specify the opening mode and file permissions. Stdlib.open_in
and Stdlib.open_in_bin
are special cases of this function.
val input_char : in_channel -> char
Read one character from the given input channel.
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.
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 Stdlib.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
.
val really_input_string : in_channel -> int -> string
really_input_string ic len
reads len
characters from channel ic
and returns them in a new string.
val input_byte : in_channel -> int
Same as Stdlib.input_char
, but return the 8-bit integer representing the character.
val input_binary_int : in_channel -> int
Read an integer encoded in binary format (4 bytes, big-endian) from the given input channel. See Stdlib.output_binary_int
.
val input_value : in_channel -> 'a
Read the representation of a structured value, as produced by Stdlib.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. For files opened in text mode under Windows, the returned position is approximate (owing to end-of-line conversion); in particular, saving the current position with pos_in
, then going back to this position using seek_in
will not work. For this programming idiom to work reliably and portably, the file must be opened in binary mode.
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 performed 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 function has no effect under operating systems that do not distinguish between 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 allow operating on files whose sizes are greater than max_int
.
References
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
. Unary operator, see Ocaml_operators
for more information.
val (:=) : 'a ref -> 'a -> unit
r := a
stores the value of a
in reference r
. Equivalent to fun r v -> r.contents <- v
. Right-associative operator, see Ocaml_operators
for more information.
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
Operations on format strings
Format strings are character strings with special lexical conventions that defines the functionality of formatted input/output functions. Format strings are used to read data with formatted input functions from module Scanf
and to print data with formatted output functions from modules Printf
and Format
.
Format strings are made of three kinds of entities:
- conversions specifications, introduced by the special 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 specifying 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 output.
There is an additional lexical rule to escape the special characters '%'
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 information about conversion specifications and formatting indications available, 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.formatter
; 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 functions, it is typically the result type of the receiver function.
type ('a, 'b, 'c, 'd, 'e, 'f) format6 =
('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.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.
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 (^^) :
diff --git a/unstable/api/ml/melange/Typemod_hide/index.html b/unstable/api/ml/melange/Typemod_hide/index.html
deleted file mode 100644
index 7e35d6fe2..000000000
--- a/unstable/api/ml/melange/Typemod_hide/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Typemod_hide (melange.Typemod_hide) Module Typemod_hide
val should_hide : Melange_compiler_libs.Typedtree.module_binding -> bool
diff --git a/unstable/api/ml/melange/Vec_int/index.html b/unstable/api/ml/melange/Vec_int/index.html
index e235d6cb2..cc3292a2d 100644
--- a/unstable/api/ml/melange/Vec_int/index.html
+++ b/unstable/api/ml/melange/Vec_int/index.html
@@ -4,4 +4,4 @@
cb_no:(elt -> 'a -> 'a) ->
'a ->
t ->
- 'a
val capacity : t -> int
+ 'aval capacity : t -> int
val mem : int -> t -> bool
Ast_compatible
let const_exp_string:
- ?loc:Melange_compiler_libs.Location.t =>
- ?attrs:list(Melange_compiler_libs.Parsetree.attribute) =>
- ?delimiter:string =>
- string =>
- Melange_compiler_libs.Parsetree.expression;
let apply_simple:
- ?loc:Melange_compiler_libs.Location.t =>
- ?attrs:list(Melange_compiler_libs.Parsetree.attribute) =>
- Melange_compiler_libs.Parsetree.expression =>
- list(Melange_compiler_libs.Parsetree.expression) =>
- Melange_compiler_libs.Parsetree.expression;
Ast_config
let add_structure:
- string =>
- (option(Melange_compiler_libs.Parsetree.expression) => unit) =>
- unit;
let add_signature:
- string =>
- (option(Melange_compiler_libs.Parsetree.expression) => unit) =>
- unit;
let iter_on_bs_config_stru: Melange_compiler_libs.Parsetree.structure => unit;
let iter_on_bs_config_sigi: Melange_compiler_libs.Parsetree.signature => unit;
Ast_extract
module Set_string = Melange_compiler_libs.Depend.String.Set;
let read_parse_and_extract: Ml_binary.kind('a) => 'a => Set_string.t;
Ast_payload
type t = Melange_compiler_libs.Parsetree.payload;
A utility module used when destructuring parsetree attributes, used for compiling FFI attributes and built-in ppx
type label_expr = (lid, Melange_compiler_libs.Parsetree.expression);
type action = (lid, option(Melange_compiler_libs.Parsetree.expression));
let ident_or_record_as_config:
- Melange_compiler_libs.Location.t =>
- t =>
- list(action);
let assert_bool_lit: Melange_compiler_libs.Parsetree.expression => bool;
let table_dispatch:
- Map_string.t((option(Melange_compiler_libs.Parsetree.expression) => 'a)) =>
- action =>
- option('a);
Ast_utf8_string
let classify: char => byte;
Belt.Result
Utilities for result data type.
Belt.Result
is a data type with two variants: Ok
and Error
. Each of these variants can contain data, and those two pieces of data need not have the same data type. Belt.Result
is useful when you need to not only determine whether some data is valid or not (use Belt.Option
for that), but also keep information about the invalid data.
In the examples, we presume the existence of two variables:
let good = Ok 42
-let bad = Error "Invalid data"
let getExn: t('a, 'b) => 'a;
getExn res
when res
is Ok n
, returns n
when res
is Error m
, raise an exception
getExn good = 42;;
+let bad = Error "Invalid data"
let getExn: t('a, 'b) => 'a;
getExn res
when res
is Ok n
, returns n
when res
is Error m
, raise an exception
getExn good = 42;;
getExn bad;; (* raises exception *)
let mapWithDefaultU: t('a, 'c) => 'b => Js.Fn.arity1(('a => 'b)) => 'b;
let mapWithDefault: t('a, 'c) => 'b => ('a => 'b) => 'b;
mapWithDefault res default f
When res
is Ok n
, returns f n
, otherwise default
.
mapWithDefault good 0 (fun x -> x / 2) = 21
mapWithDefault bad 0 (fun x -> x / 2) = 0
let mapU: t('a, 'c) => Js.Fn.arity1(('a => 'b)) => t('b, 'c);
map res f
When res
is Ok n
, returns Ok (f n)
. Otherwise returns res
unchanged. Function f
takes a value of the same type as n
and returns an ordinary value.
let f x = sqrt (float_of_int x)
map (Ok 64) f = Ok 8.0
diff --git a/unstable/api/re/melange/Belt/Set/index.html b/unstable/api/re/melange/Belt/Set/index.html
index fa64bc350..0893ecce7 100644
--- a/unstable/api/re/melange/Belt/Set/index.html
+++ b/unstable/api/re/melange/Belt/Set/index.html
@@ -48,7 +48,7 @@
let acc = ref [] ;;
forEach s0 (fun x -> acc := x !acc);;
!acc = [6;5;3;2];;
let reduceU: t('value, 'id) => 'a => Js.Fn.arity2(('a => 'value => 'a)) => 'a;
let reduce: t('value, 'id) => 'a => ('a => 'value => 'a) => 'a;
In increasing order.
let s0 = fromArray ~id:(module IntCmp) [|5;2;3;5;6|]];;
-reduce s0 [] Bs.List.add = [6;5;3;2];;
let everyU: t('value, 'id) => Js.Fn.arity1(('value => bool)) => bool;
let every: t('value, 'id) => ('value => bool) => bool;
every p s
checks if all elements of the set satisfy the predicate p
. Order unspecified.
let someU: t('value, 'id) => Js.Fn.arity1(('value => bool)) => bool;
let some: t('value, 'id) => ('value => bool) => bool;
some p s
checks if at least one element of the set satisfies the predicate p
.
let keepU: t('value, 'id) => Js.Fn.arity1(('value => bool)) => t('value, 'id);
keep m p
returns the set of all elements in s
that satisfy predicate p
.
let everyU: t('value, 'id) => Js.Fn.arity1(('value => bool)) => bool;
let every: t('value, 'id) => ('value => bool) => bool;
every p s
checks if all elements of the set satisfy the predicate p
. Order unspecified.
let someU: t('value, 'id) => Js.Fn.arity1(('value => bool)) => bool;
let some: t('value, 'id) => ('value => bool) => bool;
some p s
checks if at least one element of the set satisfies the predicate p
.
let keepU: t('value, 'id) => Js.Fn.arity1(('value => bool)) => t('value, 'id);
keep m p
returns the set of all elements in s
that satisfy predicate p
.
let partitionU:
t('value, 'id) =>
Js.Fn.arity1(('value => bool)) =>
(t('value, 'id), t('value, 'id));
let partition:
diff --git a/unstable/api/re/melange/Bs_ast_invariant/index.html b/unstable/api/re/melange/Bs_ast_invariant/index.html
deleted file mode 100644
index c54df9632..000000000
--- a/unstable/api/re/melange/Bs_ast_invariant/index.html
+++ /dev/null
@@ -1,6 +0,0 @@
-
-Bs_ast_invariant (melange.Bs_ast_invariant) Module Bs_ast_invariant
let iter_warnings_on_stru: Melange_compiler_libs.Parsetree.structure => unit;
let iter_warnings_on_sigi: Melange_compiler_libs.Parsetree.signature => unit;
let emit_external_warnings_on_structure:
- Melange_compiler_libs.Parsetree.structure =>
- unit;
let emit_external_warnings_on_signature:
- Melange_compiler_libs.Parsetree.signature =>
- unit;
diff --git a/unstable/api/re/melange/Bs_flow_ast_utils/index.html b/unstable/api/re/melange/Bs_flow_ast_utils/index.html
deleted file mode 100644
index 05802f429..000000000
--- a/unstable/api/re/melange/Bs_flow_ast_utils/index.html
+++ /dev/null
@@ -1,6 +0,0 @@
-
-Bs_flow_ast_utils (melange.Bs_flow_ast_utils) Module Bs_flow_ast_utils
let check_flow_errors:
- loc:Melange_compiler_libs.Location.t =>
- offset:int =>
- list((Js_parser.Loc.t, Js_parser.Parse_error.t)) =>
- unit;
diff --git a/unstable/api/re/melange/Build_reserved/SSet/index.html b/unstable/api/re/melange/Build_reserved/SSet/index.html
deleted file mode 100644
index 0f5f27d8b..000000000
--- a/unstable/api/re/melange/Build_reserved/SSet/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-SSet (melange.Build_reserved.SSet) Module Build_reserved.SSet
diff --git a/unstable/api/re/melange/Build_reserved/index.html b/unstable/api/re/melange/Build_reserved/index.html
deleted file mode 100644
index 34fac3e3d..000000000
--- a/unstable/api/re/melange/Build_reserved/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Build_reserved (melange.Build_reserved) Module Build_reserved
diff --git a/unstable/api/re/melange/Classify_function/index.html b/unstable/api/re/melange/Classify_function/index.html
deleted file mode 100644
index 933b19f36..000000000
--- a/unstable/api/re/melange/Classify_function/index.html
+++ /dev/null
@@ -1,7 +0,0 @@
-
-Classify_function (melange.Classify_function) Module Classify_function
let classify:
- ?check:(Melange_compiler_libs.Location.t, int) =>
- string =>
- Js_raw_info.exp;
let classify_exp:
- Js_parser.Flow_ast.Expression.t(Js_parser.Loc.t, Js_parser.Loc.t) =>
- Js_raw_info.exp;
let classify_stmt: string => Js_raw_info.stmt;
diff --git a/unstable/api/re/melange/Ext_list/index.html b/unstable/api/re/melange/Ext_list/index.html
index cb5a46fb0..4e4da815c 100644
--- a/unstable/api/re/melange/Ext_list/index.html
+++ b/unstable/api/re/melange/Ext_list/index.html
@@ -1,18 +1,12 @@
-Ext_list (melange.Ext_list) Module Ext_list
let combine_array_append:
+Ext_list (melange.Ext_list) Module Ext_list
map_last f xs
will pass true
to f
for the last element, false
otherwise. For empty list, it returns empty
map_last f xs
will pass true
to f
for the last element, false
otherwise. For empty list, it returns empty
split_at n l
will split l
into two lists a,b
, a
will be of length n
, otherwise, it will raise
split_at_last l
It is equivalent to split_at (List.length l - 1) l
length xs = length ys + n
input n should be positive TODO: input checking
stable_group eq lst
Example: Input:
stable_group (=) [1;2;3;4;3]
Output:
[[1];[2];[4];[3;3]]
TODO: this is O(n^2) behavior which could be improved later
find_first_not p lst
if all elements in lst
pass, return None
otherwise return the first element e
as Some e
which fails the predicate
find_opt f l
returns None
if all return None
, otherwise returns the first one.
for_all2_no_exn p xs ys
return true
if all satisfied, false
otherwise or length not equal
f
is applied follow the list order
assoc_by_string default key lst
if key
is found in the list return that val, other unbox the default
, otherwise assert false
+ 'acc;
split_at n l
will split l
into two lists a,b
, a
will be of length n
, otherwise, it will raise
split_at_last l
is equivalent to split_at (List.length l - 1) l
length xs = length ys + n
input n should be positive TODO: input checking
stable_group eq lst
Example: Input:
stable_group (=) [1;2;3;4;3]
Output:
[[1];[2];[4];[3;3]]
TODO: this is O(n^2) behavior which could be improved later
for_all2_no_exn p xs ys
returns true
if all predicates satisfied, false
otherwise or when the list lengths are not equal.
diff --git a/unstable/api/re/melange/Ext_log/index.html b/unstable/api/re/melange/Ext_log/index.html
deleted file mode 100644
index 81c56d407..000000000
--- a/unstable/api/re/melange/Ext_log/index.html
+++ /dev/null
@@ -1,4 +0,0 @@
-
-Ext_log (melange.Ext_log) Module Ext_log
A Poor man's logging utility
Example:
err __LOC__ "xx"
let dwarn: ?__POS__:(string, int, int, int) => logging('a);
diff --git a/unstable/api/re/melange/Ext_path/index.html b/unstable/api/re/melange/Ext_path/index.html
index dc09e53ea..3adbd6f59 100644
--- a/unstable/api/re/melange/Ext_path/index.html
+++ b/unstable/api/re/melange/Ext_path/index.html
@@ -1,5 +1,5 @@
-Ext_path (melange.Ext_path) Module Ext_path
combine path1 path2
1. add some simplifications when concatenating 2. when path2
is absolute, return path2
get_extension "a.txt" = ".txt"
+Ext_path (melange.Ext_path) Module Ext_path
get_extension "a.txt" = ".txt"
get_extension "a" = ""
TODO: could be highly optimized if from
and to
resolve to the same path, a zero-length string is returned Given that two paths are directory
A typical use case is
Filename.concat
(rel_normalized_absolute_path cwd (Filename.dirname a))
(Filename.basename a)
diff --git a/unstable/api/re/melange/Ext_string/index.html b/unstable/api/re/melange/Ext_string/index.html
index 3816c6010..31ae15984 100644
--- a/unstable/api/re/melange/Ext_string/index.html
+++ b/unstable/api/re/melange/Ext_string/index.html
@@ -1,3 +1,2 @@
-Ext_string (melange.Ext_string) Module Ext_string
Extension to the standard library String
module, fixed some bugs like avoiding locale sensitivity
ends_with_then_chop name ext
ends_with_then_chop "a.cmj" ".cmj"
-"a"
This is useful in controlled or file case sensitve system
for_all_from s start p
if start
is negative, it raises, if start
is too large, it returns true
+Ext_string (melange.Ext_string) Module Ext_string
Extension to the standard library String
module, fixed some bugs like avoiding locale sensitivity
for_all_from s start p
if start
is negative, it raises, if start
is too large, it returns true
diff --git a/unstable/api/re/melange/External_arg_spec/index.html b/unstable/api/re/melange/External_arg_spec/index.html
deleted file mode 100644
index da179cbf0..000000000
--- a/unstable/api/re/melange/External_arg_spec/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-External_arg_spec (melange.External_arg_spec) Module External_arg_spec
type attr =
| Poly_var_string of {
}
| Poly_var of {
}
| Int(list((string, int)))
| Arg_cst(cst)
| Fn_uncurry_arity(int)
| Extern_unit
| Nothing
| Ignore
| Unwrap
;
type obj_params = list(obj_param);
type params = list(param);
let cst_obj_literal: string => cst;
let cst_int: int => cst;
let cst_string: string => cst;
let empty_label: label;
let obj_label: string => label;
let optional: bool => string => label;
let dummy: param;
diff --git a/unstable/api/re/melange/External_ffi_types/index.html b/unstable/api/re/melange/External_ffi_types/index.html
deleted file mode 100644
index 3e79e06f3..000000000
--- a/unstable/api/re/melange/External_ffi_types/index.html
+++ /dev/null
@@ -1,6 +0,0 @@
-
-External_ffi_types (melange.External_ffi_types) Module External_ffi_types
type arg_type = External_arg_spec.attr;
type arg_label = External_arg_spec.label;
type external_spec =
| Js_var of {
name: string,
external_module_name: option(external_module_name),
scopes: list(string),
}
| Js_module_as_var(external_module_name)
| Js_module_as_fn of {
external_module_name: external_module_name,
splice: bool,
}
| Js_module_as_class(external_module_name)
| Js_call of {
name: string,
external_module_name: option(external_module_name),
splice: bool,
scopes: list(string),
}
| Js_send of {
name: string,
splice: bool,
pipe: pipe,
js_send_scopes: list(string),
}
| Js_new of {
name: string,
external_module_name: option(external_module_name),
splice: bool,
scopes: list(string),
}
| Js_set of {
}
| Js_get of {
}
| Js_get_index of {
}
| Js_set_index of {
}
;
type t = pri
| Ffi_bs(params, return_wrapper, external_spec)
| Ffi_obj_create(External_arg_spec.obj_params)
| Ffi_inline_const(Lam_constant.t)
| Ffi_normal
;
let check_ffi: ?loc:Melange_compiler_libs.Location.t => external_spec => bool;
let to_string: t => string;
let from_string: string => t;
Note
let ffi_bs: External_arg_spec.params => return_wrapper => external_spec => t;
let ffi_bs_as_prims:
- External_arg_spec.params =>
- return_wrapper =>
- external_spec =>
- list(string);
let ffi_obj_create: External_arg_spec.obj_params => t;
let ffi_obj_as_prims: External_arg_spec.obj_params => list(string);
diff --git a/unstable/api/re/melange/Git_commit/index.html b/unstable/api/re/melange/Git_commit/index.html
deleted file mode 100644
index 1822968aa..000000000
--- a/unstable/api/re/melange/Git_commit/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Git_commit (melange.Git_commit) Module Git_commit
diff --git a/unstable/api/re/melange/Hash_set_poly/index.html b/unstable/api/re/melange/Hash_set_poly/index.html
index 4fdf7f9f8..ba3aa49e6 100644
--- a/unstable/api/re/melange/Hash_set_poly/index.html
+++ b/unstable/api/re/melange/Hash_set_poly/index.html
@@ -1,2 +1,2 @@
-Hash_set_poly (melange.Hash_set_poly) Module Hash_set_poly
let create: int => t('a);
let clear: t('a) => unit;
let reset: t('a) => unit;
let add: t('a) => 'a => unit;
let remove: t('a) => 'a => unit;
let mem: t('a) => 'a => bool;
let iter: t('a) => ('a => unit) => unit;
let to_list: t('a) => list('a);
let length: t('a) => int;
+Hash_set_poly (melange.Hash_set_poly) Module Hash_set_poly
let create: int => t('a);
let clear: t('a) => unit;
let reset: t('a) => unit;
let add: t('a) => 'a => unit;
let remove: t('a) => 'a => unit;
let mem: t('a) => 'a => bool;
let iter: t('a) => ('a => unit) => unit;
let to_list: t('a) => list('a);
let length: t('a) => int;
let fold: t('a) => 'b => ('a => 'b => 'b) => 'b;
let of_array: array('a) => t('a);
let check_add: t('a) => 'a => bool;
diff --git a/unstable/api/re/melange/Int_vec_util/index.html b/unstable/api/re/melange/Int_vec_util/index.html
deleted file mode 100644
index 343817312..000000000
--- a/unstable/api/re/melange/Int_vec_util/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Int_vec_util (melange.Int_vec_util) Module Int_vec_util
let mem: int => Vec_int.t => bool;
diff --git a/unstable/api/re/melange/Js/List/index.html b/unstable/api/re/melange/Js/List/index.html
deleted file mode 100644
index 5ff96f79d..000000000
--- a/unstable/api/re/melange/Js/List/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-List (melange.Js.List) Module Js.List
Provide utilities for list
let length: t('a) => int;
let isEmpty: t('a) => bool;
let hd: t('a) => option('a);
let nth: t('a) => int => option('a);
let mapRev: Js.Fn.arity1(('a => 'b)) => t('a) => t('b);
let map: Js.Fn.arity1(('a => 'b)) => t('a) => t('b);
let iter: Js.Fn.arity1(('a => unit)) => t('a) => unit;
let iteri: Js.Fn.arity2((int => 'a => unit)) => t('a) => unit;
let foldLeft: Js.Fn.arity2(('a => 'b => 'a)) => 'a => list('b) => 'a;
Application order is left to right, tail recurisve
let foldRight: Js.Fn.arity2(('a => 'b => 'b)) => list('a) => 'b => 'b;
Application order is right to left tail-recursive.
let filter: Js.Fn.arity1(('a => bool)) => t('a) => t('a);
let filterMap: Js.Fn.arity1(('a => option('b))) => t('a) => t('b);
let countBy: Js.Fn.arity1(('a => bool)) => list('a) => int;
let init: int => Js.Fn.arity1((int => 'a)) => t('a);
let toVector: t('a) => array('a);
let equal: Js.Fn.arity2(('a => 'a => bool)) => list('a) => list('a) => bool;
diff --git a/unstable/api/re/melange/Js/Null_undefined/index.html b/unstable/api/re/melange/Js/Null_undefined/index.html
deleted file mode 100644
index a702a2692..000000000
--- a/unstable/api/re/melange/Js/Null_undefined/index.html
+++ /dev/null
@@ -1,15 +0,0 @@
-
-Null_undefined (melange.Js.Null_undefined) Module Js.Null_undefined
Contains functionality for dealing with values that can be both null
and undefined
let return: 'a => t('a);
Constructs a value of 'a Js.null_undefined
containing a value of 'a
let isNullable: t('a) => bool;
Returns true
if the given value is null
or undefined
, false
otherwise
let null: t('a);
The null
value of type 'a Js.null_undefined
let undefined: t('a);
The undefined
value of type 'a Js.null_undefined
let bind: t('a) => Js.Fn.arity1(('a => 'b)) => t('b);
Maps the contained value using the given function
If 'a Js.null_undefined
contains a value, that value is unwrapped, mapped to a 'b
using the given function a' -> 'b
, then wrapped back up and returned as 'b Js.null_undefined
let maybeGreetWorld (maybeGreeting: string Js.null_undefined) =
- Js.Undefined.bind maybeGreeting (fun greeting -> greeting ^ " world!")
let iter: t('a) => Js.Fn.arity1(('a => unit)) => unit;
Iterates over the contained value with the given function
If 'a Js.null_undefined
contains a value, that value is unwrapped and applied to the given function.
let maybeSay (maybeMessage: string Js.null_undefined) =
- Js.Null_undefined.iter maybeMessage (fun message -> Js.log message)
let fromOption: option('a) => t('a);
Maps 'a option
to 'a Js.null_undefined
-
- Some a -> return a
- None -> undefined
-
-let from_opt: option('a) => t('a);
let toOption: t('a) => option('a);
Maps 'a Js.null_undefined
to 'a option
-
- return a -> Some a
- undefined -> None
- null -> None
-
-let to_opt: t('a) => option('a);
diff --git a/unstable/api/re/melange/Js/Option/index.html b/unstable/api/re/melange/Js/Option/index.html
deleted file mode 100644
index 76672d841..000000000
--- a/unstable/api/re/melange/Js/Option/index.html
+++ /dev/null
@@ -1,6 +0,0 @@
-
-Option (melange.Js.Option) Module Js.Option
Provide utilities for option
let isSomeValue: Js.Fn.arity2(('a => 'a => bool)) => 'a => option('a) => bool;
let equal:
- Js.Fn.arity2(('a => 'b => bool)) =>
- option('a) =>
- option('b) =>
- bool;
let andThen: Js.Fn.arity1(('a => option('b))) => option('a) => option('b);
let map: Js.Fn.arity1(('a => 'b)) => option('a) => option('b);
let filter: Js.Fn.arity1(('a => bool)) => option('a) => option('a);
diff --git a/unstable/api/re/melange/Js/Result/index.html b/unstable/api/re/melange/Js/Result/index.html
deleted file mode 100644
index e1a71b97d..000000000
--- a/unstable/api/re/melange/Js/Result/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Result (melange.Js.Result) Module Js.Result
Define the interface for result
diff --git a/unstable/api/re/melange/Js/index.html b/unstable/api/re/melange/Js/index.html
index 7301fb080..30640d1d7 100644
--- a/unstable/api/re/melange/Js/index.html
+++ b/unstable/api/re/melange/Js/index.html
@@ -2,4 +2,4 @@
Js (melange.Js) Module Js
This library provides bindings and necessary support for JS FFI. It contains all bindings into Js
namespace.
[| 1;2;3;4|]
|. Js.Array2.map (fun x -> x + 1 )
|. Js.Array2.reduce (+) 0
-|. Js.log
module Fn: { ... };
The same as empty
in Js.Null
will be compiled as null
The same as empty
Js.Undefined
will be compiled as undefined
typeof x
will be compiled as typeof x
in JS Please consider functions in Types
for a type safe way of reflection
operators
unsafe_lt a b
will be compiled as a < b
. It is marked as unsafe, since it is impossible to give a proper semantics for comparision which applies to any type
unsafe_le a b
will be compiled as a <= b
. See also unsafe_lt
unsafe_gt a b
will be compiled as a > b
. See also unsafe_lt
unsafe_ge a b
will be compiled as a >= b
. See also unsafe_lt
Types for JS objects
nullable, value of this type can be either null
or 'a
this type is the same as type t
in Null
value of this type can be either undefined
or 'a
this type is the same as type t
in Undefined
value of this type can be undefined
, null
or 'a
this type is the same as type t
n Null_undefined
type null_undefined(+'a) = nullable('a);
module Array2: { ... };
Provide bindings to Js array
module Exn: { ... };
Provide utilities for dealing with Js exceptions
module Vector: { ... };
module String: { ... };
Provide bindings to JS string
module TypedArray2: { ... };
Provide bindings for JS typed array
nested modules
module Null: { ... };
Provide utilities around 'a null
module Nullable: { ... };
Provide utilities around null_undefined
module Null_undefined: { ... };
module Array: { ... };
Provide bindings to Js array
module String2: { ... };
Provide bindings to JS string
module Re: { ... };
Provide bindings to Js regex expression
module Promise: { ... };
Provide bindings to JS promise
module Date: { ... };
Provide bindings for JS Date
module Dict: { ... };
Provide utilities for JS dictionary object
module Global: { ... };
Provide bindings to JS global functions in global namespace
module Json: { ... };
Provide utilities for json
module Math: { ... };
Provide bindings for JS Math
object
module Obj: { ... };
module Typed_array: { ... };
Provide bindings for JS typed array
module Types: { ... };
Provide utilities for manipulating JS types
module Float: { ... };
Provide utilities for JS float
module Int: { ... };
Provide utilities for int
module Bigint: { ... };
Provide utilities for bigint
module Option: { ... };
Provide utilities for option
module Result: { ... };
Define the interface for result
module List: { ... };
Provide utilities for list
module Console: { ... };
module Set: { ... };
Provides bindings for ES6 Set
module WeakSet: { ... };
Provides bindings for ES6 WeakSet
module Map: { ... };
Provides bindings for ES6 Map
module WeakMap: { ... };
Provides bindings for ES6 WeakMap
+|. Js.log
module Fn: { ... };
The same as empty
in Js.Null
will be compiled as null
The same as empty
Js.Undefined
will be compiled as undefined
typeof x
will be compiled as typeof x
in JS Please consider functions in Types
for a type safe way of reflection
operators
unsafe_lt a b
will be compiled as a < b
. It is marked as unsafe, since it is impossible to give a proper semantics for comparision which applies to any type
unsafe_le a b
will be compiled as a <= b
. See also unsafe_lt
unsafe_gt a b
will be compiled as a > b
. See also unsafe_lt
unsafe_ge a b
will be compiled as a >= b
. See also unsafe_lt
Types for JS objects
nullable, value of this type can be either null
or 'a
this type is the same as type t
in Null
value of this type can be either undefined
or 'a
this type is the same as type t
in Undefined
value of this type can be undefined
, null
or 'a
this type is the same as type t
n Null_undefined
type null_undefined(+'a) = nullable('a);
module Array2: { ... };
Provide bindings to Js array
module Exn: { ... };
Provide utilities for dealing with Js exceptions
module Vector: { ... };
module String: { ... };
Provide bindings to JS string
module TypedArray2: { ... };
Provide bindings for JS typed array
nested modules
module Null: { ... };
Provide utilities around 'a null
module Nullable: { ... };
Provide utilities around null_undefined
module Array: { ... };
Provide bindings to Js array
module String2: { ... };
Provide bindings to JS string
module Re: { ... };
Provide bindings to Js regex expression
module Promise: { ... };
Provide bindings to JS promise
module Date: { ... };
Provide bindings for JS Date
module Dict: { ... };
Provide utilities for JS dictionary object
module Global: { ... };
Provide bindings to JS global functions in global namespace
module Json: { ... };
Provide utilities for json
module Math: { ... };
Provide bindings for JS Math
object
module Obj: { ... };
module Typed_array: { ... };
Provide bindings for JS typed array
module Types: { ... };
Provide utilities for manipulating JS types
module Float: { ... };
Provide utilities for JS float
module Int: { ... };
Provide utilities for int
module Bigint: { ... };
Provide utilities for bigint
module Console: { ... };
module Set: { ... };
Provides bindings for ES6 Set
module WeakSet: { ... };
Provides bindings for ES6 WeakSet
module Map: { ... };
Provides bindings for ES6 Map
module WeakMap: { ... };
Provides bindings for ES6 WeakMap
diff --git a/unstable/api/re/melange/Js_config/index.html b/unstable/api/re/melange/Js_config/index.html
deleted file mode 100644
index 67ccaf6a6..000000000
--- a/unstable/api/re/melange/Js_config/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Js_config (melange.Js_config) Module Js_config
return package_name
and path
when in script mode:
diff --git a/unstable/api/re/melange/Js_raw_info/index.html b/unstable/api/re/melange/Js_raw_info/index.html
deleted file mode 100644
index c8da82a07..000000000
--- a/unstable/api/re/melange/Js_raw_info/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Js_raw_info (melange.Js_raw_info) Module Js_raw_info
diff --git a/unstable/api/re/melange/Lam/index.html b/unstable/api/re/melange/Lam/index.html
deleted file mode 100644
index 1111b0483..000000000
--- a/unstable/api/re/melange/Lam/index.html
+++ /dev/null
@@ -1,24 +0,0 @@
-
-Lam (melange.Lam) Module Lam
type ap_info = {
ap_loc: Melange_compiler_libs.Location.t,
ap_inlined: Melange_compiler_libs.Lambda.inline_attribute,
ap_status: apply_status,
};
type lambda_switch = {
sw_consts_full: bool,
sw_consts: list((int, t)),
sw_blocks_full: bool,
sw_blocks: list((int, t)),
sw_failaction: option(t),
sw_names: option(Melange_compiler_libs.Lambda.switch_names),
};
and lfunction = {
arity: int,
params: list(ident),
body: t,
attr: Melange_compiler_libs.Lambda.function_attribute,
};
and prim_info = pri {
primitive: Lam_primitive.t,
args: list(t),
loc: Melange_compiler_libs.Location.t,
};
and t = pri
| Lvar(ident)
| Lmutvar(ident)
| Lglobal_module(ident)
| Lconst(Lam_constant.t)
| Lapply(apply)
| Lfunction(lfunction)
| Llet(Lam_compat.let_kind, ident, t, t)
| Lmutlet(ident, t, t)
| Lletrec(list((ident, t)), t)
| Lprim(prim_info)
| Lswitch(t, lambda_switch)
| Lstringswitch(t, list((string, t)), option(t))
| Lstaticraise(int, list(t))
| Lstaticcatch(t, (int, list(ident)), t)
| Ltrywith(t, ident, t)
| Lifthenelse(t, t, t)
| Lsequence(t, t)
| Lwhile(t, t)
| Lfor(ident, t, t, Asttypes.direction_flag, t)
| Lassign(ident, t)
| Lsend(Melange_compiler_libs.Lambda.meth_kind, t, t, list(t), Melange_compiler_libs.Location.t)
| Lifused(ident, t)
;
let handle_bs_non_obj_ffi:
- External_arg_spec.params =>
- External_ffi_types.return_wrapper =>
- External_ffi_types.external_spec =>
- list(t) =>
- Melange_compiler_libs.Location.t =>
- string =>
- t;
let const: Lam_constant.t => t;
let function_:
- attr:Melange_compiler_libs.Lambda.function_attribute =>
- arity:int =>
- params:list(ident) =>
- body:t =>
- t;
let let_: Lam_compat.let_kind => ident => t => t => t;
let switch: t => lambda_switch => t;
constant folding
let false_: t;
let unit: t;
let not_: Melange_compiler_libs.Location.t => t => t;
constant folding
let send:
- Melange_compiler_libs.Lambda.meth_kind =>
- t =>
- t =>
- list(t) =>
- Melange_compiler_libs.Location.t =>
- t;
let prim:
- primitive:Lam_primitive.t =>
- args:list(t) =>
- Melange_compiler_libs.Location.t =>
- t;
constant folding
diff --git a/unstable/api/re/melange/Lam_compat/index.html b/unstable/api/re/melange/Lam_compat/index.html
deleted file mode 100644
index 3dfdbc79c..000000000
--- a/unstable/api/re/melange/Lam_compat/index.html
+++ /dev/null
@@ -1,5 +0,0 @@
-
-Lam_compat (melange.Lam_compat) Module Lam_compat
type field_dbg_info = Melange_compiler_libs.Lambda.field_dbg_info =
| Fld_na(string)
| Fld_record of {
}
| Fld_module of {
}
| Fld_record_inline of {
}
| Fld_record_extension of {
}
| Fld_tuple
| Fld_poly_var_tag
| Fld_poly_var_content
| Fld_extension
| Fld_variant
| Fld_cons
| Fld_array
;
let str_of_field_info: field_dbg_info => option(string);
type set_field_dbg_info = Melange_compiler_libs.Lambda.set_field_dbg_info =
| Fld_set_na
| Fld_record_set(string)
| Fld_record_inline_set(string)
| Fld_record_extension_set(string)
;
let cmp_int32: integer_comparison => int32 => int32 => bool;
let cmp_int64: integer_comparison => int64 => int64 => bool;
let cmp_nativeint: integer_comparison => nativeint => nativeint => bool;
let cmp_float: float_comparison => float => float => bool;
let cmp_int: integer_comparison => int => int => bool;
let eq_comparison: integer_comparison => integer_comparison => bool;
let eq_float_comparison: float_comparison => float_comparison => bool;
let eq_boxed_integer: boxed_integer => boxed_integer => bool;
let eq_compile_time_constant:
- compile_time_constant =>
- compile_time_constant =>
- bool;
diff --git a/unstable/api/re/melange/Lam_constant/index.html b/unstable/api/re/melange/Lam_constant/index.html
deleted file mode 100644
index 1a96bd438..000000000
--- a/unstable/api/re/melange/Lam_constant/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Lam_constant (melange.Lam_constant) Module Lam_constant
let string_of_pointer_info: pointer_info => option(string);
type t =
| Const_js_null
| Const_js_undefined
| Const_js_true
| Const_js_false
| Const_int of {
i: int32,
comment: pointer_info,
}
| Const_char(char)
| Const_string of {
}
| Const_float(string)
| Const_int64(int64)
| Const_pointer(string)
| Const_block(int, Lam_tag_info.t, list(t))
| Const_float_array(list(string))
| Const_some(t)
| Const_module_alias
;
let lam_none: t;
diff --git a/unstable/api/re/melange/Lam_methname/index.html b/unstable/api/re/melange/Lam_methname/index.html
deleted file mode 100644
index 91f376c7f..000000000
--- a/unstable/api/re/melange/Lam_methname/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Lam_methname (melange.Lam_methname) Module Lam_methname
diff --git a/unstable/api/re/melange/Lam_primitive/index.html b/unstable/api/re/melange/Lam_primitive/index.html
deleted file mode 100644
index 43ccd8ff4..000000000
--- a/unstable/api/re/melange/Lam_primitive/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Lam_primitive (melange.Lam_primitive) Module Lam_primitive
type t =
| Pbytes_to_string
| Pbytes_of_string
| Pmakeblock(int, Lam_tag_info.t, Asttypes.mutable_flag)
| Pfield(int, Melange_compiler_libs.Lambda.field_dbg_info)
| Psetfield(int, Melange_compiler_libs.Lambda.set_field_dbg_info)
| Pduprecord(record_representation)
| Plazyforce
| Pccall of {
}
| Pjs_call of {
prim_name: string,
arg_types: External_arg_spec.params,
ffi: External_ffi_types.external_spec,
}
| Pjs_object_create(External_arg_spec.obj_params)
| Praise
| Psequand
| Psequor
| Pnot
| Pnegint
| Paddint
| Psubint
| Pmulint
| Pdivint
| Pmodint
| Pandint
| Porint
| Pxorint
| Plslint
| Plsrint
| Pasrint
| Poffsetint(int)
| Poffsetref(int)
| Pintoffloat
| Pfloatofint
| Pnegfloat
| Paddfloat
| Psubfloat
| Pmulfloat
| Pdivfloat
| Pintcomp(Lam_compat.integer_comparison)
| Pfloatcomp(Lam_compat.float_comparison)
| Pjscomp(Lam_compat.integer_comparison)
| Pint64comp(Lam_compat.integer_comparison)
| Pjs_apply
| Pjs_runtime_apply
| Pstringlength
| Pstringrefu
| Pstringrefs
| Pstringadd
| Pbyteslength
| Pbytesrefu
| Pbytessetu
| Pbytesrefs
| Pbytessets
| Pbytes_load_16(bool)
| Pbytes_load_32(bool)
| Pbytes_load_64(bool)
| Pbytes_set_16(bool)
| Pbytes_set_32(bool)
| Pbytes_set_64(bool)
| Pmakearray
| Parraylength
| Parrayrefu
| Parraysetu
| Parrayrefs
| Parraysets
| Pisint
| Pis_poly_var_const
| Pisout(int)
| Pint64ofint
| Pintofint64
| Pnegint64
| Paddint64
| Psubint64
| Pmulint64
| Pdivint64
| Pmodint64
| Pandint64
| Porint64
| Pxorint64
| Plslint64
| Plsrint64
| Pasrint64
| Pctconst(Lam_compat.compile_time_constant)
| Pbswap16
| Pbbswap(Lam_compat.boxed_integer)
| Pdebugger
| Pjs_unsafe_downgrade of {
name: string,
setter: bool,
loc: Melange_compiler_libs.Location.t,
}
| Pinit_mod
| Pupdate_mod
| Praw_js_code(Js_raw_info.t)
| Pjs_fn_make(int)
| Pvoid_run
| Pfull_apply
| Pjs_fn_method
| Pundefined_to_opt
| Pnull_to_opt
| Pnull_undefined_to_opt
| Pis_null
| Pis_undefined
| Pis_null_undefined
| Pjs_typeof
| Pjs_function_length
| Pcaml_obj_length
| Pwrap_exn
| Pcreate_extension(string)
| Pis_not_none
| Pval_from_option
| Pval_from_option_not_nest
| Psome
| Psome_not_nest
| Pfield_computed
| Psetfield_computed
;
diff --git a/unstable/api/re/melange/Lam_tag_info/index.html b/unstable/api/re/melange/Lam_tag_info/index.html
deleted file mode 100644
index 1c193d5c9..000000000
--- a/unstable/api/re/melange/Lam_tag_info/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Lam_tag_info (melange.Lam_tag_info) Module Lam_tag_info
diff --git a/unstable/api/re/melange/Literals/index.html b/unstable/api/re/melange/Literals/index.html
deleted file mode 100644
index ecc88ab7f..000000000
--- a/unstable/api/re/melange/Literals/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Literals (melange.Literals) Module Literals
diff --git a/unstable/api/re/melange/Mel_exception/index.html b/unstable/api/re/melange/Mel_exception/index.html
deleted file mode 100644
index 529477532..000000000
--- a/unstable/api/re/melange/Mel_exception/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Mel_exception (melange.Mel_exception) Module Mel_exception
let error: error => 'a;
diff --git a/unstable/api/re/melange/Melange_ffi/Classify_function/index.html b/unstable/api/re/melange/Melange_ffi/Classify_function/index.html
new file mode 100644
index 000000000..e1139372a
--- /dev/null
+++ b/unstable/api/re/melange/Melange_ffi/Classify_function/index.html
@@ -0,0 +1,7 @@
+
+Classify_function (melange.Melange_ffi.Classify_function) Module Melange_ffi.Classify_function
let classify:
+ ?check:(Melange_compiler_libs.Location.t, int) =>
+ string =>
+ Js_raw_info.exp;
let classify_exp:
+ Js_parser.Flow_ast.Expression.t(Js_parser.Loc.t, Js_parser.Loc.t) =>
+ Js_raw_info.exp;
let classify_stmt: string => Js_raw_info.stmt;
diff --git a/unstable/api/re/melange/Melange_ffi/External_arg_spec/index.html b/unstable/api/re/melange/Melange_ffi/External_arg_spec/index.html
new file mode 100644
index 000000000..32b82b4fb
--- /dev/null
+++ b/unstable/api/re/melange/Melange_ffi/External_arg_spec/index.html
@@ -0,0 +1,2 @@
+
+External_arg_spec (melange.Melange_ffi.External_arg_spec) Module Melange_ffi.External_arg_spec
type attr =
| Poly_var_string of {
}
| Poly_var of {
}
| Int(list((string, int)))
| Arg_cst(cst)
| Fn_uncurry_arity(int)
| Extern_unit
| Nothing
| Ignore
| Unwrap
;
type obj_params = list(obj_param);
type params = list(param);
let cst_obj_literal: string => cst;
let cst_int: int => cst;
let cst_string: string => cst;
let empty_label: label;
let obj_label: string => label;
let optional: bool => string => label;
let dummy: param;
diff --git a/unstable/api/re/melange/Melange_ffi/External_ffi_types/Literals/index.html b/unstable/api/re/melange/Melange_ffi/External_ffi_types/Literals/index.html
new file mode 100644
index 000000000..c5919c40e
--- /dev/null
+++ b/unstable/api/re/melange/Melange_ffi/External_ffi_types/Literals/index.html
@@ -0,0 +1,2 @@
+
+Literals (melange.Melange_ffi.External_ffi_types.Literals) Module External_ffi_types.Literals
diff --git a/unstable/api/re/melange/Melange_ffi/External_ffi_types/index.html b/unstable/api/re/melange/Melange_ffi/External_ffi_types/index.html
new file mode 100644
index 000000000..df77e40b7
--- /dev/null
+++ b/unstable/api/re/melange/Melange_ffi/External_ffi_types/index.html
@@ -0,0 +1,6 @@
+
+External_ffi_types (melange.Melange_ffi.External_ffi_types) Module Melange_ffi.External_ffi_types
module Literals: { ... };
type arg_type = External_arg_spec.attr;
type arg_label = External_arg_spec.label;
type external_spec =
| Js_var of {
name: string,
external_module_name: option(external_module_name),
scopes: list(string),
}
| Js_module_as_var(external_module_name)
| Js_module_as_fn of {
external_module_name: external_module_name,
splice: bool,
}
| Js_module_as_class(external_module_name)
| Js_call of {
name: string,
external_module_name: option(external_module_name),
splice: bool,
scopes: list(string),
}
| Js_send of {
name: string,
splice: bool,
pipe: pipe,
js_send_scopes: list(string),
}
| Js_new of {
name: string,
external_module_name: option(external_module_name),
splice: bool,
scopes: list(string),
}
| Js_set of {
}
| Js_get of {
}
| Js_get_index of {
}
| Js_set_index of {
}
;
type t = pri
| Ffi_bs(params, return_wrapper, external_spec)
| Ffi_obj_create(External_arg_spec.obj_params)
| Ffi_inline_const(Lam_constant.t)
| Ffi_normal
;
let check_ffi: ?loc:Melange_compiler_libs.Location.t => external_spec => bool;
let to_string: t => string;
let from_string: string => t;
Note
let ffi_bs: External_arg_spec.params => return_wrapper => external_spec => t;
let ffi_bs_as_prims:
+ External_arg_spec.params =>
+ return_wrapper =>
+ external_spec =>
+ list(string);
let ffi_obj_create: External_arg_spec.obj_params => t;
let ffi_obj_as_prims: External_arg_spec.obj_params => list(string);
diff --git a/unstable/api/re/melange/Melange_ffi/Flow_ast_utils/index.html b/unstable/api/re/melange/Melange_ffi/Flow_ast_utils/index.html
new file mode 100644
index 000000000..539a90e20
--- /dev/null
+++ b/unstable/api/re/melange/Melange_ffi/Flow_ast_utils/index.html
@@ -0,0 +1,6 @@
+
+Flow_ast_utils (melange.Melange_ffi.Flow_ast_utils) Module Melange_ffi.Flow_ast_utils
let check_flow_errors:
+ loc:Melange_compiler_libs.Location.t =>
+ offset:int =>
+ list((Js_parser.Loc.t, Js_parser.Parse_error.t)) =>
+ unit;
diff --git a/unstable/api/re/melange/Melange_ffi/Js_raw_info/index.html b/unstable/api/re/melange/Melange_ffi/Js_raw_info/index.html
new file mode 100644
index 000000000..fb1c8318b
--- /dev/null
+++ b/unstable/api/re/melange/Melange_ffi/Js_raw_info/index.html
@@ -0,0 +1,2 @@
+
+Js_raw_info (melange.Melange_ffi.Js_raw_info) Module Melange_ffi.Js_raw_info
diff --git a/unstable/api/re/melange/Melange_ffi/Lam_constant/index.html b/unstable/api/re/melange/Melange_ffi/Lam_constant/index.html
new file mode 100644
index 000000000..c35db3ccf
--- /dev/null
+++ b/unstable/api/re/melange/Melange_ffi/Lam_constant/index.html
@@ -0,0 +1,2 @@
+
+Lam_constant (melange.Melange_ffi.Lam_constant) Module Melange_ffi.Lam_constant
let string_of_pointer_info: pointer_info => option(string);
type t =
| Const_js_null
| Const_js_undefined
| Const_js_true
| Const_js_false
| Const_int of {
i: int32,
comment: pointer_info,
}
| Const_char(char)
| Const_string of {
}
| Const_float(string)
| Const_int64(int64)
| Const_pointer(string)
| Const_block(int, Lam_tag_info.t, list(t))
| Const_float_array(list(string))
| Const_some(t)
| Const_module_alias
;
let lam_none: t;
diff --git a/unstable/api/re/melange/Melange_ffi/Lam_methname/index.html b/unstable/api/re/melange/Melange_ffi/Lam_methname/index.html
new file mode 100644
index 000000000..81411d433
--- /dev/null
+++ b/unstable/api/re/melange/Melange_ffi/Lam_methname/index.html
@@ -0,0 +1,2 @@
+
+Lam_methname (melange.Melange_ffi.Lam_methname) Module Melange_ffi.Lam_methname
diff --git a/unstable/api/re/melange/Melange_ffi/Lam_tag_info/index.html b/unstable/api/re/melange/Melange_ffi/Lam_tag_info/index.html
new file mode 100644
index 000000000..04ea3eac0
--- /dev/null
+++ b/unstable/api/re/melange/Melange_ffi/Lam_tag_info/index.html
@@ -0,0 +1,2 @@
+
+Lam_tag_info (melange.Melange_ffi.Lam_tag_info) Module Melange_ffi.Lam_tag_info
diff --git a/unstable/api/re/melange/Melange_ffi/Utf8_string/index.html b/unstable/api/re/melange/Melange_ffi/Utf8_string/index.html
new file mode 100644
index 000000000..121ddb0b0
--- /dev/null
+++ b/unstable/api/re/melange/Melange_ffi/Utf8_string/index.html
@@ -0,0 +1,2 @@
+
+Utf8_string (melange.Melange_ffi.Utf8_string) Module Melange_ffi.Utf8_string
let classify: char => byte;
diff --git a/unstable/api/re/melange/Melange_ffi/index.html b/unstable/api/re/melange/Melange_ffi/index.html
new file mode 100644
index 000000000..c9568e36f
--- /dev/null
+++ b/unstable/api/re/melange/Melange_ffi/index.html
@@ -0,0 +1,2 @@
+
+Melange_ffi (melange.Melange_ffi) Module Melange_ffi
module Classify_function: { ... };
module External_arg_spec: { ... };
module External_ffi_types: { ... };
module Flow_ast_utils: { ... };
module Js_raw_info: { ... };
module Lam_constant: { ... };
module Lam_methname: { ... };
module Lam_tag_info: { ... };
module Utf8_string: { ... };
diff --git a/unstable/api/re/melange/Melange_ppx/Ast_literal/index.html b/unstable/api/re/melange/Melange_ppx/Ast_literal/index.html
index a0b249ca6..59ec9ff63 100644
--- a/unstable/api/re/melange/Melange_ppx/Ast_literal/index.html
+++ b/unstable/api/re/melange/Melange_ppx/Ast_literal/index.html
@@ -1,2 +1,2 @@
-Ast_literal (melange.Melange_ppx.Ast_literal) Module Melange_ppx.Ast_literal
let predef_prefix_ident: t;
let predef_option: t;
let predef_some: t;
let predef_none: t;
let js_fn: t;
let js_internal_full_apply: t;
let opaque: t;
let js_oo: t;
let js_meth: t;
let js_meth_callback: t;
let js_obj: t;
let ignore_id: t;
let js_null: t;
let js_undefined: t;
let js_null_undefined: t;
let js_re_id: t;
let js_internal: t;
+Ast_literal (melange.Melange_ppx.Ast_literal) Module Melange_ppx.Ast_literal
let js_fn: t;
let js_internal: t;
let js_internal_full_apply: t;
let js_meth: t;
let js_meth_callback: t;
let js_null: t;
let js_null_undefined: t;
let js_obj: t;
let js_oo: t;
let js_re_id: t;
let js_undefined: t;
let opaque: t;
let predef_some: t;
let predef_none: t;
let unsafe_downgrade: t;
diff --git a/unstable/api/re/melange/Melange_version/index.html b/unstable/api/re/melange/Melange_version/index.html
deleted file mode 100644
index 83a01dc29..000000000
--- a/unstable/api/re/melange/Melange_version/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Melange_version (melange.Melange_version) Module Melange_version
diff --git a/unstable/api/re/melange/Ml_binary/index.html b/unstable/api/re/melange/Ml_binary/index.html
deleted file mode 100644
index 21a0b4e48..000000000
--- a/unstable/api/re/melange/Ml_binary/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Ml_binary (melange.Ml_binary) Module Ml_binary
type kind(_) =
| Ml : kind(Melange_compiler_libs.Parsetree.structure)
| Mli : kind(Melange_compiler_libs.Parsetree.signature)
;
let magic_of_kind: kind('a) => string;
diff --git a/unstable/api/re/melange/Stdlib/index.html b/unstable/api/re/melange/Stdlib/index.html
index f2f318705..bdb83752a 100644
--- a/unstable/api/re/melange/Stdlib/index.html
+++ b/unstable/api/re/melange/Stdlib/index.html
@@ -1,5 +1,5 @@
-Stdlib (melange.Stdlib) Module Stdlib
The OCaml Standard library.
This module is automatically opened at the beginning of each compilation. All components of this module can therefore be referred by their short name, without prefixing them by Stdlib
.
In particular, it provides the basic operations over the built-in types (numbers, booleans, byte sequences, strings, exceptions, references, lists, arrays, input-output channels, ...) and the standard library modules.
Exceptions
The Exit
exception is not raised by any library function. It is provided for use in your programs.
Exception raised when none of the cases of a pattern-matching apply. The arguments are the location of the match keyword in the source code (file name, line number, column number).
Exception raised when an assertion fails. The arguments are the location of the assert keyword in the source code (file name, line number, column number).
Exception raised by library functions to signal that the given arguments do not make sense. The string gives some information to the programmer. As a general rule, this exception should not be caught, it denotes a programming error and the code should be modified not to trigger it.
Exception raised by library functions to signal that they are undefined on the given arguments. The string is meant to give some information to the programmer; you must not pattern match on the string literal because it may change in future versions (use Failure _ instead).
Exception raised by search functions when the desired object could not be found.
Exception raised by the garbage collector when there is insufficient memory to complete the computation. (Not reliable for allocations on the minor heap.)
Exception raised by the bytecode interpreter when the evaluation stack reaches its maximal size. This often indicates infinite or excessively deep recursion in the user's program.
Before 4.10, it was not fully implemented by the native-code compiler.
Exception raised by the input/output functions to report an operating system error. The string is meant to give some information to the programmer; you must not pattern match on the string literal because it may change in future versions (use Sys_error _ instead).
Exception raised by input functions to signal that the end of file has been reached.
Exception raised by integer division and remainder operations when their second argument is zero.
A special case of Sys_error raised when no I/O is possible on a non-blocking I/O channel.
Exception raised when an ill-founded recursive module definition is evaluated. The arguments are the location of the definition in the source code (file name, line number, column number).
Comparisons
e1 = e2
tests for structural equality of e1
and e2
. Mutable structures (e.g. references and arrays) are equal if and only if their current 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. Left-associative operator, see Ocaml_operators
for more information.
Negation of Stdlib.(=)
. Left-associative operator, see Ocaml_operators
for more information.
See Stdlib.(>=)
. Left-associative operator, see Ocaml_operators
for more information.
See Stdlib.(>=)
. Left-associative operator, see Ocaml_operators
for more information.
See Stdlib.(>=)
. Left-associative operator, see Ocaml_operators
for more information.
Structural ordering functions. These functions coincide with the usual orderings over integers, characters, strings, byte sequences and floating-point numbers, and extend them to a total ordering over all types. The ordering is compatible with ( = )
. As in the case of ( = )
, mutable structures are compared by contents. Comparison between functional values raises Invalid_argument
. Comparison between cyclic structures may not terminate. Left-associative operator, see Ocaml_operators
for more information.
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 ordering implemented by compare
is compatible with the comparison predicates =
, <
and >
defined above, with one difference on the treatment of the float value Stdlib.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 total ordering relation.
compare
applied to functional values may raise Invalid_argument
. compare
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 Array.sort
functions.
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
. Left-associative operator, see Ocaml_operators
for more information.
Negation of Stdlib.(==)
. Left-associative operator, see Ocaml_operators
for more information.
Boolean operations
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. Right-associative operator, see Ocaml_operators
for more information.
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. Right-associative operator, see Ocaml_operators
for more information.
Debugging
__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".
__LINE__
returns the line number at which this expression appears in the file currently being parsed by the compiler.
__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 character position in the line.
__FUNCTION__
returns the name of the current function or method, including any enclosing modules or classes.
__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 standard error format of OCaml: "File %S, line %d, characters %d-%d".
__LINE_OF__ expr
returns a pair (line, expr)
, where line
is the line number at which the expression expr
appears in the file currently being parsed by the compiler.
__POS_OF__ expr
returns a pair (loc,expr)
, where loc
is a tuple (file,lnum,cnum,enum)
corresponding to the location at which the expression expr
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 character position in the line.
Composition operators
Reverse-application operator: x |> f |> g
is exactly equivalent to g (f (x))
. Left-associative operator, see Ocaml_operators
for more information.
Application operator: g @@ f @@ x
is exactly equivalent to g (f (x))
. Right-associative operator, see Ocaml_operators
for more information.
Integer arithmetic
Integers are Sys.int_size
bits wide. All operations are taken modulo 2Sys.int_size
. They do not fail on overflow.
Unary negation. You can also write - e
instead of ~- e
. Unary operator, see Ocaml_operators
for more information.
Unary addition. You can also write + e
instead of ~+ e
. Unary operator, see Ocaml_operators
for more information.
Integer addition. Left-associative operator, see Ocaml_operators
for more information.
Integer subtraction. Left-associative operator, , see Ocaml_operators
for more information.
Integer multiplication. Left-associative operator, see Ocaml_operators
for more information.
Integer division. Integer division rounds the real quotient of its arguments towards zero. More precisely, if x >= 0
and y > 0
, x / y
is the greatest integer less than or equal to the real quotient of x
by y
. Moreover, (- x) / y = x / (- y) = - (x / y)
. Left-associative operator, see Ocaml_operators
for more information.
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
. Left-associative operator, see Ocaml_operators
for more information.
abs x
is the absolute value of x
. On min_int
this is min_int
itself and thus remains negative.
Bitwise operations
Bitwise logical and. Left-associative operator, see Ocaml_operators
for more information.
Bitwise logical or. Left-associative operator, see Ocaml_operators
for more information.
Bitwise logical exclusive or. Left-associative operator, see Ocaml_operators
for more information.
n lsl m
shifts n
to the left by m
bits. The result is unspecified if m < 0
or m > Sys.int_size
. Right-associative operator, see Ocaml_operators
for more information.
n lsr m
shifts n
to the right by m
bits. This is a logical shift: zeroes are inserted regardless of the sign of n
. The result is unspecified if m < 0
or m > Sys.int_size
. Right-associative operator, see Ocaml_operators
for more information.
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 > Sys.int_size
. Right-associative operator, see Ocaml_operators
for more information.
Floating-point arithmetic
OCaml's floating-point numbers follow the IEEE 754 standard, using double precision (64 bits) numbers. Floating-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 instance, 1.0 /. infinity
is 0.0
, basic arithmetic operations (+.
, -.
, *.
, /.
) with nan
as an argument return nan
, ...
Unary negation. You can also write -. e
instead of ~-. e
. Unary operator, see Ocaml_operators
for more information.
Unary addition. You can also write +. e
instead of ~+. e
. Unary operator, see Ocaml_operators
for more information.
Floating-point addition. Left-associative operator, see Ocaml_operators
for more information.
Floating-point subtraction. Left-associative operator, see Ocaml_operators
for more information.
Floating-point multiplication. Left-associative operator, see Ocaml_operators
for more information.
Floating-point division. Left-associative operator, see Ocaml_operators
for more information.
expm1 x
computes exp x -. 1.0
, giving numerically-accurate results even if x
is close to 0.0
.
log1p x
computes log(1.0 +. x)
(natural logarithm), giving numerically-accurate results even if x
is close to 0.0
.
Arc cosine. The argument must fall within the range [-1.0, 1.0]
. Result is in radians and is between 0.0
and pi
.
Arc sine. The argument must fall within the range [-1.0, 1.0]
. Result is in radians and is between -pi/2
and pi/2
.
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
.
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.
Hyperbolic arc cosine. The argument must fall within the range [1.0, inf]
. Result is in radians and is between 0.0
and inf
.
Hyperbolic arc sine. The argument and result range over the entire real line. Result is in radians.
Hyperbolic arc tangent. The argument must fall within the range [-1.0, 1.0]
. Result is in radians and ranges over the entire real line.
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.
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.
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.
mod_float a b
returns the remainder of a
with respect to b
. The returned value is a -. n *. b
, where n
is the quotient a /. b
rounded towards zero to an integer.
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
.
Same as Stdlib.float_of_int
.
Same as Stdlib.int_of_float
.
Truncate the given floating-point number to an integer. The result is unspecified if the argument is nan
or falls outside the range of representable integers.
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 Stdlib.classify_float
function.
let classify_float: float => fpclass;
String operations
More string operations are provided in module String
.
String concatenation. Right-associative operator, see Ocaml_operators
for more information.
Character operations
More character operations are provided in module Char
.
Unit operations
Discard the value of its argument and return ()
. For instance, ignore(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
Return the string representation of a boolean. As the returned values may be shared, the user should not modify them directly.
Convert the given string to a boolean.
Return None
if the string is not "true"
or "false"
.
Same as Stdlib.bool_of_string_opt
, but raise Invalid_argument "bool_of_string"
instead of returning None
.
Return the string representation of an integer, in decimal.
Convert the given string to an integer. The string is read in decimal (by default, or if the string begins with 0u
), 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 0u
prefix reads the input as an unsigned integer in the range [0, 2*max_int+1]
. If the input exceeds max_int
it is converted to the signed integer min_int + input - max_int - 1
.
The _
(underscore) character can appear anywhere in the string and is ignored.
Return None
if the given string is not a valid representation of an integer, or if the integer represented exceeds the range of integers representable in type int
.
Same as Stdlib.int_of_string_opt
, but raise Failure "int_of_string"
instead of returning None
.
Return a string representation of a floating-point number.
This conversion can involve a loss of precision. For greater control over the manner in which the number is printed, see Printf
.
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 decimal 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.
Return None
if the given string is not a valid representation of a float.
Same as Stdlib.float_of_string_opt
, but raise Failure "float_of_string"
instead of returning None
.
Pair operations
List operations
More list operations are provided in module List
.
l0 @ l1
appends l1
to l0
. Same function as List.append
. Right-associative operator, see Ocaml_operators
for more information.
Input/output
Note: all input/output functions can raise Sys_error
when the system calls they invoke fail.
let stdin: in_channel;
The standard input for the process.
let stdout: out_channel;
The standard output for the process.
let stderr: out_channel;
The standard error output for the process.
Output functions on standard output
Print a floating-point number, in decimal, on standard output.
The conversion of the number to a string uses string_of_float
and can involve a loss of precision.
Print a string, followed by a newline character, on standard output and flush standard output.
Print a newline character on standard output, and flush standard output. This can be used to simulate line buffering of standard output.
Output functions on standard error
Print a floating-point number, in decimal, on standard error.
The conversion of the number to a string uses string_of_float
and can involve a loss of precision.
Print a string, followed by a newline character on standard error and flush standard error.
Print a newline character on standard error, and flush standard error.
Input functions on standard input
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.
Flush standard output, then read one line from standard input and convert it to an integer.
Return None
if the line read is not a valid representation of an integer.
Same as Stdlib.read_int_opt
, but raise Failure "int_of_string"
instead of returning None
.
Flush standard output, then read one line from standard input and convert it to a floating-point number.
Return None
if the line read is not a valid representation of a floating-point number.
Same as Stdlib.read_float_opt
, but raise Failure "float_of_string"
instead of returning None
.
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 Stdlib.open_out_gen
and Stdlib.open_in_gen
.
let 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 truncated to zero length if it already exists. It is created if it does not already exists.
let open_out_bin: string => out_channel;
Same as Stdlib.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 function behaves like Stdlib.open_out
.
let open_out_gen: list(open_flag) => 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. Stdlib.open_out
and Stdlib.open_out_bin
are special cases of this function.
let flush: out_channel => unit;
Flush the buffer associated with the given output channel, performing all pending writes on that channel. Interactive programs must be careful about flushing standard output and standard error at the right time.
let output_char: out_channel => char => unit;
Write the character on the given output channel.
let output_string: out_channel => string => unit;
Write the string on the given output channel.
let output_bytes: out_channel => bytes => unit;
Write the byte sequence on the given output channel.
let 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
.
let output_substring: out_channel => string => int => int => unit;
Same as output
but take a string as argument instead of a byte sequence.
let 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.
let 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 232. The only reliable way to read it back is through the Stdlib.input_binary_int
function. The format is compatible across all machines for a given version of OCaml.
let output_value: out_channel => 'a => unit;
Write the representation of a structured value of any type to a channel. Circularities and sharing inside the value are detected and preserved. The object can be read back, by the function Stdlib.input_value
. See the description of module Marshal
for more information. Stdlib.output_value
is equivalent to Marshal.to_channel
with an empty list of flags.
let 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.
let 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). For files opened in text mode under Windows, the returned position is approximate (owing to end-of-line conversion); in particular, saving the current position with pos_out
, then going back to this position using seek_out
will not work. For this programming idiom to work reliably and portably, the file must be opened in binary mode.
let 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.
let close_out: out_channel => unit;
Close the given channel, flushing all buffered write operations. Output 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.
let close_out_noerr: out_channel => unit;
Same as close_out
, but ignore all errors.
let 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 function has no effect under operating systems that do not distinguish between text mode and binary mode.
General input functions
let 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.
let open_in_bin: string => in_channel;
Same as Stdlib.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 behaves like Stdlib.open_in
.
let open_in_gen: list(open_flag) => int => string => in_channel;
open_in_gen mode perm filename
opens the named file for reading, as described above. The extra arguments mode
and perm
specify the opening mode and file permissions. Stdlib.open_in
and Stdlib.open_in_bin
are special cases of this function.
let input_char: in_channel => char;
Read one character from the given input channel.
let 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.
let 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 Stdlib.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
.
let 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
.
let really_input_string: in_channel => int => string;
really_input_string ic len
reads len
characters from channel ic
and returns them in a new string.
let input_byte: in_channel => int;
Same as Stdlib.input_char
, but return the 8-bit integer representing the character.
let input_binary_int: in_channel => int;
Read an integer encoded in binary format (4 bytes, big-endian) from the given input channel. See Stdlib.output_binary_int
.
let input_value: in_channel => 'a;
Read the representation of a structured value, as produced by Stdlib.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.
let 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.
let pos_in: in_channel => int;
Return the current reading position for the given channel. For files opened in text mode under Windows, the returned position is approximate (owing to end-of-line conversion); in particular, saving the current position with pos_in
, then going back to this position using seek_in
will not work. For this programming idiom to work reliably and portably, the file must be opened in binary mode.
let 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 performed when reading from a channel opened in text mode.
let 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.
let close_in_noerr: in_channel => unit;
Same as close_in
, but ignore all errors.
let 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 function has no effect under operating systems that do not distinguish between text mode and binary mode.
Operations on large files
module LargeFile: { ... };
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 allow operating on files whose sizes are greater than max_int
.
References
The type of references (mutable indirection cells) containing a value of type 'a
.
let ref: 'a => ref('a);
Return a fresh reference containing the given value.
let (!): ref('a) => 'a;
!r
returns the current contents of reference r
. Equivalent to fun r -> r.contents
. Unary operator, see Ocaml_operators
for more information.
let (:=): ref('a) => 'a => unit;
r := a
stores the value of a
in reference r
. Equivalent to fun r v -> r.contents <- v
. Right-associative operator, see Ocaml_operators
for more information.
let incr: ref(int) => unit;
Increment the integer contained in the given reference. Equivalent to fun r -> r := succ !r
.
let decr: ref(int) => unit;
Decrement the integer contained in the given reference. Equivalent to fun r -> r := pred !r
.
Result type
Operations on format strings
Format strings are character strings with special lexical conventions that defines the functionality of formatted input/output functions. Format strings are used to read data with formatted input functions from module Scanf
and to print data with formatted output functions from modules Printf
and Format
.
Format strings are made of three kinds of entities:
- conversions specifications, introduced by the special 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 specifying 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 output.
There is an additional lexical rule to escape the special characters '%'
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 information about conversion specifications and formatting indications available, 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.formatter
; 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 functions, it is typically the result type of the receiver function.
type format6('a, 'b, 'c, 'd, 'e, 'f) =
+Stdlib (melange.Stdlib) Module Stdlib
The OCaml Standard library.
This module is automatically opened at the beginning of each compilation. All components of this module can therefore be referred by their short name, without prefixing them by Stdlib
.
In particular, it provides the basic operations over the built-in types (numbers, booleans, byte sequences, strings, exceptions, references, lists, arrays, input-output channels, ...) and the standard library modules.
Exceptions
The Exit
exception is not raised by any library function. It is provided for use in your programs.
Exception raised when none of the cases of a pattern-matching apply. The arguments are the location of the match keyword in the source code (file name, line number, column number).
Exception raised when an assertion fails. The arguments are the location of the assert keyword in the source code (file name, line number, column number).
Exception raised by library functions to signal that the given arguments do not make sense. The string gives some information to the programmer. As a general rule, this exception should not be caught, it denotes a programming error and the code should be modified not to trigger it.
Exception raised by library functions to signal that they are undefined on the given arguments. The string is meant to give some information to the programmer; you must not pattern match on the string literal because it may change in future versions (use Failure _ instead).
Exception raised by search functions when the desired object could not be found.
Exception raised by the garbage collector when there is insufficient memory to complete the computation. (Not reliable for allocations on the minor heap.)
Exception raised by the bytecode interpreter when the evaluation stack reaches its maximal size. This often indicates infinite or excessively deep recursion in the user's program.
Before 4.10, it was not fully implemented by the native-code compiler.
Exception raised by the input/output functions to report an operating system error. The string is meant to give some information to the programmer; you must not pattern match on the string literal because it may change in future versions (use Sys_error _ instead).
Exception raised by input functions to signal that the end of file has been reached.
Exception raised by integer division and remainder operations when their second argument is zero.
A special case of Sys_error raised when no I/O is possible on a non-blocking I/O channel.
Exception raised when an ill-founded recursive module definition is evaluated. The arguments are the location of the definition in the source code (file name, line number, column number).
Comparisons
e1 = e2
tests for structural equality of e1
and e2
. Mutable structures (e.g. references and arrays) are equal if and only if their current 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. Left-associative operator, see Ocaml_operators
for more information.
Negation of Stdlib.(=)
. Left-associative operator, see Ocaml_operators
for more information.
See Stdlib.(>=)
. Left-associative operator, see Ocaml_operators
for more information.
See Stdlib.(>=)
. Left-associative operator, see Ocaml_operators
for more information.
See Stdlib.(>=)
. Left-associative operator, see Ocaml_operators
for more information.
Structural ordering functions. These functions coincide with the usual orderings over integers, characters, strings, byte sequences and floating-point numbers, and extend them to a total ordering over all types. The ordering is compatible with ( = )
. As in the case of ( = )
, mutable structures are compared by contents. Comparison between functional values raises Invalid_argument
. Comparison between cyclic structures may not terminate. Left-associative operator, see Ocaml_operators
for more information.
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 ordering implemented by compare
is compatible with the comparison predicates =
, <
and >
defined above, with one difference on the treatment of the float value Stdlib.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 total ordering relation.
compare
applied to functional values may raise Invalid_argument
. compare
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 Array.sort
functions.
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
. Left-associative operator, see Ocaml_operators
for more information.
Negation of Stdlib.(==)
. Left-associative operator, see Ocaml_operators
for more information.
Boolean operations
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. Right-associative operator, see Ocaml_operators
for more information.
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. Right-associative operator, see Ocaml_operators
for more information.
Debugging
__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".
__LINE__
returns the line number at which this expression appears in the file currently being parsed by the compiler.
__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 character position in the line.
__FUNCTION__
returns the name of the current function or method, including any enclosing modules or classes.
__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 standard error format of OCaml: "File %S, line %d, characters %d-%d".
__LINE_OF__ expr
returns a pair (line, expr)
, where line
is the line number at which the expression expr
appears in the file currently being parsed by the compiler.
__POS_OF__ expr
returns a pair (loc,expr)
, where loc
is a tuple (file,lnum,cnum,enum)
corresponding to the location at which the expression expr
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 character position in the line.
Composition operators
Reverse-application operator: x |> f |> g
is exactly equivalent to g (f (x))
. Left-associative operator, see Ocaml_operators
for more information.
Application operator: g @@ f @@ x
is exactly equivalent to g (f (x))
. Right-associative operator, see Ocaml_operators
for more information.
Integer arithmetic
Integers are Sys.int_size
bits wide. All operations are taken modulo 2Sys.int_size
. They do not fail on overflow.
Unary negation. You can also write - e
instead of ~- e
. Unary operator, see Ocaml_operators
for more information.
Unary addition. You can also write + e
instead of ~+ e
. Unary operator, see Ocaml_operators
for more information.
Integer addition. Left-associative operator, see Ocaml_operators
for more information.
Integer subtraction. Left-associative operator, , see Ocaml_operators
for more information.
Integer multiplication. Left-associative operator, see Ocaml_operators
for more information.
Integer division. Integer division rounds the real quotient of its arguments towards zero. More precisely, if x >= 0
and y > 0
, x / y
is the greatest integer less than or equal to the real quotient of x
by y
. Moreover, (- x) / y = x / (- y) = - (x / y)
. Left-associative operator, see Ocaml_operators
for more information.
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
. Left-associative operator, see Ocaml_operators
for more information.
abs x
is the absolute value of x
. On min_int
this is min_int
itself and thus remains negative.
Bitwise operations
Bitwise logical and. Left-associative operator, see Ocaml_operators
for more information.
Bitwise logical or. Left-associative operator, see Ocaml_operators
for more information.
Bitwise logical exclusive or. Left-associative operator, see Ocaml_operators
for more information.
n lsl m
shifts n
to the left by m
bits. The result is unspecified if m < 0
or m > Sys.int_size
. Right-associative operator, see Ocaml_operators
for more information.
n lsr m
shifts n
to the right by m
bits. This is a logical shift: zeroes are inserted regardless of the sign of n
. The result is unspecified if m < 0
or m > Sys.int_size
. Right-associative operator, see Ocaml_operators
for more information.
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 > Sys.int_size
. Right-associative operator, see Ocaml_operators
for more information.
Floating-point arithmetic
OCaml's floating-point numbers follow the IEEE 754 standard, using double precision (64 bits) numbers. Floating-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 instance, 1.0 /. infinity
is 0.0
, basic arithmetic operations (+.
, -.
, *.
, /.
) with nan
as an argument return nan
, ...
Unary negation. You can also write -. e
instead of ~-. e
. Unary operator, see Ocaml_operators
for more information.
Unary addition. You can also write +. e
instead of ~+. e
. Unary operator, see Ocaml_operators
for more information.
Floating-point addition. Left-associative operator, see Ocaml_operators
for more information.
Floating-point subtraction. Left-associative operator, see Ocaml_operators
for more information.
Floating-point multiplication. Left-associative operator, see Ocaml_operators
for more information.
Floating-point division. Left-associative operator, see Ocaml_operators
for more information.
expm1 x
computes exp x -. 1.0
, giving numerically-accurate results even if x
is close to 0.0
.
log1p x
computes log(1.0 +. x)
(natural logarithm), giving numerically-accurate results even if x
is close to 0.0
.
Arc cosine. The argument must fall within the range [-1.0, 1.0]
. Result is in radians and is between 0.0
and pi
.
Arc sine. The argument must fall within the range [-1.0, 1.0]
. Result is in radians and is between -pi/2
and pi/2
.
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
.
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.
Hyperbolic arc cosine. The argument must fall within the range [1.0, inf]
. Result is in radians and is between 0.0
and inf
.
Hyperbolic arc sine. The argument and result range over the entire real line. Result is in radians.
Hyperbolic arc tangent. The argument must fall within the range [-1.0, 1.0]
. Result is in radians and ranges over the entire real line.
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.
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.
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.
mod_float a b
returns the remainder of a
with respect to b
. The returned value is a -. n *. b
, where n
is the quotient a /. b
rounded towards zero to an integer.
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
.
Same as Stdlib.float_of_int
.
Same as Stdlib.int_of_float
.
Truncate the given floating-point number to an integer. The result is unspecified if the argument is nan
or falls outside the range of representable integers.
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 Stdlib.classify_float
function.
let classify_float: float => fpclass;
String operations
More string operations are provided in module String
.
String concatenation. Right-associative operator, see Ocaml_operators
for more information.
Character operations
More character operations are provided in module Char
.
Unit operations
Discard the value of its argument and return ()
. For instance, ignore(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
Return the string representation of a boolean. As the returned values may be shared, the user should not modify them directly.
Convert the given string to a boolean.
Return None
if the string is not "true"
or "false"
.
Same as Stdlib.bool_of_string_opt
, but raise Invalid_argument "bool_of_string"
instead of returning None
.
Return the string representation of an integer, in decimal.
Convert the given string to an integer. The string is read in decimal (by default, or if the string begins with 0u
), 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 0u
prefix reads the input as an unsigned integer in the range [0, 2*max_int+1]
. If the input exceeds max_int
it is converted to the signed integer min_int + input - max_int - 1
.
The _
(underscore) character can appear anywhere in the string and is ignored.
Return None
if the given string is not a valid representation of an integer, or if the integer represented exceeds the range of integers representable in type int
.
Same as Stdlib.int_of_string_opt
, but raise Failure "int_of_string"
instead of returning None
.
Return a string representation of a floating-point number.
This conversion can involve a loss of precision. For greater control over the manner in which the number is printed, see Printf
.
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 decimal 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.
Return None
if the given string is not a valid representation of a float.
Same as Stdlib.float_of_string_opt
, but raise Failure "float_of_string"
instead of returning None
.
Pair operations
List operations
More list operations are provided in module List
.
l0 @ l1
appends l1
to l0
. Same function as List.append
. Right-associative operator, see Ocaml_operators
for more information.
Input/output
Note: all input/output functions can raise Sys_error
when the system calls they invoke fail.
let stdin: in_channel;
The standard input for the process.
let stdout: out_channel;
The standard output for the process.
let stderr: out_channel;
The standard error output for the process.
Output functions on standard output
Print a floating-point number, in decimal, on standard output.
The conversion of the number to a string uses string_of_float
and can involve a loss of precision.
Print a string, followed by a newline character, on standard output and flush standard output.
Print a newline character on standard output, and flush standard output. This can be used to simulate line buffering of standard output.
Output functions on standard error
Print a floating-point number, in decimal, on standard error.
The conversion of the number to a string uses string_of_float
and can involve a loss of precision.
Print a string, followed by a newline character on standard error and flush standard error.
Print a newline character on standard error, and flush standard error.
Input functions on standard input
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.
Flush standard output, then read one line from standard input and convert it to an integer.
Return None
if the line read is not a valid representation of an integer.
Same as Stdlib.read_int_opt
, but raise Failure "int_of_string"
instead of returning None
.
Flush standard output, then read one line from standard input and convert it to a floating-point number.
Return None
if the line read is not a valid representation of a floating-point number.
Same as Stdlib.read_float_opt
, but raise Failure "float_of_string"
instead of returning None
.
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 Stdlib.open_out_gen
and Stdlib.open_in_gen
.
let 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 truncated to zero length if it already exists. It is created if it does not already exists.
let open_out_bin: string => out_channel;
Same as Stdlib.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 function behaves like Stdlib.open_out
.
let open_out_gen: list(open_flag) => 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. Stdlib.open_out
and Stdlib.open_out_bin
are special cases of this function.
let flush: out_channel => unit;
Flush the buffer associated with the given output channel, performing all pending writes on that channel. Interactive programs must be careful about flushing standard output and standard error at the right time.
let output_char: out_channel => char => unit;
Write the character on the given output channel.
let output_string: out_channel => string => unit;
Write the string on the given output channel.
let output_bytes: out_channel => bytes => unit;
Write the byte sequence on the given output channel.
let 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
.
let output_substring: out_channel => string => int => int => unit;
Same as output
but take a string as argument instead of a byte sequence.
let 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.
let 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 232. The only reliable way to read it back is through the Stdlib.input_binary_int
function. The format is compatible across all machines for a given version of OCaml.
let output_value: out_channel => 'a => unit;
Write the representation of a structured value of any type to a channel. Circularities and sharing inside the value are detected and preserved. The object can be read back, by the function Stdlib.input_value
. See the description of module Marshal
for more information. Stdlib.output_value
is equivalent to Marshal.to_channel
with an empty list of flags.
let 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.
let 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). For files opened in text mode under Windows, the returned position is approximate (owing to end-of-line conversion); in particular, saving the current position with pos_out
, then going back to this position using seek_out
will not work. For this programming idiom to work reliably and portably, the file must be opened in binary mode.
let 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.
let close_out: out_channel => unit;
Close the given channel, flushing all buffered write operations. Output 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.
let close_out_noerr: out_channel => unit;
Same as close_out
, but ignore all errors.
let 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 function has no effect under operating systems that do not distinguish between text mode and binary mode.
General input functions
let 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.
let open_in_bin: string => in_channel;
Same as Stdlib.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 behaves like Stdlib.open_in
.
let open_in_gen: list(open_flag) => int => string => in_channel;
open_in_gen mode perm filename
opens the named file for reading, as described above. The extra arguments mode
and perm
specify the opening mode and file permissions. Stdlib.open_in
and Stdlib.open_in_bin
are special cases of this function.
let input_char: in_channel => char;
Read one character from the given input channel.
let 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.
let 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 Stdlib.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
.
let 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
.
let really_input_string: in_channel => int => string;
really_input_string ic len
reads len
characters from channel ic
and returns them in a new string.
let input_byte: in_channel => int;
Same as Stdlib.input_char
, but return the 8-bit integer representing the character.
let input_binary_int: in_channel => int;
Read an integer encoded in binary format (4 bytes, big-endian) from the given input channel. See Stdlib.output_binary_int
.
let input_value: in_channel => 'a;
Read the representation of a structured value, as produced by Stdlib.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.
let 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.
let pos_in: in_channel => int;
Return the current reading position for the given channel. For files opened in text mode under Windows, the returned position is approximate (owing to end-of-line conversion); in particular, saving the current position with pos_in
, then going back to this position using seek_in
will not work. For this programming idiom to work reliably and portably, the file must be opened in binary mode.
let 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 performed when reading from a channel opened in text mode.
let 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.
let close_in_noerr: in_channel => unit;
Same as close_in
, but ignore all errors.
let 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 function has no effect under operating systems that do not distinguish between text mode and binary mode.
Operations on large files
module LargeFile: { ... };
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 allow operating on files whose sizes are greater than max_int
.
References
The type of references (mutable indirection cells) containing a value of type 'a
.
let ref: 'a => ref('a);
Return a fresh reference containing the given value.
let (!): ref('a) => 'a;
!r
returns the current contents of reference r
. Equivalent to fun r -> r.contents
. Unary operator, see Ocaml_operators
for more information.
let (:=): ref('a) => 'a => unit;
r := a
stores the value of a
in reference r
. Equivalent to fun r v -> r.contents <- v
. Right-associative operator, see Ocaml_operators
for more information.
let incr: ref(int) => unit;
Increment the integer contained in the given reference. Equivalent to fun r -> r := succ !r
.
let decr: ref(int) => unit;
Decrement the integer contained in the given reference. Equivalent to fun r -> r := pred !r
.
Result type
Operations on format strings
Format strings are character strings with special lexical conventions that defines the functionality of formatted input/output functions. Format strings are used to read data with formatted input functions from module Scanf
and to print data with formatted output functions from modules Printf
and Format
.
Format strings are made of three kinds of entities:
- conversions specifications, introduced by the special 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 specifying 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 output.
There is an additional lexical rule to escape the special characters '%'
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 information about conversion specifications and formatting indications available, 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.formatter
; 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 functions, it is typically the result type of the receiver function.
type format6('a, 'b, 'c, 'd, 'e, 'f) =
CamlinternalFormatBasics.format6('a, 'b, 'c, 'd, 'e, 'f);
type format4('a, 'b, 'c, 'd) = format6('a, 'b, 'c, 'c, 'c, 'd);
type format('a, 'b, 'c) = format4('a, 'b, 'c, 'c);
let string_of_format: format6('a, 'b, 'c, 'd, 'e, 'f) => string;
Converts a format string into a string.
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.
let (^^):
diff --git a/unstable/api/re/melange/Typemod_hide/index.html b/unstable/api/re/melange/Typemod_hide/index.html
deleted file mode 100644
index 90521acf1..000000000
--- a/unstable/api/re/melange/Typemod_hide/index.html
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Typemod_hide (melange.Typemod_hide) Module Typemod_hide
let should_hide: Melange_compiler_libs.Typedtree.module_binding => bool;
diff --git a/unstable/api/re/melange/Vec_int/index.html b/unstable/api/re/melange/Vec_int/index.html
index 9ebbeaa36..ed64cba09 100644
--- a/unstable/api/re/melange/Vec_int/index.html
+++ b/unstable/api/re/melange/Vec_int/index.html
@@ -4,4 +4,4 @@
cb_no:(elt => 'a => 'a) =>
'a =>
t =>
- 'a;
let capacity: t => int;
+ 'a;let capacity: t => int;
let mem: int => t => bool;