This is an automated email from the git hooks/post-receive script.

lucas pushed a commit to branch master
in repository ocamlbricks.

commit ddf9ed1c93759a6785bc7839d6d1f88e91511244
Author: Lucas Nussbaum <lu...@debian.org>
Date:   Tue Jul 8 11:09:31 2014 +0200

    Imported Upstream version 0.90+bzr400
---
 EXTRA/arrayExtra.ml       | 12 ++++++++
 EXTRA/arrayExtra.mli      |  2 ++
 EXTRA/listExtra.ml        | 17 +++++++++++
 EXTRA/listExtra.mli       |  2 ++
 EXTRA/stringExtra.ml      | 19 +++++++++---
 EXTRA/stringExtra.mli     |  4 +++
 EXTRA/unixExtra.ml        | 13 ++++++++
 EXTRA/unixExtra.mli       |  9 ++++++
 SHELL/linux.ml            | 48 +++++++++++++++--------------
 SHELL/linux.mli           |  8 ++---
 STRUCTURES/cortex.ml      | 36 +++++++++++++++++++++-
 STRUCTURES/cortex.mli     |  8 +++++
 STRUCTURES/cortex_lib.ml  | 77 +++++++++++++++++++++++++++++++++++++++++++++++
 STRUCTURES/cortex_lib.mli | 24 +++++++++++++++
 STRUCTURES/endpoint.mli   | 12 ++++----
 meta.ml.released          | 10 +++---
 16 files changed, 258 insertions(+), 43 deletions(-)

diff --git a/EXTRA/arrayExtra.ml b/EXTRA/arrayExtra.ml
index 05b48cb..16c42b7 100644
--- a/EXTRA/arrayExtra.ml
+++ b/EXTRA/arrayExtra.ml
@@ -368,6 +368,10 @@ let partitioni =
   let result = Array.map (fun l -> Array.of_list (List.rev l)) ls in
   result
   
+let amass ~size = 
+  if size <= 0 then invalid_arg "ArrayExtra.amass: size must be greater than 
zero" else
+  partitioni (fun i x -> i/size)
+ 
 (** {b Example}:
 {[
 # cut [1;2;3;0;2] [|0;1;2;3;4;5;6;7;8;9|];;
@@ -383,6 +387,14 @@ let cut ~lengths xs =
     List.map (fun (start, len) -> Array.sub xs start len) start_len_list
   with Invalid_argument "Array.sub" -> invalid_arg "ArrayExtra.cut"
 
+(** As standard [Array.sub] but with optional length (if not provided, the 
length is defined 
+    in order to take the rest of the list after the given position) *)  
+let sub ?len xs pos = 
+ let len = match len with
+ | None -> (Array.length xs) - pos
+ | Some n -> n
+ in
+ Array.sub xs pos len
 
 (** Tools for matrices (arrays of arrays). *)
 module Matrix = struct
diff --git a/EXTRA/arrayExtra.mli b/EXTRA/arrayExtra.mli
index 9c05f33..579125c 100644
--- a/EXTRA/arrayExtra.mli
+++ b/EXTRA/arrayExtra.mli
@@ -19,6 +19,8 @@
 val of_known_length_list : ?reversing:bool -> int -> 'a list -> 'a array
 val partition  : ?min_size:int -> ('a -> int) -> 'a array -> 'a array array
 val partitioni : ?min_size:int -> (int -> 'a -> int) -> 'a array -> 'a array 
array
+val amass      : size:int -> 'a array -> 'a array array
+val sub        : ?len:int -> 'a array -> int -> 'a array
 
 val int_seq   : min:int   -> max:int   -> incr:int   -> int array
 val float_seq : min:float -> max:float -> incr:float -> float array
diff --git a/EXTRA/listExtra.ml b/EXTRA/listExtra.ml
index 415cb31..2650fed 100644
--- a/EXTRA/listExtra.ml
+++ b/EXTRA/listExtra.ml
@@ -221,6 +221,23 @@ let remove_duplicates ?(take_first=true) =
 ;;
 
 (** {b Example}:
+{[# let xs = ['a';'b';'c';'d';'e';'f';'g';'h';'i';'j'] ;;
+#ListExtra.amass 3 xs ;;
+  : char list list = [['a'; 'b'; 'c']; ['d'; 'e'; 'f']; ['g'; 'h'; 'i']; ['j']]
+# xs = List.concat (ListExtra.amass 3 xs) ;;
+  : bool = true ]}*)
+let amass ~size xs =
+  if size <= 0 then invalid_arg "ListExtra.amass: size must be greater than 
zero" else
+  let rec loop i acc1 acc2 xs =
+    if i>size then loop 1 [] ((List.rev acc1)::acc2) xs else
+    match xs with
+    | []    -> if acc1=[] then acc2 else (List.rev acc1)::acc2
+    | x::xs -> loop (i+1) (x::acc1) acc2 xs
+  in
+  List.rev (loop 1 [] [] xs)
+
+    
+(** {b Example}:
 {[# int_seq 3 10 2 ;;
   : int list = [3; 5; 7; 9]
 ]}*)
diff --git a/EXTRA/listExtra.mli b/EXTRA/listExtra.mli
index ca3b384..1c3bf25 100644
--- a/EXTRA/listExtra.mli
+++ b/EXTRA/listExtra.mli
@@ -119,6 +119,8 @@ val intersection : 'a list -> 'a list -> 'a list
 val uniq         : 'a list -> 'a list
 val remove_duplicates : ?take_first:bool -> 'a list -> 'a list
 
+val amass        : size:int -> 'a list -> 'a list list
+
 (** {2 Indexes} *)
 
 val int_seq   : min:int   -> max:int   -> incr:int   -> int list
diff --git a/EXTRA/stringExtra.ml b/EXTRA/stringExtra.ml
index eb925ef..efd2823 100644
--- a/EXTRA/stringExtra.ml
+++ b/EXTRA/stringExtra.ml
@@ -516,6 +516,9 @@ let concat ?(blit:blit_function=String.blit) xs =
     (fun k src -> let l=(String.length src) in (blit src 0 dst k l); (k+l)) 0 
xs in
  dst
 
+(** Remove all occurrences of a character from a string. *) 
+let rm d s = concat (split ~d s) ;;
+ 
 (** Quote a string using a prefix [l] (by default [l="'"]) and a suffix [r] 
(by default [r="'"]). *)
 let quote ?(l="'") ?(r="'") (x:string) = String.concat "" [l;x;r]
 
@@ -524,7 +527,7 @@ let quote ?(l="'") ?(r="'") (x:string) = String.concat "" 
[l;x;r]
 let assemble_if_not_empty ~prefix ~suffix x =
   if (x="") then "" else (String.concat "" [prefix;x;suffix])
 
-(** [merge_map f l] maps the function [f] on the list [l]
+(** [map_concat f l] maps the function [f] on the list [l]
     then merge the result with the separator ([sep=" "] by default). *)
 let map_concat ?(sep=" ") f l = String.concat sep (List.map f l)
 
@@ -545,6 +548,7 @@ let rec merge_fields sep (fieldlist:int list) (l:string 
list) =
 # ensure_cr_at_end "hello\n";;
   : string = "hello\n"]}*)
 let ensure_cr_at_end x =
+ if x="" then "\n" else (* continue *)
  let l    = (String.length x) in
  let last = (String.sub x (l-1) 1) in
  match last with "\n" -> x | _ -> x^"\n"
@@ -557,12 +561,13 @@ type word = string
     The last line in the text may not terminate with a newline. *)
 module Text = struct
 
-(** A (line structured) text is a {b list} of strings. *)
-type t = string list
-
 (** In this context, a line is not structured, it's a flatten string. *)
 type line = string
 
+(** A (line structured) text is a {b list} of strings. *)
+type t = line list
+
+
 (** Convert a string list in a raw text.
     Each string in the input list is treated by the function 
[ensure_cr_at_end] in order to
     add a newline if needed, then the list is folded by a simple catenation 
([^]).
@@ -641,6 +646,12 @@ let collapse_and_split ?do_not_squeeze ?(d=' ') t =
   let s = String.concat (Char.escaped d) t in
   split ?do_not_squeeze ~d s
 
+(** Merge fixed-length size groups of lines. *)  
+let merge_lines ?(sep=" ") (n:int) xs =
+  let xss = ArrayExtra.amass (n) (Array.of_list xs) in
+  let zs  = Array.map (fun ys -> String.concat sep (Array.to_list ys)) xss in
+  Array.to_list zs
+
 (** Converting raw text to matrix (list of list) of strings (words) and 
vice-versa. *)
 module Matrix = struct
 
diff --git a/EXTRA/stringExtra.mli b/EXTRA/stringExtra.mli
index 969d41d..bea1fc3 100644
--- a/EXTRA/stringExtra.mli
+++ b/EXTRA/stringExtra.mli
@@ -91,6 +91,7 @@ val to_charlist : string -> char list
 val of_charlist : char list -> string
 val expand : (char -> string option) -> string -> string
 val tr : char -> char -> string -> string
+val rm : char -> string -> string
 
 module Charlist :
   sig
@@ -126,7 +127,10 @@ module Text :
     val of_string : ?do_not_squeeze:unit -> string -> t
     val from_file : ?do_not_squeeze:unit -> string -> t
     val grep      : ?before:int -> ?after:int -> Str.regexp -> t -> t
+    (* --- *)
+    val merge_lines        : ?sep:string -> int -> t -> t
     val collapse_and_split : ?do_not_squeeze:unit -> ?d:char -> t -> word list
+    (* --- *)
     module Matrix :
       sig
         type t = word list list
diff --git a/EXTRA/unixExtra.ml b/EXTRA/unixExtra.ml
index 578664d..c9c584d 100644
--- a/EXTRA/unixExtra.ml
+++ b/EXTRA/unixExtra.ml
@@ -770,6 +770,19 @@ let script ?stdin ?stdout ?stderr ?pseudo ?(forward=[]) 
?register_pid (content:c
  end
 ;;
 
+let script_future ?stdin ?stdout ?stderr ?pseudo ?(forward=[]) ?register_pid 
(content:content) (argv_list:string list) : (int * string * string) Future.t =
+ begin
+ let program = temp_file ~perm:0o755 ~suffix:".sh" ~content () in
+ try
+  let k x y z = 
+    let () = Unix.unlink program in
+    (x,y,z)
+  in
+  kfuture ?stdin ?stdout ?stderr ?pseudo ~forward ?register_pid program 
argv_list k
+ with e -> ((Unix.unlink program); raise e)
+ end
+;;
+
 (** Tools for manipulating directory entries: *)
 module Dir = struct
 
diff --git a/EXTRA/unixExtra.mli b/EXTRA/unixExtra.mli
index 77c2500..11b1107 100644
--- a/EXTRA/unixExtra.mli
+++ b/EXTRA/unixExtra.mli
@@ -198,6 +198,15 @@ val script :
   ?register_pid:(int->unit) ->
   content -> string list -> process_result
 
+val script_future :
+  ?stdin:Endpoint.Source.t ->
+  ?stdout:Endpoint.Sink.t  ->
+  ?stderr:Endpoint.Sink.t  ->
+  ?pseudo:string ->
+  ?forward:int list ->
+  ?register_pid:(int->unit) ->
+  content -> string list -> process_result Future.t
+  
 type pid = int
 val is_process_alive : pid -> bool
 
diff --git a/SHELL/linux.ml b/SHELL/linux.ml
index f87ac9d..f13a423 100644
--- a/SHELL/linux.ml
+++ b/SHELL/linux.ml
@@ -31,7 +31,7 @@ module Process = struct
    session      : int;            (* %d (6) *)
    tty_nr       : int;            (* %d (7) *)
    tpgid        : int;            (* %d (8) *)
-   flags        : int;            (* %u (%lu before Linux 2.6.22) (9) *)
+   flags        : int64;          (* %lu (should be %u, or %lu before Linux 
2.6.22) (9) *)
    minflt       : int64;          (* %lu (10) *)
    cminflt      : int64;          (* %lu (11) *)
    majflt       : int64;          (* %lu (12) *)
@@ -62,8 +62,8 @@ module Process = struct
    cnswap       : int64;          (* %lu (37) *)
    exit_signal  : int;            (* %d (since Linux 2.1.22) (38) *)
    processor    : int;            (* %d (since Linux 2.2.8)  (39) *)
-   rt_priority  : int;            (* %u (since Linux 2.5.19; was %lu before 
Linux 2.6.22) (40) *)
-   policy       : int;            (* %u (since Linux 2.5.19; was %lu before 
Linux 2.6.22) (41) *)
+   rt_priority  : int64;          (* %lu (should be %u since Linux 2.5.19; was 
%lu before Linux 2.6.22) (40) *)
+   policy       : int64;          (* %lu (should be %u since Linux 2.5.19; was 
%lu before Linux 2.6.22) (41) *)
    delayacct_blkio_ticks : int64; (* %llu (since Linux 2.6.18) (42) *)
    guest_time   : int64;          (* %lu (since Linux 2.6.24) (43) *)
    cguest_time  : int64;          (* %ld (since Linux 2.6.24) (44) *)
@@ -92,25 +92,31 @@ module Process = struct
        guest_time=guest_time; cguest_time=cguest_time;
        }
 
+
+ let input_line_from_file filename =
+   try
+     let ch = open_in filename in
+     let result = try Some (input_line ch) with _ -> None in
+     let () = close_in ch in
+     result
+   with _ -> None
+
  let stat pid =
   let filename = Printf.sprintf "/proc/%d/stat" pid in
-  try
-    let ch = open_in filename in
-    let result =
+  Option.bind
+    (input_line_from_file filename)
+    begin fun line ->
       try
-       let obj = Scanf.fscanf ch
-        (* 0                           1                                      
2                                       3                                     4 
              *)
-         (* 1  2  3  4  5  6  7  8  9   0  1   2   3   4   5   6   7   8   9   
0   1   2   3   4   5  6   7   8   9   0   1   2   3   4   5   6   7   8  9  0  
1  2   3   4 *)
-          "%d %s %c %d %d %d %d %d %u %Lu %Lu %Lu %Lu %Lu %Lu %Ld %Ld %Ld %Ld 
%Ld %Ld %Lu %Lu %Ld %s %Lu %Lu %Lu %Lu %Lu %Lu %Lu %Lu %Lu %s %Lu %Lu %d %d %u 
%u %Lu %Lu %Ld"
+       let obj = Scanf.sscanf line
+        (* 0                           1                                       
2                                      3                                    4   
              *)
+         (* 1  2  3  4  5  6  7  8  9   0   1   2   3   4   5   6   7   8   9  
 0   1   2   3   4   5  6   7   8   9   0   1   2   3   4   5   6   7  8  9  0  
 1   2   3   4 *)
+          "%d %s %c %d %d %d %d %d %Lu %Lu %Lu %Lu %Lu %Lu %Lu %Ld %Ld %Ld %Ld 
%Ld %Ld %Lu %Lu %Ld %s %Lu %Lu %Lu %Lu %Lu %Lu %Lu %Lu %Lu %s %Lu %Lu %d %d %Lu 
%Lu %Lu %Lu %Ld"
          stat_constructor
        in
        Some obj
       with Scanf.Scan_failure(msg) ->
         (Printf.kfprintf flush stderr "Linux.stat: failed scanning file %s: 
%s\n" filename msg; None)
-    in
-    let () = close_in ch in
-    result
-  with _ -> None
+    end
 
  let easy_stat pid =
   let easy_stat_constructor pid comm state ppid pgrp session tty_nr tpgid 
other_fields =
@@ -127,19 +133,15 @@ module Process = struct
     end
   in
   let filename = Printf.sprintf "/proc/%d/stat" pid in
-  try
-    let ch = open_in filename in
-    let result =
+  Option.bind
+    (input_line_from_file filename)
+    begin fun line ->
       try
-       let obj = Scanf.fscanf ch "%d %s %c %d %d %d %d %d %s@\n" 
easy_stat_constructor in
+       let obj = Scanf.sscanf line "%d %s %c %d %d %d %d %d %s@\n" 
easy_stat_constructor in
        Some obj
       with Scanf.Scan_failure(msg) ->
         (Printf.kfprintf flush stderr "Linux.easy_stat: failed scanning file 
%s: %s\n" filename msg; None)
-    in
-    let () = close_in ch in
-    result
-  with _ -> None
-
+    end
 
  let get_proc_PID_directories () =
   let xs = UnixExtra.Dir.to_list ~entry_kind:Unix.S_DIR "/proc/" in
diff --git a/SHELL/linux.mli b/SHELL/linux.mli
index efccdb3..4a69497 100644
--- a/SHELL/linux.mli
+++ b/SHELL/linux.mli
@@ -59,7 +59,7 @@ module Process : sig
    tpgid : int;        (** %d (8) The ID of the foreground process group of the
                           controlling terminal of the process. *)
 
-   flags : int;        (** %u (%lu before Linux 2.6.22)
+   flags : int64;      (** %lu (should be %u, or %lu before Linux 2.6.22)
                           (9) The kernel flags word of the process.  For bit
                           meanings, see the PF_* defines in the Linux kernel
                           source file include/linux/sched.h.  Details depend
@@ -201,13 +201,13 @@ module Process : sig
    processor : int;    (** %d (since Linux 2.2.8)
                           (39) CPU number last executed on. *)
 
-   rt_priority : int;  (** %u (since Linux 2.5.19; was %lu before Linux 2.6.22)
+   rt_priority : int64;(** %lu (should be %u since Linux 2.5.19; was %lu 
before Linux 2.6.22)
                           (40) Real-time scheduling priority, a number in
                           the range 1 to 99 for processes scheduled under a
                           real-time policy, or 0, for non-real-time
                           processes (see sched_setscheduler(2)). *)
 
-   policy : int;       (** %u (since Linux 2.5.19; was %lu before Linux 2.6.22)
+   policy : int64;     (** %lu (should be %u since Linux 2.5.19; was %lu 
before Linux 2.6.22)
                           (41) Scheduling policy (see
                           sched_setscheduler(2)).  Decode using the SCHED_*
                           constants in linux/sched.h. *)
@@ -268,7 +268,7 @@ module Process : sig
  val get_descendant_easy_stats_as_forest : ?pid:int -> unit -> easy_stat 
Forest.t
 
  (** {2 Kill descendants}*)
- 
+
  (** Kill the whole hierarchy (forest) of the descendants of the caller (by 
default) or the provided [~pid].
      By default the children are processed concurrently (and recursively) 
using futures.
      The sequence of signals send to each process (from leafs to root) are (by 
default) the following in this order:
diff --git a/STRUCTURES/cortex.ml b/STRUCTURES/cortex.ml
index 33c6bc5..81715f2 100644
--- a/STRUCTURES/cortex.ml
+++ b/STRUCTURES/cortex.ml
@@ -635,7 +635,6 @@ type 'a scalar_or_cortex = ('a, ('a t)) Either.t
 let scalar x = Either.Left x
 let cortex x = Either.Right x
 
-(* La differenza con una view รจ che gli on_proposal sono distinti. *)
 let connection ?on_proposal ?on_commit ?private_fellow (f:'a->'b) (g:'b -> 'a) 
(member_x : 'a t) : 'b t =
   let (x_mutexes, x) = member_x in
   let mutexes = x_mutexes in
@@ -677,6 +676,41 @@ let connection ?on_proposal ?on_commit ?private_fellow 
(f:'a->'b) (g:'b -> 'a) (
   let () = Option.iter (Egg.wait) x_bell in
   group
 
+let view ?equality ?on_proposal ?on_commit ?private_fellow (f:'a->'b) 
(member_x : 'a t) : 'b t =
+  let (x_mutexes, x) = member_x in
+  let mutexes = x_mutexes in
+  let proposal () = f (x.Unprotected.get_content ()) in
+  let private_fellow : bool = (private_fellow = Some ()) in
+  let x_bell = if private_fellow then None else Some (Egg.create ()) in
+  let group =
+    Mutex_group.with_mutex mutexes
+      (fun () ->
+       let content_copy = ref (proposal ()) in
+       let get_content () = !content_copy in
+       let rec propose_content a =
+         begin
+           content_copy := a;
+           a
+         end
+       and
+         result : ('b t) Lazy.t =
+           lazy (make ~mutexes ?equality ?on_proposal ?on_commit ~get_content 
~propose_content ())
+       in
+       (* end of recursive definition *)
+       let (_, group_u) as group = (Lazy.force result) in
+       let membership () = not !(group_u.Unprotected.no_longer_in_use) in
+       let trigger_on (member) =
+         repeat_propose_to_group_on_member_commit
+           ~signal_me_in_critical_section:(Option.extract x_bell) ~membership 
~proposal ~group (member)
+       in
+       (* If the encapsulated cortex is private (not accessible outside the 
connection), nobody will
+          try to modify its state, so there is no need to install an observer: 
*)
+       let _thd1 = if private_fellow then None else Some (Thread.create 
(trigger_on) (member_x)) in
+       group)
+  in
+  let () = Option.iter (Egg.wait) x_bell in
+  group
+
 
 let wrapper ?on_proposal ?on_commit ?private_fellow (member_x : 'a t) : 'a t =
   let (x_mutexes, x) = member_x in
diff --git a/STRUCTURES/cortex.mli b/STRUCTURES/cortex.mli
index abd1852..8fb1031 100644
--- a/STRUCTURES/cortex.mli
+++ b/STRUCTURES/cortex.mli
@@ -76,6 +76,14 @@ val connection :
   ('b -> 'a) ->
   'a t -> 'b t
 
+val view :
+  ?equality:('b -> 'b -> bool) ->
+  ?on_proposal:('b -> 'b -> 'b) ->
+  ?on_commit:('b -> 'b -> unit) ->
+  ?private_fellow:unit ->
+  ('a -> 'b) ->
+  'a t -> 'b t
+
 (* A wrapper is a connection with the identity functions: *)
 val wrapper :
   ?on_proposal:('a -> 'a -> 'a) ->
diff --git a/STRUCTURES/cortex_lib.ml b/STRUCTURES/cortex_lib.ml
index ec2ca91..a59c255 100644
--- a/STRUCTURES/cortex_lib.ml
+++ b/STRUCTURES/cortex_lib.ml
@@ -400,3 +400,80 @@ module Service = struct
 
 
 end (* module Service *)
+
+module Channel = struct
+
+  (* The channel may be empty or it may contain a message for someone *)
+  type 'a t = ('a option) Cortex.t
+
+  let return
+    ?equality
+    ?on_proposal
+    ?on_commit
+    ?init
+    ()
+    =
+    let equality = match equality with
+    | None   -> None
+    | Some f ->
+        Some
+          (fun xo yo -> match xo,yo with
+           | None, None     -> true
+           | Some x, Some y -> f x y
+           | _,_ -> false)
+    in
+    Cortex.return ?equality ?on_proposal ?on_commit init
+
+  let receive (t:'a t) : 'a =
+    let (result, _changed) =
+      Cortex.eval
+       ~guard:(fun v -> v<>None)
+       (fun v () ->
+         match v with
+         | Some msg -> (None, (fun _ -> msg))
+         | None     -> assert false)
+       ()
+       t
+    in result
+
+  let send (t:'a t) (msg:'a) : bool =
+    let (result, changed) =
+      Cortex.eval
+       ~guard:(fun v -> v=None)
+       (fun v () ->
+         match v with
+         | None   -> (Some msg), (fun _accepted -> ())
+         | Some _ -> assert false)
+       ()
+       t
+     in
+     changed
+
+end (* Canal *)
+
+module Clock = struct
+
+  (* Just a counter incremented by an hidden thread. *)
+  type t = int Cortex.t
+
+  let make ?(init=0) ?limit ?(delay=1.) () =
+    let result = Cortex.return init in
+    let _orbiter =
+      let terminate =
+        match limit with
+        | None       -> (fun i -> false)
+        | Some limit -> ((=)limit)
+      in
+      let rec loop i =
+        if terminate i then () else (* continue: *)
+        let () = Thread.delay delay in
+        let i = i + 1 in
+        let () = Cortex.set result i in
+        loop i
+      in
+      Thread.create loop init
+   in
+   result
+
+end (* Clock *)
+
diff --git a/STRUCTURES/cortex_lib.mli b/STRUCTURES/cortex_lib.mli
index 92da080..50d0531 100644
--- a/STRUCTURES/cortex_lib.mli
+++ b/STRUCTURES/cortex_lib.mli
@@ -134,3 +134,27 @@ module Service : sig
     end
 
 end
+
+(* 1-position communication channels: *)
+module Channel : sig
+
+  (* The channel may be empty or it may contain a message for someone *)
+  type 'a t = ('a option) Cortex.t
+
+  val return :
+    ?equality:('a -> 'a -> bool) ->
+    ?on_proposal:('a option -> 'a option -> 'a option) ->
+    ?on_commit:('a option -> 'a option -> unit) ->
+    ?init:'a ->
+    unit -> 'a t
+
+  val receive  : 'a t -> 'a
+  val send     : 'a t -> 'a -> bool (* success/failure of sending *)
+
+end (* Canal *)
+
+module Clock : sig
+  type t = int Cortex.t
+  val make : ?init:int -> ?limit:int -> ?delay:float -> unit -> t
+end
+
diff --git a/STRUCTURES/endpoint.mli b/STRUCTURES/endpoint.mli
index 1692954..b82c5ce 100644
--- a/STRUCTURES/endpoint.mli
+++ b/STRUCTURES/endpoint.mli
@@ -67,13 +67,13 @@ module Source :
 module Sink :
  sig
   type t =
-  | Unix_descr  of Unix.file_descr
-  | Out_channel of out_channel
-  | Filename    of string
-  | Filename_append of string
+  | Unix_descr        of Unix.file_descr
+  | Out_channel       of out_channel
+  | Filename          of string
+  | Filename_append   of string
   | Filename_overtype of string
-  | Fun_thread  of (Unix.file_descr -> unit)
-  | String_queue of String_queue.t
+  | Fun_thread        of (Unix.file_descr -> unit)
+  | String_queue      of String_queue.t
   | Trash
 
   val to_file_descr  : t -> Unix.file_descr * bool
diff --git a/meta.ml.released b/meta.ml.released
index 56a0abd..3d00f91 100644
--- a/meta.ml.released
+++ b/meta.ml.released
@@ -9,8 +9,8 @@ let libraryprefix = "/usr/lib/ocaml";;
 let configurationprefix = "/etc";;
 let localeprefix = "/usr/local/share/locale";;
 let documentationprefix = "/usr/local/share/doc";;
-let uname = "Linux 3.12-1-amd64 #1 SMP Debian 3.12.9-1 (2014-02-01) x86_64 
GNU/Linux";;
-let build_date = "2014-04-02 16:27:28 +0200";;
-let revision = "393";;
-let source_date = "2014-03-24 16:51:07 +0100";;
-let source_date_utc_yy_mm_dd = "2014-03-24";;
+let uname = "Linux 3.14-1-amd64 #1 SMP Debian 3.14.7-1 (2014-06-16) x86_64 
GNU/Linux";;
+let build_date = "2014-07-08 11:09:04 +0200";;
+let revision = "400";;
+let source_date = "2014-07-02 17:17:17 +0200";;
+let source_date_utc_yy_mm_dd = "2014-07-02";;

-- 
Alioth's /usr/local/bin/git-commit-notice on 
/srv/git.debian.org/git/pkg-ocaml-maint/packages/ocamlbricks.git

_______________________________________________
Pkg-ocaml-maint-commits mailing list
Pkg-ocaml-maint-commits@lists.alioth.debian.org
http://lists.alioth.debian.org/cgi-bin/mailman/listinfo/pkg-ocaml-maint-commits

Reply via email to