caml-list - the Caml user's mailing list
 help / color / mirror / Atom feed
* [Caml-list] [ANN] The Missing Library
@ 2004-04-23 18:51 John Goerzen
  2004-04-23 19:52 ` Kenneth Knowles
  2004-04-23 20:41 ` Eric C. Cooper
  0 siblings, 2 replies; 210+ messages in thread
From: John Goerzen @ 2004-04-23 18:51 UTC (permalink / raw)
  To: caml-list

Hello,

Some of you may remember my complaints about missing functions in the
standard library.  To help address those, I have started work on my own
OCaml library to augment the standard functions.  You can obtain it,
along with online API docs covering every function, at: 

  gopher://quux.org/1/devel/missinglib
  
  or

  http://quux.org/devel/missinglib

[Debian users: I have uploaded it to sid, but will take a few days to
appear.]

Some excerpts from the README:

Missinglib is a collection of OCaml-related utilities.  The following
modules are are provided:

ConfigParser            System for parsing configuration files
Hashtbloper             Hash table convenience operators
Hashtblutil             Hash table utilities
Lexingutil              Lexing-related utilities
Listutil                List-manipulation utilities
Slice                   Underlying API for Slice operators
Sliceoper               Flexible subparts of arrays, lists, and strings
Streamutil              Stream parser utilities
Strutil                 String-related utilities

The entire library has no prerequisites save the OCaml standard library and
findlib and is designed to install without complexity on a variety of
systems.  It could also easily be embedded within your own source trees
so that users need not have it installed beforehand.

----------

I would greatly appreciate constructive criticism on any aspect of the
package, especially the build system.  I have tried to make it possible
to "make; make install" on just about any platform, regardless of
availability of ocamlopt.  It took some hoop-jumping, though, so
suggestions are welcome :-)

Some basic info on the modules present: The ConfigParser module can read
and write sectioned .INI-style files and is mostly compatible with
Python's ConfigParser module.  Sliceoper defines some more powerful ways
of indexing arrays, lists, and strings (some of these concepts were
discussed on this list).  Strutil provides functions like strip, lstrip,
and rstrip (removes whitespace from either end, beginning, or end, of a
string).  Listutil provides a "replace" that is analogous to
Hashtbl.replace, but for association lists; and "sub" that is similar to
String.sub or Array.sub.  Hashtbloper defines some more useful ways of
working with hash tables, such as:

  hash /> 5 

   is the same as: 

  Hashtbl.find hash 5 

    let sections = Hashtbl.create 5;;
    let options = Hashtbl.create 5;;
    Hashtbl.replace options "option1" "value1";;
    Hashtbl.replace sections "section1" options;;
    sections /> "section1" /> "option1";;
                 returns "value1" 

   let newhash = hash // ("key", "value");; 

      (Copies hash, adds the pair to the copy, and returns it -- similar
       in concept to :: for lists)

BTW, is this list the right place for a message like this?

-- John

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners


^ permalink raw reply	[flat|nested] 210+ messages in thread
* [Caml-list] Re: Common IO structure
@ 2004-05-03  6:12 Vladimir N. Silyaev
  2004-05-04 21:31 ` Benjamin Geer
  0 siblings, 1 reply; 210+ messages in thread
From: Vladimir N. Silyaev @ 2004-05-03  6:12 UTC (permalink / raw)
  To: caml-list

[-- Attachment #1: Type: text/plain, Size: 1402 bytes --]


I'm relatively new to ocaml and very new to this list. Browsing thru recent
discussion about standard IO structure, I felt that discussion was cycled 
over what signature of the "universal" class should look like, so it would 
satisfy all possible needs.

However looks like prospective users, of this new IO, have rather 
contradictive requirements to the IO in general. And I'm thinking could 
standard IO only to provide basic signature of the IO modules and framework 
for layered IO.  Doing so additional functionality could be added 
incrementally, without affection core IO and achieving interoperability 
between different libraries which are using that IO.

Last day or two I was playing with ocaml and ocaml module system, and 
sketched some variant of basic IO. This sketch based on imperative 
streams, where stream is module parameterized by the symbol type. However 
blocked based IO is also supported, test code includes naive functors to 
translate from a block based IO to a stream IO.

If you felt interested, please look into the attached file io.ml. 

In the file you would found wrappers for Pervasive file IO, rudimentary
socket I/O, naive UTF8 filter and generic I/O algorithms. At the end
of file there are several test cases to exercise I/O extensibility.

File is self sufficient example and one should be able to compile it or run
in the toplevel. 
	

Regards,
Vladimir





[-- Attachment #2: io.ml --]
[-- Type: text/plain, Size: 10705 bytes --]


module Stream = struct
  module type Read =  sig
    type t 
    type symbol
    val get: t -> symbol
  end
  module type Write =  sig
    type t 
    type symbol
    val put: t -> symbol -> unit
  end
end

module Block =
struct
  module type Read = 
  sig
    type t 
    val read:  t -> string -> int -> int -> int
  end
  module type Write = 
  sig
    type t 
    val write: t -> string -> int -> int -> unit
  end
end

module Filter = struct
  module type Read =  sig    
    include Stream.Read
    type source 
    val flush: t -> unit
    val attach: source -> t
  end
  module type Write =  sig
    include Stream.Write
    type dest
    val flush: t -> unit
    val attach: dest -> t
  end
end



module File = struct
  module Read = struct
    type file = Pervasives.in_channel
    type t = file
    let _open name :t = Pervasives.open_in_bin name
    let close (t:t) = Pervasives.close_in t
    let seek = seek_in 
    let pos = pos_in
    type symbol = char
    let get (t:t) = Pervasives.input_char t
    let read (t:t) ic buf pos = Pervasives.input t ic buf pos
  end
  module Write = struct
    type file = Pervasives.out_channel
    type t = file
    let _open name :t = Pervasives.open_out_bin name
    let close (t:t) = Pervasives.close_out t
    let seek = seek_out 
    let pos = pos_out
    type symbol = char
    let put (t:t) ch = Pervasives.output_char t ch
    let write = Pervasives.output
  end
end


module Buffer = struct
  module Read(B:Block.Read) : (Filter.Read with type symbol=char and type source=B.t)  = struct
    type t = {
      buf : String.t;
      mutable pos : int;
      mutable level: int;
      source: B.t
    }
    type source = B.t
    type symbol = char
    let attach b =
      let blen = 1024 in
	{
	  buf = String.create blen;
	  pos = 0;	  
	  level = 0;
	  source = b	
	}
    let get t = 
      if t.pos = t.level then begin
	match B.read t.source t.buf 0 (String.length t.buf) with
	    0 -> raise End_of_file
	  | n -> 
	      t.pos <- 0;
	      t.level <- n
      end;	
      let ch = t.buf.[t.pos] in
	t.pos <- t.pos + 1;
	ch	  
    let flush t = 
      t.pos <- 0;
      t.level <- 0
	
  end

  module Write(B:Block.Write) : (Filter.Write with type symbol=char and type dest=B.t)  = struct
    type dest = B.t
    type symbol = char
    type t = {
      buf : String.t;
      mutable pos : int;
      dest: B.t
    }
    let attach t = {
      buf = String.create 256;
      pos = 0;
      dest = t;		     
    }

    let flush t = 
      B.write t.dest t.buf 0 t.pos;
      t.pos <- 0

    let put t ch = 
       t.buf.[t.pos] <- ch;
       t.pos <- t.pos + 1;
       if t.pos >= String.length t.buf then flush t
  end

end

module Socket = struct
  type sock = Unix.file_descr
  type t = sock
  let create ?(domain=Unix.PF_INET) ?(protocol=0) _type   :t =  Unix.socket domain _type protocol 
  let close  = Unix.close
  module Read = struct 
    type t = sock	  
    let read  = Unix.read 
    let shutdown s = Unix.shutdown s Unix.SHUTDOWN_RECEIVE
  end
  module Write = struct
    type t = sock
    let rec write t buf off len = 
      match Unix.write t buf off len with
	  n when n=len -> ()
	| n -> write t buf (off+n) (len-n)
    let shutdown s = Unix.shutdown s Unix.SHUTDOWN_SEND
  end
  let connect ?sock addr :(Read.t*Write.t) = 
    let s = match sock with 
	Some sock -> sock
      | None ->  create Unix.SOCK_STREAM in
      Unix.connect s addr;
      (s,s)
end

module UTF8  = struct
  exception InvalidSymbol  
  type utf8 = int
  type t = utf8
  module Read(Src:Stream.Read with type symbol=char) : (Filter.Read with type symbol=utf8 and type source=Src.t) = struct
    type symbol = utf8
    type t = Src.t
    type source = Src.t
    let attach (t:Src.t) : t = t
    let flush t = ()
    let get t = 
      let next t = 
	let ch = int_of_char (Src.get t) in
	  if (ch land 0xC0) = 0x80 then ch land 0x3F else raise InvalidSymbol in
      let ch0 = int_of_char (Src.get t) in
	if ch0 < 0x80 then ch0
	else if ch0 < 0xE0 then
	  let ch1 = next  t in
	  let ch = ((ch0 land 0x1F) lsl 6) lor ch1 in
	  if ch < 0x80 then raise InvalidSymbol
	  else ch
	else if ch0 < 0xF0 then
	  let ch1 = next t in
	  let ch2 = next t in
	  let ch = ((ch0 land 0x0F) lsl 12) lor (ch1 lsl 6) lor ch2 in
	    if ch < 0x800 then raise InvalidSymbol
	    else ch
	else if ch0 < 0xF8 then
	  let ch1 = next t in
	  let ch2 = next t in
	  let ch3 = next t in
	  let ch = ((ch0 land 0x03) lsl 18) lor (ch1 lsl 12) lor (ch2 lsl 6) lor ch3 in
	    if ch < 0x10000 then raise InvalidSymbol
	    else ch
	else raise InvalidSymbol
  end     
  module Write(Dst:Stream.Write with type symbol=char): (Filter.Write with type symbol=utf8 and type dest=Dst.t)  = struct
    type symbol = utf8
    type dest = Dst.t
    type t = Dst.t
    let attach t = t
    let flush t = ()
    let put t ch = 
      if ch < 0x80 then Dst.put t (char_of_int ch)
      else if ch < 0x800 then begin
	Dst.put t (char_of_int (0xC0 lor (ch lsr 6)));
	Dst.put t (char_of_int (0x80 lor (ch land 0x3F)))
      end else if ch < 0x10000 then begin
	Dst.put t (char_of_int (0xE0 lor (ch lsr 12)));
	Dst.put t (char_of_int (0x80 lor ((ch lsr 6) land 0x3F)));
	Dst.put t (char_of_int (0x80 lor (ch land 0x3F)))
      end else if ch < 0x110000 then begin
	Dst.put t (char_of_int (0xF0 lor (ch lsr 18)));
	Dst.put t (char_of_int (0x80 lor ((ch lsr 12) land 0x3F)));
	Dst.put t (char_of_int (0x80 lor ((ch lsr 6) land 0x3F)));
	Dst.put t (char_of_int (0x80 lor (ch land 0x3F)))
      end else raise InvalidSymbol	
  end    
end

module type Type =
  sig
    type t
  end

module Char = struct
  type t = char
end

module Copy (T:Type) (Src:Stream.Read with type symbol=T.t) (Dst:Stream.Write with type symbol=T.t) = struct
  let run s d =
    while true do
      Dst.put d (Src.get s)
    done
end

  
let copy_byte src dst = 
  let module CopyFile = Copy(Char) (File.Read) (File.Write) in
  let src = File.Read._open src
  and dst = File.Write._open dst in
    try CopyFile.run src dst
    with End_of_file ->
      File.Read.close src;
      File.Write.close dst
      

module FileWriteUtf8 = UTF8.Write (File.Write)

let copy_utf src dst = 
  let module FileReadUtf8 = UTF8.Read (File.Read) in
  let module CopyFile = Copy(UTF8) (FileReadUtf8) (FileWriteUtf8) in
  let src = File.Read._open src
  and dst = File.Write._open dst in
  let src8 = FileReadUtf8.attach src
  and dst8 = FileWriteUtf8.attach dst
  in
    try CopyFile.run src8 dst8
    with End_of_file ->
      File.Read.close src;
      File.Write.close dst

module BufferedFileRead = Buffer.Read(File.Read)
module BufferedFileReadUtf8 = UTF8.Read(BufferedFileRead)
module FileReadUtf8 = UTF8.Read(File.Read)


let copy_utf2 src dst = 
  let module CopyFile = Copy (UTF8) (BufferedFileReadUtf8) (FileWriteUtf8) in 
  let src = File.Read._open src
  and dst = File.Write._open dst in
  let srcb = BufferedFileRead.attach src in
  let src8 = BufferedFileReadUtf8.attach srcb
  and dst8 = FileWriteUtf8.attach dst
  in
    try CopyFile.run src8 dst8
    with End_of_file ->
      File.Read.close src;
      File.Write.close dst

module Utf2Ascii (Dst:Stream.Write with type symbol=char )  = struct
  type symbol = UTF8.t
  type t = Dst.t
  type dest = Dst.t
  let attach (t:Dst.t) :t = t
  let put t ch = 
    match ch with
	ch when ch < 0x80 -> Dst.put t (char_of_int ch)
      | _ -> Dst.put t ' '
end



let copy_utf2ascii src dst = 
  let module FileWriteAscii = Utf2Ascii(File.Write) in
  let module CopyFile = Copy (UTF8) (BufferedFileReadUtf8) (FileWriteAscii) in
  let src = File.Read._open src
  and dst = File.Write._open dst in
  let srcb = BufferedFileRead.attach src in
  let src8 = BufferedFileReadUtf8.attach srcb in
  let dsta = FileWriteAscii.attach dst in
    try CopyFile.run src8 dsta
    with End_of_file ->
      File.Read.close src;
      File.Write.close dst


module Static = struct
  type symbol = char
  type t = {
    mutable pos: int;
    mutable buf: String.t list;
    mutable cur: String.t
  }
  let attach l = {
    pos = 0;
    buf = l;
    cur = "";
  }
  let rec get t = 
    if t.pos < String.length t.cur then begin
      let ch = t.cur.[t.pos] in
	t.pos <- t.pos + 1;
	ch
    end else match t.buf with 
	hd::tl -> 
	  t.buf <- tl;
	  t.pos <- 0;
	  t.cur <- hd;
	  get t
      | [] -> raise End_of_file
    
end

  

let copy_static dst = 
  let module CopyFile = Copy (Char) (Static) (File.Write) in
  let dst = File.Write._open dst
  and src = Static.attach ["Hello";"\n";"World";"\n"] in
    try CopyFile.run src dst
    with End_of_file ->
      File.Write.close dst

module StreamSockRead = Buffer.Read(Socket.Read)
module StreamSockWrite = Buffer.Write(Socket.Write)

let get_utf8 host url dst = 
  let addr = Unix.ADDR_INET((Unix.gethostbyname host).Unix.h_addr_list.(0), 80) in
  let (sr,sw) = Socket.connect addr in
  let req = Static.attach  ["GET"; " ";url; " "; "HTTP/0.9";"\n";"\n"] in
  let sock_wr = StreamSockWrite.attach sw 
  and sock_rd = StreamSockRead.attach sr in
  let module SendReq = Copy (Char) (Static) (StreamSockWrite) in
    try SendReq.run req sock_wr with
	End_of_file ->
	  StreamSockWrite.flush sock_wr;
 	  let dst = File.Write._open dst in
	  let module GetFile = Copy (Char) (StreamSockRead) (File.Write) in
	    try GetFile.run sock_rd dst with
		End_of_file ->
		  Socket.close sr;
		  File.Write.close dst		    

module Length (T:Type) (Src:Stream.Read with type symbol=T.t) = struct
  let get s = 
    let len = ref 0 in
      try while true do
	ignore (Src.get s);
	incr len
      done; -1
      with End_of_file -> !len
end


		    
let length file = 
  let src = File.Read._open file in
  let module FileCharLen = Length (Char) (File.Read)  in
  let len = FileCharLen.get src in
    File.Read.seek src 0;
    let module FileUtf8Len = Length (UTF8) (FileReadUtf8) in
    let usrc = FileReadUtf8.attach src in
    let len8 = FileUtf8Len.get usrc in
      File.Read.close src;
      len,len8
    
  
let run () = 
  let html = "utf8.html" in
  List.iter (
    fun (desc,op,file) ->
      print_endline desc;
      op file;
      let (bytes,symbols) = length file in
	Printf.printf "Done. File '%s'; bytes %d, symbols %d\n" file bytes symbols
  ) [ 
    "Hello World", copy_static, "static.dat";
    "Getting corpse from a web ..", (get_utf8 "www.columbia.edu"  "/kermit/utf8.html" ), html;
    "Copying corpse using bytecopy", (copy_byte html), "copy.dat";
    "Copying corpse using utf8 symbols", (copy_utf html), "copy_utf8.dat";
    "Copying corpse using utf8 symbols and read buffer", (copy_utf2 html), "copy_utf8_2.dat";
    "Converting corpse to ASCII", (copy_utf2ascii html), "ascii.dat";
  ]
    

	      
	       
	       
let _ = run ()

^ permalink raw reply	[flat|nested] 210+ messages in thread
end of thread, other threads:[~2004-05-09 17:35 UTC | newest]

Thread overview: 210+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2004-04-23 18:51 [Caml-list] [ANN] The Missing Library John Goerzen
2004-04-23 19:52 ` Kenneth Knowles
2004-04-23 20:09   ` Alexander V. Voinov
2004-04-23 20:27     ` John Goerzen
2004-04-23 20:23   ` John Goerzen
2004-04-23 20:36     ` Maxence Guesdon
2004-04-23 21:10       ` John Goerzen
2004-04-23 21:12         ` Maxence Guesdon
2004-04-23 21:18           ` Maxence Guesdon
2004-04-23 21:32             ` Nicolas Cannasse
2004-04-23 21:46             ` John Goerzen
2004-04-23 21:58               ` Maxence Guesdon
2004-04-24  8:15                 ` Matthieu BRUCHER
2004-04-24  8:15                   ` Maxence Guesdon
2004-04-23 21:36           ` John Goerzen
2004-04-23 21:33         ` John Goerzen
2004-04-23 22:04           ` Alain.Frisch
2004-04-24  4:26             ` John Goerzen
2004-04-24  8:13               ` Alain.Frisch
2004-04-24  9:28                 ` Nicolas Cannasse
2004-04-25  8:56                   ` Common IO structure (was Re: [Caml-list] [ANN] The Missing Library) Yamagata Yoriyuki
2004-04-25 11:54                     ` Gerd Stolpmann
2004-04-26 14:53                       ` [Caml-list] Re: Common IO structure Yamagata Yoriyuki
2004-04-26 21:02                         ` Gerd Stolpmann
2004-04-25 19:42                     ` Common IO structure (was Re: [Caml-list] [ANN] The Missing Library) Nicolas Cannasse
2004-04-26 13:16                       ` [Caml-list] Re: Common IO structure Yamagata Yoriyuki
2004-04-26 13:53                         ` Jacques GARRIGUE
2004-04-26 14:26                           ` Nicolas Cannasse
2004-04-28  6:52                             ` Jacques GARRIGUE
2004-04-26 14:23                         ` Nicolas Cannasse
2004-04-26 14:55                           ` skaller
2004-04-26 15:26                           ` Yamagata Yoriyuki
2004-04-26 19:28                             ` Nicolas Cannasse
2004-04-26 20:56                               ` Gerd Stolpmann
2004-04-26 21:14                                 ` John Goerzen
2004-04-26 22:32                                   ` Gerd Stolpmann
2004-04-26 21:52                                 ` Benjamin Geer
2004-04-27 16:00                                 ` Yamagata Yoriyuki
2004-04-27 21:51                                   ` Gerd Stolpmann
2004-04-27 19:08                                 ` Nicolas Cannasse
2004-04-27 22:22                                   ` Gerd Stolpmann
2004-04-28  7:42                                     ` Nicolas Cannasse
2004-04-29 10:13                                   ` Yamagata Yoriyuki
2004-04-27 15:43                               ` Yamagata Yoriyuki
2004-04-27 16:17                                 ` Nicolas Cannasse
2004-04-27 16:58                                   ` Yamagata Yoriyuki
2004-04-27 23:35                                     ` Benjamin Geer
2004-04-28  3:44                                       ` John Goerzen
2004-04-28 13:01                                         ` Richard Jones
2004-04-28 21:30                                         ` Benjamin Geer
2004-04-28 21:44                                           ` John Goerzen
2004-04-28 22:41                                             ` Richard Jones
2004-04-29 11:51                                               ` Benjamin Geer
2004-04-29 12:03                                                 ` Richard Jones
2004-04-29 15:16                                                   ` Benjamin Geer
2004-04-29 10:27                                             ` Yamagata Yoriyuki
2004-04-29 13:03                                               ` John Goerzen
2004-04-29 13:40                                                 ` Yamagata Yoriyuki
2004-04-29 14:02                                                   ` John Goerzen
2004-04-29 15:31                                                     ` Yamagata Yoriyuki
2004-04-29 17:31                                                       ` james woodyatt
2004-04-29 23:53                                                         ` Benjamin Geer
2004-04-30  4:10                                                           ` james woodyatt
2004-04-29 11:23                                             ` Benjamin Geer
2004-04-29 12:23                                               ` Richard Jones
2004-04-29 15:10                                                 ` Benjamin Geer
2004-04-29 15:35                                                   ` John Goerzen
2004-04-29 15:46                                                     ` Benjamin Geer
2004-04-29 15:58                                                       ` Richard Jones
2004-04-29 20:41                                                       ` John Goerzen
2004-04-29 22:35                                                         ` Benjamin Geer
2004-05-01 14:37                                                 ` Brian Hurt
2004-04-29 13:23                                               ` John Goerzen
2004-04-29 14:12                                                 ` John Goerzen
2004-04-29 15:37                                                 ` Benjamin Geer
2004-04-28  7:05                                       ` Nicolas Cannasse
2004-04-28  0:20                                     ` skaller
2004-04-28  3:39                                     ` John Goerzen
2004-04-28 13:04                                     ` Richard Jones
2004-04-24  9:40               ` [Caml-list] [ANN] The Missing Library Oliver Bandel
2004-04-23 22:54           ` Henri DF
2004-04-23 23:11           ` Shawn Wagner
2004-04-25  6:55           ` james woodyatt
2004-04-25  7:56             ` Brandon J. Van Every
2004-04-25 11:50             ` Benjamin Geer
2004-04-25 13:55               ` skaller
2004-04-26 12:08                 ` Martin Berger
2004-04-26 12:51                   ` skaller
2004-04-26 14:49                   ` skaller
2004-04-28  4:31                   ` Brian Hurt
2004-04-28  5:13                     ` Jon Harrop
2004-04-28  8:37                       ` skaller
2004-04-28  9:18                         ` Jon Harrop
2004-04-28 11:24                           ` skaller
2004-04-28 15:18                             ` John Goerzen
2004-04-28 16:28                               ` skaller
2004-04-28 18:02                                 ` John Goerzen
2004-04-29  0:54                                   ` skaller
2004-04-29 11:57                                     ` Andreas Rossberg
2004-04-29 13:38                                     ` John Goerzen
2004-04-28 18:42                                 ` Jon Harrop
2004-04-29  1:03                                   ` skaller
2004-04-29  1:56                                     ` Jon Harrop
2004-04-29  2:35                                       ` skaller
2004-04-29  3:00                                       ` skaller
2004-04-29  5:04                                         ` Jon Harrop
2004-04-29  5:38                                           ` skaller
2004-04-29  5:47                                     ` james woodyatt
2004-04-29 12:05                                     ` Andreas Rossberg
2004-04-28 17:07                             ` james woodyatt
2004-04-28 17:31                               ` skaller
2004-05-03  0:02                                 ` Marcin 'Qrczak' Kowalczyk
2004-05-03  7:54                                   ` skaller
2004-05-03  8:58                                     ` Marcin 'Qrczak' Kowalczyk
2004-05-03 10:58                                       ` skaller
2004-05-03 12:40                                         ` Marcin 'Qrczak' Kowalczyk
2004-05-03 13:04                                           ` Nicolas Cannasse
2004-05-03 14:24                                           ` brogoff
2004-05-03 15:26                                             ` Marcin 'Qrczak' Kowalczyk
2004-05-03 15:08                                           ` skaller
2004-05-03 16:00                                             ` Marcin 'Qrczak' Kowalczyk
2004-05-03 11:32                                       ` [Caml-list] Re: Tail-calls in C code (was: [ANN] The Missing Library) Wolfgang Lux
2004-05-03 12:34                                         ` skaller
2004-05-03 12:38                                         ` skaller
2004-05-03 12:55                                           ` skaller
2004-05-03 13:02                                         ` Marcin 'Qrczak' Kowalczyk
2004-04-28 15:15                       ` [Caml-list] [ANN] The Missing Library John Goerzen
2004-04-28 20:43                         ` Jon Harrop
2004-04-30 15:58                       ` Brian Hurt
2004-05-01  2:48                         ` skaller
2004-04-28  8:24                     ` skaller
2004-04-28  8:42                       ` Martin Berger
2004-04-28 11:38                         ` skaller
2004-04-28 16:07                           ` [Caml-list] " Shivkumar Chandrasekaran
2004-04-28 11:31                       ` [Caml-list] " Yaron M. Minsky
2004-04-28 12:09                         ` skaller
2004-04-28 12:36                           ` Nicolas Cannasse
2004-04-28 13:39                             ` skaller
2004-04-28 14:02                               ` Nicolas Cannasse
2004-04-28 15:34                                 ` skaller
2004-04-28 13:15                           ` Jean-Christophe Filliatre
2004-04-28 14:31                             ` skaller
2004-04-28 14:40                               ` Jean-Christophe Filliatre
2004-04-28 15:51                                 ` skaller
2004-04-28 13:29                           ` Andreas Rossberg
2004-04-28 16:10                           ` [Caml-list] " Shivkumar Chandrasekaran
2004-04-28 17:14                             ` skaller
2004-04-28 17:34                               ` Shivkumar Chandrasekaran
2004-04-28 20:00                               ` Jon Harrop
2004-04-25 12:20             ` [Caml-list] " Benjamin Geer
2004-04-25 14:06               ` skaller
2004-04-25 15:07                 ` Benjamin Geer
2004-04-26  0:19                   ` skaller
2004-04-23 22:08         ` Basile STARYNKEVITCH
2004-04-24  4:40           ` John Goerzen
2004-04-24 10:10           ` Oliver Bandel
2004-04-24 19:31             ` skaller
2004-04-23 20:54     ` Kenneth Knowles
2004-04-23 21:07       ` John Goerzen
2004-04-25 15:43       ` Brian Hurt
2004-04-26  0:22         ` skaller
2004-04-28  4:10           ` Brian Hurt
2004-04-26  6:48     ` Florian Hars
2004-04-23 20:41 ` Eric C. Cooper
2004-04-23 21:16   ` John Goerzen
2004-04-23 22:28     ` Shawn Wagner
2004-04-23 22:37       ` Kenneth Knowles
2004-04-23 23:16         ` Shawn Wagner
2004-04-24  1:38           ` [Caml-list] ocamlopt -pack portability John Carr
2004-04-24 10:31             ` Oliver Bandel
2004-04-24 16:53               ` John Carr
2004-04-24  4:46         ` [Caml-list] [ANN] The Missing Library John Goerzen
2004-04-24  2:43       ` Yamagata Yoriyuki
2004-04-24  9:19         ` Nicolas Cannasse
2004-04-24 12:27           ` Shawn Wagner
2004-04-24 12:58             ` Alain.Frisch
2004-04-24 17:36               ` Nicolas Cannasse
2004-04-26 14:49               ` Florian Hars
2004-04-24  2:44       ` Yamagata Yoriyuki
2004-04-24  4:51       ` John Goerzen
2004-04-24  5:11         ` Jon Harrop
2004-04-24 12:59       ` Proposal: community standard library project (was: Re: [Caml-list] [ANN] The Missing Library) Benjamin Geer
2004-04-24 17:29         ` [Caml-list] RE: Proposal: community standard library project Brandon J. Van Every
2004-04-24 18:23           ` Benjamin Geer
2004-04-25  4:37             ` Brandon J. Van Every
2004-04-26  1:45         ` [Caml-list] " Jacques GARRIGUE
2004-04-26  3:03           ` Brandon J. Van Every
2004-04-26  7:43           ` Martin Jambon
2004-04-26 18:25           ` Benjamin Geer
2004-04-26 19:37             ` Gerd Stolpmann
2004-04-26 20:24               ` skaller
2004-04-26 20:39                 ` John Goerzen
2004-04-26 22:17                   ` Brandon J. Van Every
2004-04-27  9:06                   ` skaller
2004-04-27  9:35                     ` Alain.Frisch
2004-04-27 11:29                     ` Gerd Stolpmann
2004-04-27 12:52                       ` skaller
2004-04-27 18:13                       ` [Caml-list] CVS labeling (was Re: Proposal: community standard library project) Brandon J. Van Every
2004-04-27 18:53                         ` John Goerzen
2004-05-03  6:12 [Caml-list] Re: Common IO structure Vladimir N. Silyaev
2004-05-04 21:31 ` Benjamin Geer
2004-05-04 22:59   ` Yamagata Yoriyuki
2004-05-05  8:11     ` skaller
2004-05-05 15:48       ` Marcin 'Qrczak' Kowalczyk
2004-05-05 19:28         ` skaller
2004-05-05 17:33     ` Vladimir N. Silyaev
2004-05-05 17:31   ` Vladimir N. Silyaev
2004-05-07 22:11     ` Benjamin Geer
2004-05-08  7:29       ` Vladimir N. Silyaev
2004-05-09 17:35         ` Benjamin Geer

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).