You can subscribe to this list here.
2003 
_{Jan}

_{Feb}
(81) 
_{Mar}
(97) 
_{Apr}
(88) 
_{May}
(80) 
_{Jun}
(170) 
_{Jul}
(9) 
_{Aug}

_{Sep}
(18) 
_{Oct}
(58) 
_{Nov}
(19) 
_{Dec}
(7) 

2004 
_{Jan}
(22) 
_{Feb}
(9) 
_{Mar}
(28) 
_{Apr}
(164) 
_{May}
(186) 
_{Jun}
(101) 
_{Jul}
(143) 
_{Aug}
(387) 
_{Sep}
(69) 
_{Oct}
(14) 
_{Nov}
(8) 
_{Dec}
(99) 
2005 
_{Jan}
(10) 
_{Feb}
(34) 
_{Mar}
(24) 
_{Apr}
(7) 
_{May}
(41) 
_{Jun}
(20) 
_{Jul}
(3) 
_{Aug}
(23) 
_{Sep}
(2) 
_{Oct}
(26) 
_{Nov}
(41) 
_{Dec}
(7) 
2006 
_{Jan}
(6) 
_{Feb}
(3) 
_{Mar}
(11) 
_{Apr}

_{May}

_{Jun}
(5) 
_{Jul}
(8) 
_{Aug}
(20) 
_{Sep}

_{Oct}
(6) 
_{Nov}
(5) 
_{Dec}

2007 
_{Jan}

_{Feb}
(1) 
_{Mar}

_{Apr}
(3) 
_{May}
(2) 
_{Jun}

_{Jul}

_{Aug}
(1) 
_{Sep}
(7) 
_{Oct}
(6) 
_{Nov}
(19) 
_{Dec}
(11) 
2008 
_{Jan}

_{Feb}
(7) 
_{Mar}
(9) 
_{Apr}
(21) 
_{May}
(42) 
_{Jun}
(27) 
_{Jul}
(28) 
_{Aug}
(26) 
_{Sep}
(16) 
_{Oct}
(32) 
_{Nov}
(49) 
_{Dec}
(65) 
2009 
_{Jan}
(35) 
_{Feb}
(20) 
_{Mar}
(36) 
_{Apr}
(42) 
_{May}
(111) 
_{Jun}
(99) 
_{Jul}
(70) 
_{Aug}
(25) 
_{Sep}
(15) 
_{Oct}
(29) 
_{Nov}
(3) 
_{Dec}
(18) 
2010 
_{Jan}
(10) 
_{Feb}
(4) 
_{Mar}
(57) 
_{Apr}
(63) 
_{May}
(71) 
_{Jun}
(64) 
_{Jul}
(30) 
_{Aug}
(49) 
_{Sep}
(11) 
_{Oct}
(4) 
_{Nov}
(2) 
_{Dec}
(3) 
2011 
_{Jan}
(1) 
_{Feb}
(1) 
_{Mar}

_{Apr}

_{May}

_{Jun}
(1) 
_{Jul}
(1) 
_{Aug}
(2) 
_{Sep}

_{Oct}

_{Nov}

_{Dec}
(1) 
2012 
_{Jan}

_{Feb}

_{Mar}

_{Apr}

_{May}

_{Jun}

_{Jul}

_{Aug}
(1) 
_{Sep}

_{Oct}

_{Nov}

_{Dec}

2013 
_{Jan}

_{Feb}
(1) 
_{Mar}

_{Apr}

_{May}

_{Jun}

_{Jul}

_{Aug}

_{Sep}

_{Oct}

_{Nov}

_{Dec}

2014 
_{Jan}

_{Feb}

_{Mar}

_{Apr}

_{May}

_{Jun}
(2) 
_{Jul}

_{Aug}

_{Sep}
(1) 
_{Oct}

_{Nov}
(1) 
_{Dec}

S  M  T  W  T  F  S 


1

2
(1) 
3

4

5
(2) 
6

7

8

9
(3) 
10
(1) 
11

12

13

14

15

16
(1) 
17

18

19

20

21

22

23

24

25

26

27

28

29

30





From: Nicolas Cannasse <warplayer@fr...>  20041109 19:02:58

> Anybody has any idea of some lazy lists implementation in Ocaml? Well partition could be easily added to Enum Something like : val partition : ('a > bool) > 'a Enum.t > 'a Enum.t * 'a Enum.t The implementation itself is quite easy : let partition f t = let mem_true = Queue.create() in let mem_false = Queue.create() in let next b () = try Queue.pop (if b then mem_true else mem_false) with Queue.Empty > let rec loop() = let x = t.next() in if f x = b then x else begin Queue.push x (if b then mem_false else mem_true); loop(); end; in loop() in from (next true) , from (next false) But I'm not sure we should add it to Enum module because it creates a unwelcomed dependency on the Queue module. Regards, Nicolas Cannasse 
From: Martin Jambon <martin_jambon@em...>  20041109 18:50:09

On Tue, 9 Nov 2004, Koprowski, A. wrote: > Hello, > > Anybody has any idea of some lazy lists implementation in Occaml? > > Initially I thought that ExtLib's Enums will do the work but what I > don't like about them is that operations like map, filter etc. consume > the enumeration. Now, for me it's crucial to have a partition function. > So let's say I have list 'l' and I want to partition it into 'm' and > 'n'. I want everything to be computed in a lazy fashion so forcing 'l' > is out of question. Also assume that computation yielding 'l' is > expensive so cloning it and using to produce 'm' and 'n' separately > (thus computing twice) is also not on option. Can I do it somehow with > Enums? And if not: does anybody know, hopefully positive, answer to the > question posed at the beginning of this post? I just played a little, and here is the result, just for fun (you probably can find nicer implementations somewhere on the web, and I don't know what you can do with enums here): type 'a lazy_list = Cons of 'a Lazy.t * 'a lazy_list Lazy.t  Empty type 'a t = 'a lazy_list Lazy.t let rec force l = match Lazy.force l with Cons (x, rest) > Lazy.force x :: force rest  Empty > [] let to_list = force let rec of_list l = lazy (match l with [] > Empty  x :: rest > Cons (lazy x, of_list rest)) let rec map f l = lazy (match Lazy.force l with Cons (x, rest) > Cons (lazy (f (Lazy.force x)), map f rest)  Empty > Empty) let rec filter f l = let rec find_node l = match Lazy.force l with Cons (x, rest) > if f (Lazy.force x) then Cons (x, filter f rest) else find_node rest  Empty > Empty in lazy (find_node l) let partition f l = let l' = map (fun x > (x, f x)) l in let m = map fst (filter (fun (x, b) > b) l') in let n = map fst (filter (fun (x, b) > not b) l') in (m, n) # let (m,n) = partition (fun x > print_int x; x <= 4) (of_list [1;3;5;2;7]);; val m : int lazy_list Lazy.t = <lazy> val n : int lazy_list Lazy.t = <lazy> # to_list m;; 13527 : int list = [1; 3; 2] # to_list n;;  : int list = [5; 7] # to_list m;;  : int list = [1; 3; 2] Martin  Martin Jambon, PhD Researcher in Structural Bioinformatics since the 20th Century The Burnham Institute http://www.burnham.org San Diego, California 
From: Koprowski, A. <A.K<oprowski@tu...>  20041109 13:56:04

Hello, Anybody has any idea of some lazy lists implementation in Occaml?=20 Initially I thought that ExtLib's Enums will do the work but what I don't like about them is that operations like map, filter etc. consume the enumeration. Now, for me it's crucial to have a partition function. So let's say I have list 'l' and I want to partition it into 'm' and 'n'. I want everything to be computed in a lazy fashion so forcing 'l' is out of question. Also assume that computation yielding 'l' is expensive so cloning it and using to produce 'm' and 'n' separately (thus computing twice) is also not on option. Can I do it somehow with Enums? And if not: does anybody know, hopefully positive, answer to the question posed at the beginning of this post? Thanks in advance for any help, Regards, Adam Koprowski =20   A.Koprowski@..., ICQ: 3204612   The difference between impossible and possible lies in determination   Tommy Lasorda   =20 