commentaires après

git-svn-id: http://caml.inria.fr/svn/ocaml/trunk@4082 f963ae5c-01c2-4b8c-9fe0-0dff7051ff02

Author: zoggy

stdlib/arg.mli

@@ -37,18 +37,21 @@
                            two arguments)
 *)
 
-(** The concrete type describing the behavior associated
-   with a keyword. *)
 type spec =
-  | Unit of (unit -> unit)     (** Call the function with unit argument *)
+    Unit of (unit -> unit)     (** Call the function with unit argument *)
   | Set of bool ref            (** Set the reference to true *)
   | Clear of bool ref          (** Set the reference to false *)
   | String of (string -> unit) (** Call the function with a string argument *)
   | Int of (int -> unit)       (** Call the function with an int argument *)
   | Float of (float -> unit)   (** Call the function with a float argument *)
-  | Rest of (string -> unit)   (** Stop interpreting keywords and call the
-                                  function with each remaining argument *)
+  | Rest of (string -> unit)   (** Stop interpreting keywords and call the 
+				  function with each remaining argument *)
+
+(** The concrete type describing the behavior associated
+   with a keyword. *)
 
+val parse :
+  (string * spec * string) list -> (string -> unit) -> string -> unit
 (** [Arg.parse speclist anonfun usage_msg] parses the command line.
     [speclist] is a list of triples [(key, spec, doc)].
     [key] is the option keyword, it must start with a ['-'] character.
@@ -73,19 +76,17 @@ type spec =
     the program.  You can override this behaviour by specifying your
     own [-help] and [--help] options in [speclist].
 *)
-val parse : (string * spec * string) list ->
-            (string -> unit) -> string -> unit
 
+exception Bad of string
 (** Functions in [spec] or [anonfun] can raise [Arg.Bad] with an error
    message to reject invalid arguments. *)
-exception Bad of string
 
+val usage : (string * spec * string) list -> string -> unit
 (** [Arg.usage speclist usage_msg] prints an error message including
     the list of valid options.  This is the same message that
     {!Arg.parse} prints in case of error.
     [speclist] and [usage_msg] are the same as for [Arg.parse]. *)
-val usage : (string * spec * string) list -> string -> unit
 
+val current : int ref
 (** Position (in {!Sys.argv}) of the argument being processed.  You can
     change this value, e.g. to force {!Arg.parse} to skip some arguments.*)
-val current : int ref;;

stdlib/array.mli

@@ -14,26 +14,27 @@
 
 (** Array operations. *)
 
-(** Return the length (number of elements) of the given array. *)
 external length : 'a array -> int = "%array_length"
+(** Return the length (number of elements) of the given array. *)
 
+external get : 'a array -> int -> 'a = "%array_safe_get"
 (** [Array.get a n] returns the element number [n] of array [a].
    The first element has number 0.
    The last element has number [Array.length a - 1].
 
    Raise [Invalid_argument "Array.get"]  if [n] is outside the range
    0 to [(Array.length a - 1)].
    You can also write [a.(n)] instead of [Array.get a n]. *)
-external get: 'a array -> int -> 'a = "%array_safe_get"
 
+external set : 'a array -> int -> 'a -> unit = "%array_safe_set"
 (** [Array.set a n x] modifies array [a] in place, replacing
    element number [n] with [x].
 
    Raise [Invalid_argument "Array.set"] if [n] is outside the range
    0 to [Array.length a - 1].
    You can also write [a.(n) <- x] instead of [Array.set a n x]. *)
-external set: 'a array -> int -> 'a -> unit = "%array_safe_set"
 
+external make : int -> 'a -> 'a array = "make_vect"
 (** [Array.make n x] returns a fresh array of length [n],
    initialized with [x].
    All the elements of this new array are initially
@@ -45,17 +46,17 @@ external set: 'a array -> int -> 'a -> unit = "%array_safe_set"
    Raise [Invalid_argument] if [n < 0] or [n > Sys.max_array_length].
    If the value of [x] is a floating-point number, then the maximum
    size is only [Sys.max_array_length / 2].*)
-external make: int -> 'a -> 'a array = "make_vect"
 
+external create : int -> 'a -> 'a array = "make_vect"
 (** @deprecated [Array.create] is an alias for {!Array.make}. *)
-external create: int -> 'a -> 'a array = "make_vect"
 
+val init : int -> (int -> 'a) -> 'a array
 (** [Array.init n f] returns a fresh array of length [n],
    with element number [i] initialized to the result of [f i].
    In other terms, [Array.init n f] tabulates the results of [f]
    applied to the integers [0] to [n-1]. *)
-val init: int -> (int -> 'a) -> 'a array
 
+val make_matrix : int -> int -> 'a -> 'a array array
 (** [Array.make_matrix dimx dimy e] returns a two-dimensional array
    (an array of arrays) with first dimension [dimx] and
    second dimension [dimy]. All the elements of this new matrix
@@ -67,38 +68,38 @@ val init: int -> (int -> 'a) -> 'a array
    greater than [Sys.max_array_length].
    If the value of [e] is a floating-point number, then the maximum
    size is only [Sys.max_array_length / 2]. *)
-val make_matrix: int -> int -> 'a -> 'a array array
 
+val create_matrix : int -> int -> 'a -> 'a array array
 (** @deprecated [Array.create_matrix] is an alias for {!Array.make_matrix}. *)
-val create_matrix: int -> int -> 'a -> 'a array array
 
+val append : 'a array -> 'a array -> 'a array
 (** [Array.append v1 v2] returns a fresh array containing the
    concatenation of the arrays [v1] and [v2]. *)
-val append: 'a array -> 'a array -> 'a array
 
+val concat : 'a array list -> 'a array
 (** Same as [Array.append], but catenates a list of arrays. *)
-val concat: 'a array list -> 'a array
 
+val sub : 'a array -> int -> int -> 'a array
 (** [Array.sub a start len] returns a fresh array of length [len],
    containing the elements number [start] to [start + len - 1]
    of array [a].
 
    Raise [Invalid_argument "Array.sub"] if [start] and [len] do not
    designate a valid subarray of [a]; that is, if
    [start < 0], or [len < 0], or [start + len > Array.length a]. *)
-val sub: 'a array -> int -> int -> 'a array
 
+val copy : 'a array -> 'a array
 (** [Array.copy a] returns a copy of [a], that is, a fresh array
    containing the same elements as [a]. *)
-val copy: 'a array -> 'a array
 
+val fill : 'a array -> int -> int -> 'a -> unit
 (** [Array.fill a ofs len x] modifies the array [a] in place,
    storing [x] in elements number [ofs] to [ofs + len - 1].
 
    Raise [Invalid_argument "Array.fill"] if [ofs] and [len] do not
    designate a valid subarray of [a]. *)
-val fill: 'a array -> int -> int -> 'a -> unit
 
+val blit : 'a array -> int -> 'a array -> int -> int -> unit
 (** [Array.blit v1 o1 v2 o2 len] copies [len] elements
    from array [v1], starting at element number [o1], to array [v2],
    starting at element number [o2]. It works correctly even if
@@ -108,49 +109,49 @@ val fill: 'a array -> int -> int -> 'a -> unit
    Raise [Invalid_argument "Array.blit"] if [o1] and [len] do not
    designate a valid subarray of [v1], or if [o2] and [len] do not
    designate a valid subarray of [v2]. *)
-val blit: 'a array -> int -> 'a array -> int -> int -> unit
 
+val to_list : 'a array -> 'a list
 (** [Array.to_list a] returns the list of all the elements of [a]. *)
-val to_list: 'a array -> 'a list
 
+val of_list : 'a list -> 'a array
 (** [Array.of_list l] returns a fresh array containing the elements
    of [l]. *)
-val of_list: 'a list -> 'a array
 
+val iter : ('a -> unit) -> 'a array -> unit
 (** [Array.iter f a] applies function [f] in turn to all
    the elements of [a].  It is equivalent to
    [f a.(0); f a.(1); ...; f a.(Array.length a - 1); ()]. *)
-val iter: ('a -> unit) -> 'a array -> unit
 
+val map : ('a -> 'b) -> 'a array -> 'b array
 (** [Array.map f a] applies function [f] to all the elements of [a],
    and builds an array with the results returned by [f]:
    [[| f a.(0); f a.(1); ...; f a.(Array.length a - 1) |]]. *)
-val map: ('a -> 'b) -> 'a array -> 'b array
 
+val iteri : (int -> 'a -> unit) -> 'a array -> unit
 (** Same as {!Array.iter}, but the
    function is applied to the index of the element as first argument,
    and the element itself as second argument. *)
-val iteri: (int -> 'a -> unit) -> 'a array -> unit
 
+val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array
 (** Same as {!Array.map}, but the
    function is applied to the index of the element as first argument,
    and the element itself as second argument. *)
-val mapi: (int -> 'a -> 'b) -> 'a array -> 'b array
 
+val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a
 (** [Array.fold_left f x a] computes
    [f (... (f (f x a.(0)) a.(1)) ...) a.(n-1)],
    where [n] is the length of the array [a]. *)
-val fold_left: ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a
 
+val fold_right : ('b -> 'a -> 'a) -> 'b array -> 'a -> 'a
 (** [Array.fold_right f a x] computes
    [f a.(0) (f a.(1) ( ... (f a.(n-1) x) ...))],
    where [n] is the length of the array [a]. *)
-val fold_right: ('b -> 'a -> 'a) -> 'b array -> 'a -> 'a
 
 
 (** {2 Sorting} *)
 
 
+val sort : ('a -> 'a -> int) -> 'a array -> unit
 (** Sort an array in increasing order according to a comparison
    function.  The comparison function must return 0 if its arguments
    compare as equal, a positive integer if the first is greater,
@@ -161,22 +162,20 @@ val fold_right: ('b -> 'a -> 'a) -> 'b array -> 'a -> 'a
    [Array.sort] is guaranteed to run in constant heap space
    and logarithmic stack space.
 
-   
    The current implementation uses Heap Sort.  It runs in constant
    stack space.
 *)
-val sort : ('a -> 'a -> int) -> 'a array -> unit;;
 
+val stable_sort : ('a -> 'a -> int) -> 'a array -> unit
 (** Same as {!Array.sort}, but the sorting algorithm is stable and
    not guaranteed to use a fixed amount of heap memory.
    The current implementation is Merge Sort. It uses [n/2]
    words of heap space, where [n] is the length of the array.
    It is faster than the current implementation of {!Array.sort}.
 *)
-val stable_sort : ('a -> 'a -> int) -> 'a array -> unit;;
 
 (**/**)
 (** {2 Undocumented functions} *)
 
-external unsafe_get: 'a array -> int -> 'a = "%array_unsafe_get"
-external unsafe_set: 'a array -> int -> 'a -> unit = "%array_unsafe_set"
+external unsafe_get : 'a array -> int -> 'a = "%array_unsafe_get"
+external unsafe_set : 'a array -> int -> 'a -> unit = "%array_unsafe_set"