From mboxrd@z Thu Jan 1 00:00:00 1970 Received: (from majordomo@localhost) by pauillac.inria.fr (8.7.6/8.7.3) id AAA13703; Thu, 25 Jul 2002 00:31:20 +0200 (MET DST) X-Authentication-Warning: pauillac.inria.fr: majordomo set sender to owner-caml-list@pauillac.inria.fr using -f Received: from concorde.inria.fr (concorde.inria.fr [192.93.2.39]) by pauillac.inria.fr (8.7.6/8.7.3) with ESMTP id AAA13704 for ; Thu, 25 Jul 2002 00:31:19 +0200 (MET DST) Received: from lists.utu.fi (lac.utu.fi [130.232.1.36]) by concorde.inria.fr (8.11.1/8.11.1) with ESMTP id g6OMVIH24581 for ; Thu, 25 Jul 2002 00:31:18 +0200 (MET DST) Received: by lists.utu.fi (Postfix, from userid 60001) id 072564B5CD; Thu, 25 Jul 2002 01:31:17 +0300 (EET DST) To: Oleg Subject: Re: [Caml-list] Rule based language [was: productivity improvement] Message-ID: <1027549877.3d3f2ab5bff5c@webmail.utu.fi> Date: Thu, 25 Jul 2002 01:31:17 +0300 (EET DST) From: sajuma@utu.fi Cc: caml-list@inria.fr MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="-MOQ10275498775dbad3572ea39d0c7f1a102d965f58b3" User-Agent: IMP/PHP IMAP webmail program 2.2.5 Sender: owner-caml-list@pauillac.inria.fr Precedence: bulk This message is in MIME format. ---MOQ10275498775dbad3572ea39d0c7f1a102d965f58b3 Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: 8bit > > > This looks pretty simple. What makes you think the program is a > > > compelling evidence of O'Caml superior productivity? > > 197 lines of code, including whitespace and commments. I > > think it is a pretty clear example of how you can write cool > > software in O'Caml in a very short time. If you had not been > > "lazy", as you said, and had tried implementing the same > > language in C++, I strongly doubt you could have written a > > more compact source. > 109 LOC in C++ counting blank lines and lines containing a single > '}'. See atttached files. > A few notes about the differences between your O'Caml program and > my C++ > program: > 1) I'm not using Yacc or Lex for parsing, because I'm not familiar > with these > tools, so ugly parsing takes up most of those 109 LOC (Parsing > things is > peripheral to my professional interests right now. I don't write > compilers) I think that the difference of parsing code illustrates the difference between imperative and functional programming: C++ code has no clear structure and it's parts do not have simple meanings. In O'Caml code, the parser is combined from smaller parts and every parser has a simple meaning. Same kind of code could be written in C++ too, but C++ doesn't support functional style good enough to make this normal. > 2) I decided not to implement the "simple" keyword, because I did > not understand what it was supposed to mean (a depth limit on > deduction, I'm guessing, but what for?) I think you misunderstood the specification of the language. (It was not very clear). The meaning of "a and b" should not be "a is reachable and b is reachable" (additive and), but "a and b are true at the same time" (multiplicative and). Of course I could be mistaken too, but the multiplicative case is more interesting. > 4) The algorithms are different I think, resulting in, for example, > about 200x speed improvement for the attached test.input file on my > P3-800MHz (g++-3.0 vs ocamlopt) (The output is identical). The O'Caml > program convergence seems to be quite unstable. Sometimes it is as > fast or even faster than the C++ program. The examples are too simple to show the difference. I have made a new example that can detect the difference, and also has a big enough search space. > I can see how the same algorithm can be implemented in ~100 LOC of > O'Caml too. However, IMO as this and the previous examples show, reports > about extreme LOC ratios are premature. The previous example shows that converting simple pattern matching to C++ makes it twice as long, unreadable, and still doesn't implement all the functionality. Anyway, problems in memory management and modularity only appear when the programs become big. Usually big programs are not written in two languages, so comparison is hard. But the example of Horus vs. Ensemble shows that there is very large improvement. Ensemble and other big O'Caml programs could probably be converted to C without making them much bigger, but they would become unreadable and unmaintainable. Here is a question: in C you can hack in all the object oriented features, so why are you using C++? Many claim that OOP in C is better than in C++, so what would you say to these people? Perhaps we could then tell you why you should use O'Caml. All I can say now is that O'Caml has been a massive productivity improvement for me. ---MOQ10275498775dbad3572ea39d0c7f1a102d965f58b3 Content-Type: application/octet-stream; name="rules.ml" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="rules.ml" Cm9wZW4gR2VubGV4CgpsZXQgcmVjIGNvbmQyID0gcGFyc2VyCiB8IFs8ICdJZGVudCAiYW5kI jsgJ0lkZW50IHg7IHhzID0gY29uZDIgPl0gLT4geDo6eHMKIHwgWzwgPl0gLT4gW10KCmxldC Bjb25kID0gcGFyc2VyIFs8ICdJZGVudCB4OyB4cyA9IGNvbmQyID5dIC0+IHg6OnhzIHwgWzw gPl0gLT4gW10KCmxldCB0b2tlbiA9IHBhcnNlciBbPCAnSWRlbnQgaSA+XSAtPiBpIHwgWzwg J0ludCBpID5dIC0+IHN0cmluZ19vZl9pbnQgaQoKbGV0IGdvYWwgPSBwYXJzZXIKIHwgWzwgJ 0lkZW50ICJzaW1wbGUiOyBnbiA9IHRva2VuOyAnSWRlbnQgImlzIjsgbCA9IGNvbmQ7ICdLd2 QgIjsiID5dIC0+CiAgICh0cnVlLGduLGwpCiB8IFs8IGduID0gdG9rZW47ICdJZGVudCAiaXM iOyBsID0gY29uZDsgJ0t3ZCAiOyIgPl0gLT4gKGZhbHNlLGduLGwpCgpsZXQgcmVjIGdvYWxz ID0gcGFyc2VyCiB8IFs8IGcgPSBnb2FsOyBncyA9IGdvYWxzID5dIC0+IGc6OmdzCiB8IFs8I F8gPSBTdHJlYW0uZW1wdHkgPl0gLT4gW10KCmxldCByZWMgZGF0YXNldCA9IHBhcnNlcgogfC BbPCAnSWRlbnQgImdvYWxzIjsgJ0t3ZCAiOiIgPl0gLT4gW10KIHwgWzwgJ0lkZW50IGQ7ICd Ld2QgIjsiOyBkcyA9IGRhdGFzZXQgPl0gLT4gZDo6ZHMKCmxldCBydWxlID0gcGFyc2VyCiB8 IFs8IHJuID0gdG9rZW47ICdJZGVudCAiaXMiOyBwcmU9Y29uZDsgJ0t3ZCAiPT4iOyBwb3N0P WNvbmQ7ICdLd2QgIjsiID5dIC0+CiAgIChybixwcmUscG9zdCkKCmxldCByZWMgcnVsZXMgPS BwYXJzZXIKIHwgWzwgJ0lkZW50ICJkYXRhc2V0IjsgJ0t3ZCAiOiIgPl0gLT4gW10KIHwgWzw gciA9IHJ1bGU7IHJzID0gcnVsZXMgPl0gLT4gcjo6cnMKCmxldCBydWxlc2V0ID0gcGFyc2Vy IFs8ICdJZGVudCAicnVsZXNldCI7ICdLd2QgIjoiOyBsc3QgPSBydWxlcyA+XSAtPiBsc3QKC mxldCBwcm9ncmFtID0gcGFyc2VyCiB8IFs8IHJzID0gcnVsZXNldDsgZHMgPSBkYXRhc2V0Oy BncyA9IGdvYWxzID5dIC0+IChycywgZHMsIGdzKQoKdHlwZSBydWxlID0geyBuYW1lIDogc3R yaW5nOyBkbGlzdCA6IGludCBhcnJheTsgYWxpc3QgOiBpbnQgYXJyYXkgfQoKbGV0IHNldF9i aXQgeCBpID0gaSBsb3IgKDEgbHNsIHgpCgpsZXQgYWRkX2xpc3QgbGlzdCB4ID0gbGlzdC4oe CAvIDMxKSA8LSBzZXRfYml0ICh4IG1vZCAzMSkgbGlzdC4oeCAvIDMxKQoKbGV0IGFkZCB4IH kgPSBBcnJheS5tYXBpIChmdW4gaSB4IC0+IHggbG9yIHkuKGkpKSB4CmxldCBtaW51cyB4IHk gPSBBcnJheS5tYXBpIChmdW4gaSB4IC0+IHggbGFuZCAobG5vdCB5LihpKSkpIHgKCmxldCBp bmNsdWRlcyB4IHkgPQogIGxldCByZXMgPSByZWYgdHJ1ZSBpbgogIGZvciBpID0gMCB0byBBc nJheS5sZW5ndGggeCAtIDEgZG8KICAgIGlmIChsbm90IHguKGkpKSBsYW5kIHkuKGkpIDw+ID AgdGhlbiByZXMgOj0gZmFsc2UKICBkb25lOwogICFyZXMKCmxldCBzdGF0ZXMgPSBIYXNodGJ sLmNyZWF0ZSAxMDAwCgpsZXQgYXBwbHlfcnVsZSBzdGF0ZSB7ZGxpc3Q9ZGxpc3Q7YWxpc3Q9 YWxpc3R9ID0KICBpZiBpbmNsdWRlcyBzdGF0ZSBkbGlzdCB0aGVuIFNvbWUgKGFkZCAobWlud XMgc3RhdGUgZGxpc3QpIGFsaXN0KSBlbHNlIE5vbmUKCmxldCByZWMgc2VhcmNoIGdvYWwgc3 RhdGUgcnVsZXMgPQogIGlmIGluY2x1ZGVzIHN0YXRlIGdvYWwgdGhlbiBTb21lIFtdIGVsc2U KICBpZiBIYXNodGJsLm1lbSBzdGF0ZXMgc3RhdGUgdGhlbiBOb25lIGVsc2UKICBsZXQgXyA9 IEhhc2h0YmwuYWRkIHN0YXRlcyBzdGF0ZSAoKSBpbgogIGxldCByZWMgdHJ5X3J1bGVzID0gZ nVuY3Rpb24KICAgfCBbXSAtPiBOb25lCiAgIHwgcjo6cnMgd2hlbiBpbmNsdWRlcyBzdGF0ZS ByLmRsaXN0IC0+CiAgICAgKCBtYXRjaCBzZWFyY2ggZ29hbCAoYWRkIChtaW51cyBzdGF0ZSB yLmRsaXN0KSByLmFsaXN0KSBydWxlcyB3aXRoCiAgICAgfCBOb25lIC0+IHRyeV9ydWxlcyBy cwogICAgIHwgU29tZSBwIC0+IFNvbWUgKHIubmFtZTo6cCkgKQogICB8IF86OnJzIC0+IHRye V9ydWxlcyBycyBpbgogIHRyeV9ydWxlcyBydWxlcwoKbGV0IHJlYyBzaW1wbGUgc3RhdGUgcn VsZXMgPQogIGxldCAoY2hhbmdlZCxzdGF0ZSkgPSBMaXN0LmZvbGRfbGVmdCAoZnVuIChjaCx zdGF0ZSkgciAtPgogICAgbWF0Y2ggYXBwbHlfcnVsZSBzdGF0ZSByIHdpdGgKICAgICB8IE5v bmUgLT4gKGNoLHN0YXRlKQogICAgIHwgU29tZSBuc3RhdGUgLT4gKHRydWUsbnN0YXRlKSkgK GZhbHNlLHN0YXRlKSBydWxlcyBpbgogIGlmIGNoYW5nZWQgdGhlbiBzaW1wbGUgc3RhdGUgcn VsZXMgZWxzZSBzdGF0ZQoKbGV0IHRlc3Rfc2ltcGxlIHN0YXRlIGdvYWwgcnVsZXMgPQogIGl mIGluY2x1ZGVzIChzaW1wbGUgc3RhdGUgcnVsZXMpIGdvYWwgdGhlbiAiZm91bmQiIGVsc2Ug Im5vdCBmb3VuZCIKCmxldCB0ZXN0X25vcm1hbCBzdGF0ZSBnb2FsIHJ1bGVzID0KICBIYXNod GJsLmNsZWFyIHN0YXRlczsKICBtYXRjaCBzZWFyY2ggZ29hbCBzdGF0ZSBydWxlcyB3aXRoCi AgfCBOb25lIC0+ICJub3QgZm91bmQiCiAgfCBTb21lIHBsYW4gLT4gU3RyaW5nLmNvbmNhdCA iOyAiIHBsYW4KCmxldCB0YWJsZSA9IEhhc2h0YmwuY3JlYXRlIDEwMCBhbmQgdW5pcSA9IHJl ZiAwCgpsZXQgbmV3X2lkIG5hbWUgPQogIGlmIG5vdCAoSGFzaHRibC5tZW0gdGFibGUgbmFtZ SkgdGhlbiAoSGFzaHRibC5hZGQgdGFibGUgbmFtZSAhdW5pcTsgaW5jciB1bmlxKQoKbGV0IG 1ha2VfbGlzdCBuYW1lcyA9CiAgbGV0IGFyciA9IEFycmF5Lm1ha2UgKCF1bmlxLzMxICsgMSk gMCBpbgogIExpc3QuaXRlciAoZnVuIG4gLT4gYWRkX2xpc3QgYXJyIChIYXNodGJsLmZpbmQg dGFibGUgbikpIG5hbWVzOyBhcnIKCmxldCBjb21waWxlIHJzIHN0YXRlID0KICBMaXN0Lml0Z XIgKGZ1biAoXyxhLGIpIC0+IExpc3QuaXRlciBuZXdfaWQgKGFAYikpIHJzOyBMaXN0Lml0ZX IgbmV3X2lkIHN0YXRlOwogIExpc3QubWFwIChmdW4gKG4sYSxiKSAtPiB7bmFtZT1uOyBkbGl zdD1tYWtlX2xpc3QgYTsgYWxpc3Q9bWFrZV9saXN0IGJ9KSBycywKICBtYWtlX2xpc3Qgc3Rh dGUKCmxldCBfID0KICBsZXQgc3QgPSBTdHJlYW0ub2ZfY2hhbm5lbCBzdGRpbiBpbgogIGxld CAocnMsZHMsZ29hbHMpID0gcHJvZ3JhbSAobWFrZV9sZXhlciBbIjsiOyAiOiI7ICI9PiJdIH N0KSBpbgogIGxldCBydWxlcywgc3RhdGUgPSBjb21waWxlIHJzIGRzIGluCiAgbGV0IHRlc3R fZ29hbCAocyxnbixnKSA9CiAgICBsZXQgZ29hbCA9IG1ha2VfbGlzdCBnIGluCiAgICBwcmlu dF9zdHJpbmcgKCJHb2FsICIgXiBnbiBeICI6ICIgXgogICAgICAoaWYgcyB0aGVuIHRlc3Rfc 2ltcGxlIHN0YXRlIGdvYWwgcnVsZXMKICAgICAgIGVsc2UgdGVzdF9ub3JtYWwgc3RhdGUgZ2 9hbCBydWxlcykgXiAiXG4iKSBpbgogIExpc3QuaXRlciB0ZXN0X2dvYWwgZ29hbHMKCg== ---MOQ10275498775dbad3572ea39d0c7f1a102d965f58b3 Content-Type: application/octet-stream; name="pigeons.prog" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="pigeons.prog" cnVsZXNldDoKCnRvXzFfMSBpcyBwXzEgYW5kIGhfMSA9PiBpXzFfMTsKZnJvbV8xXzEgaXMgaV8x XzEgPT4gcF8xIGFuZCBoXzE7CnRvXzFfMiBpcyBwXzEgYW5kIGhfMiA9PiBpXzFfMjsKZnJvbV8x XzIgaXMgaV8xXzIgPT4gcF8xIGFuZCBoXzI7CnRvXzFfMyBpcyBwXzEgYW5kIGhfMyA9PiBpXzFf MzsKZnJvbV8xXzMgaXMgaV8xXzMgPT4gcF8xIGFuZCBoXzM7CnRvXzFfNCBpcyBwXzEgYW5kIGhf NCA9PiBpXzFfNDsKZnJvbV8xXzQgaXMgaV8xXzQgPT4gcF8xIGFuZCBoXzQ7CnRvXzFfNSBpcyBw XzEgYW5kIGhfNSA9PiBpXzFfNTsKZnJvbV8xXzUgaXMgaV8xXzUgPT4gcF8xIGFuZCBoXzU7CnRv XzFfNiBpcyBwXzEgYW5kIGhfNiA9PiBpXzFfNjsKZnJvbV8xXzYgaXMgaV8xXzYgPT4gcF8xIGFu ZCBoXzY7CnRvXzFfNyBpcyBwXzEgYW5kIGhfNyA9PiBpXzFfNzsKZnJvbV8xXzcgaXMgaV8xXzcg PT4gcF8xIGFuZCBoXzc7Cgp0b18yXzEgaXMgcF8yIGFuZCBoXzEgPT4gaV8yXzE7CmZyb21fMl8x IGlzIGlfMl8xID0+IHBfMiBhbmQgaF8xOwp0b18yXzIgaXMgcF8yIGFuZCBoXzIgPT4gaV8yXzI7 CmZyb21fMl8yIGlzIGlfMl8yID0+IHBfMiBhbmQgaF8yOwp0b18yXzMgaXMgcF8yIGFuZCBoXzMg PT4gaV8yXzM7CmZyb21fMl8zIGlzIGlfMl8zID0+IHBfMiBhbmQgaF8zOwp0b18yXzQgaXMgcF8y IGFuZCBoXzQgPT4gaV8yXzQ7CmZyb21fMl80IGlzIGlfMl80ID0+IHBfMiBhbmQgaF80Owp0b18y XzUgaXMgcF8yIGFuZCBoXzUgPT4gaV8yXzU7CmZyb21fMl81IGlzIGlfMl81ID0+IHBfMiBhbmQg aF81Owp0b18yXzYgaXMgcF8yIGFuZCBoXzYgPT4gaV8yXzY7CmZyb21fMl82IGlzIGlfMl82ID0+ IHBfMiBhbmQgaF82Owp0b18yXzcgaXMgcF8yIGFuZCBoXzcgPT4gaV8yXzc7CmZyb21fMl83IGlz IGlfMl83ID0+IHBfMiBhbmQgaF83OwoKdG9fM18xIGlzIHBfMyBhbmQgaF8xID0+IGlfM18xOwpm cm9tXzNfMSBpcyBpXzNfMSA9PiBwXzMgYW5kIGhfMTsKdG9fM18yIGlzIHBfMyBhbmQgaF8yID0+ IGlfM18yOwpmcm9tXzNfMiBpcyBpXzNfMiA9PiBwXzMgYW5kIGhfMjsKdG9fM18zIGlzIHBfMyBh bmQgaF8zID0+IGlfM18zOwpmcm9tXzNfMyBpcyBpXzNfMyA9PiBwXzMgYW5kIGhfMzsKdG9fM180 IGlzIHBfMyBhbmQgaF80ID0+IGlfM180Owpmcm9tXzNfNCBpcyBpXzNfNCA9PiBwXzMgYW5kIGhf NDsKdG9fM181IGlzIHBfMyBhbmQgaF81ID0+IGlfM181Owpmcm9tXzNfNSBpcyBpXzNfNSA9PiBw XzMgYW5kIGhfNTsKdG9fM182IGlzIHBfMyBhbmQgaF82ID0+IGlfM182Owpmcm9tXzNfNiBpcyBp XzNfNiA9PiBwXzMgYW5kIGhfNjsKdG9fM183IGlzIHBfMyBhbmQgaF83ID0+IGlfM183Owpmcm9t XzNfNyBpcyBpXzNfNyA9PiBwXzMgYW5kIGhfNzsKCnRvXzRfMSBpcyBwXzQgYW5kIGhfMSA9PiBp XzRfMTsKZnJvbV80XzEgaXMgaV80XzEgPT4gcF80IGFuZCBoXzE7CnRvXzRfMiBpcyBwXzQgYW5k IGhfMiA9PiBpXzRfMjsKZnJvbV80XzIgaXMgaV80XzIgPT4gcF80IGFuZCBoXzI7CnRvXzRfMyBp cyBwXzQgYW5kIGhfMyA9PiBpXzRfMzsKZnJvbV80XzMgaXMgaV80XzMgPT4gcF80IGFuZCBoXzM7 CnRvXzRfNCBpcyBwXzQgYW5kIGhfNCA9PiBpXzRfNDsKZnJvbV80XzQgaXMgaV80XzQgPT4gcF80 IGFuZCBoXzQ7CnRvXzRfNSBpcyBwXzQgYW5kIGhfNSA9PiBpXzRfNTsKZnJvbV80XzUgaXMgaV80 XzUgPT4gcF80IGFuZCBoXzU7CnRvXzRfNiBpcyBwXzQgYW5kIGhfNiA9PiBpXzRfNjsKZnJvbV80 XzYgaXMgaV80XzYgPT4gcF80IGFuZCBoXzY7CnRvXzRfNyBpcyBwXzQgYW5kIGhfNyA9PiBpXzRf NzsKZnJvbV80XzcgaXMgaV80XzcgPT4gcF80IGFuZCBoXzc7Cgp0b181XzEgaXMgcF81IGFuZCBo XzEgPT4gaV81XzE7CmZyb21fNV8xIGlzIGlfNV8xID0+IHBfNSBhbmQgaF8xOwp0b181XzIgaXMg cF81IGFuZCBoXzIgPT4gaV81XzI7CmZyb21fNV8yIGlzIGlfNV8yID0+IHBfNSBhbmQgaF8yOwp0 b181XzMgaXMgcF81IGFuZCBoXzMgPT4gaV81XzM7CmZyb21fNV8zIGlzIGlfNV8zID0+IHBfNSBh bmQgaF8zOwp0b181XzQgaXMgcF81IGFuZCBoXzQgPT4gaV81XzQ7CmZyb21fNV80IGlzIGlfNV80 ID0+IHBfNSBhbmQgaF80Owp0b181XzUgaXMgcF81IGFuZCBoXzUgPT4gaV81XzU7CmZyb21fNV81 IGlzIGlfNV81ID0+IHBfNSBhbmQgaF81Owp0b181XzYgaXMgcF81IGFuZCBoXzYgPT4gaV81XzY7 CmZyb21fNV82IGlzIGlfNV82ID0+IHBfNSBhbmQgaF82Owp0b181XzcgaXMgcF81IGFuZCBoXzcg PT4gaV81Xzc7CmZyb21fNV83IGlzIGlfNV83ID0+IHBfNSBhbmQgaF83OwoKdG9fNl8xIGlzIHBf NiBhbmQgaF8xID0+IGlfNl8xOwpmcm9tXzZfMSBpcyBpXzZfMSA9PiBwXzYgYW5kIGhfMTsKdG9f Nl8yIGlzIHBfNiBhbmQgaF8yID0+IGlfNl8yOwpmcm9tXzZfMiBpcyBpXzZfMiA9PiBwXzYgYW5k IGhfMjsKdG9fNl8zIGlzIHBfNiBhbmQgaF8zID0+IGlfNl8zOwpmcm9tXzZfMyBpcyBpXzZfMyA9 PiBwXzYgYW5kIGhfMzsKdG9fNl80IGlzIHBfNiBhbmQgaF80ID0+IGlfNl80Owpmcm9tXzZfNCBp cyBpXzZfNCA9PiBwXzYgYW5kIGhfNDsKdG9fNl81IGlzIHBfNiBhbmQgaF81ID0+IGlfNl81Owpm cm9tXzZfNSBpcyBpXzZfNSA9PiBwXzYgYW5kIGhfNTsKdG9fNl82IGlzIHBfNiBhbmQgaF82ID0+ IGlfNl82Owpmcm9tXzZfNiBpcyBpXzZfNiA9PiBwXzYgYW5kIGhfNjsKdG9fNl83IGlzIHBfNiBh bmQgaF83ID0+IGlfNl83Owpmcm9tXzZfNyBpcyBpXzZfNyA9PiBwXzYgYW5kIGhfNzsKCnRvXzdf MSBpcyBwXzcgYW5kIGhfMSA9PiBpXzdfMTsKZnJvbV83XzEgaXMgaV83XzEgPT4gcF83IGFuZCBo XzE7CnRvXzdfMiBpcyBwXzcgYW5kIGhfMiA9PiBpXzdfMjsKZnJvbV83XzIgaXMgaV83XzIgPT4g cF83IGFuZCBoXzI7CnRvXzdfMyBpcyBwXzcgYW5kIGhfMyA9PiBpXzdfMzsKZnJvbV83XzMgaXMg aV83XzMgPT4gcF83IGFuZCBoXzM7CnRvXzdfNCBpcyBwXzcgYW5kIGhfNCA9PiBpXzdfNDsKZnJv bV83XzQgaXMgaV83XzQgPT4gcF83IGFuZCBoXzQ7CnRvXzdfNSBpcyBwXzcgYW5kIGhfNSA9PiBp XzdfNTsKZnJvbV83XzUgaXMgaV83XzUgPT4gcF83IGFuZCBoXzU7CnRvXzdfNiBpcyBwXzcgYW5k IGhfNiA9PiBpXzdfNjsKZnJvbV83XzYgaXMgaV83XzYgPT4gcF83IGFuZCBoXzY7CnRvXzdfNyBp cyBwXzcgYW5kIGhfNyA9PiBpXzdfNzsKZnJvbV83XzcgaXMgaV83XzcgPT4gcF83IGFuZCBoXzc7 CgpkYXRhc2V0OgoKcF8wOwpwXzE7CnBfMjsKcF8zOwpwXzQ7CnBfNTsKcF82OwpwXzc7CmhfMDsK aF8xOwpoXzI7CmhfMzsKaF80OwpoXzU7CmhfNjsKaF83OwoKZ29hbHM6Cgp4IGlzIGlfMV8xIGFu ZCBpXzJfMiBhbmQgaV8zXzMgYW5kIGlfNF80IGFuZCBpXzVfNSBhbmQgaV82XzYgYW5kIGlfN183 Owp5IGlzIGlfMV8xIGFuZCBpXzJfMiBhbmQgaV8zXzMgYW5kIGlfNF80IGFuZCBpXzVfNSBhbmQg aV82XzYgYW5kIGlfN182Owp6IGlzIGlfMV8xIGFuZCBpXzFfMiBhbmQgaV8zXzMgYW5kIGlfNF80 IGFuZCBpXzVfNSBhbmQgaV82XzYgYW5kIGlfN183OwoK ---MOQ10275498775dbad3572ea39d0c7f1a102d965f58b3-- ------------------- 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