foobarquux changed the topic of #ocaml to: www.ocaml.org
malc has quit ["no reason"]
comatoast is now known as diddling_with_garf_s_buffer
diddling_with_garf_s_buffer is now known as comatoast
pHa has quit [Read error: 104 (Connection reset by peer)]
pHa has joined #ocaml
jao has quit [Remote closed the connection]
jao has joined #ocaml
comatoat has joined #ocaml
comatoast has quit [Read error: 54 (Connection reset by peer)]
comatoat is now known as comatoast
gl has quit [Read error: 110 (Connection timed out)]
mellum has quit [Read error: 110 (Connection timed out)]
comatoast has quit ["Whoosh!"]
clog has quit [^C]
clog has joined #ocaml
teek has joined #ocaml
jao has quit [Read error: 104 (Connection reset by peer)]
jao has joined #ocaml
gl has joined #ocaml
mellum has joined #ocaml
teek has quit ["Coffee break"]
jao has quit [carter.openprojects.net irc.openprojects.net]
graydon has quit [carter.openprojects.net irc.openprojects.net]
jao has joined #ocaml
graydon has joined #ocaml
Submarine has joined #ocaml
<Submarine> hi
<Submarine> What is the program that OCaml developers use to process documentation?
<Submarine> The one that extracts comments containing [variable_name] and outputs HTML?
<gl> ocamldoc ?
malc has joined #ocaml
foobarquux has joined #ocaml
jao has quit [Read error: 113 (No route to host)]
jao has joined #ocaml
<jao> hi, what system do you recommend for building ocaml projects: OCamlMakefile, Katmake, something with autoconf...?
<Submarine> I use plain GNU Make.
<jao> do you use a standard template?
<Submarine> I have a set of rules that I copy/paste between makefiles.
<Submarine> This lacks elegance, but it has the advantage of not requiring the installation of yet another program on the build machines.
<jao> i see... OCamlMakefile is a good template written by Markus Mottl, and uses GNU make too... i was thinking of using it for the same reasons
<Submarine> BSD Make is a pain in the ass.
* jao has never used BSD make, although he runs FreeBSD
<Submarine> I'm not terribly impressed by FreeBSD.
<jao> i used to run debian, but i prefer freebsd (not terribly impressed, though :)
<Submarine> I'd appreciate progress on the CDK (Caml Development Kit).
<Submarine> It's OCaml on steroids: it ships OCaml plus the most common tools and libraries.
<Submarine> So instead of downloading and installing OCaml, lablgtk, mlgmp and the like, you install CDK.
<Submarine> Unfortunately, I could not build it last time I tried. :-)
<jao> i did not know it: where can i find more info?
<Submarine> I think it's on Fabrice le Fessant's page.
<malc> pauillac.inria.fr/cdk
<jao> looks very interesting... is it actively maintained?
<malc> last updated 11days ago
<malc> i guess Fabrice works on it on and off.. lately mostly off
<malc> but, i use cdk3.01+1 since the release, though i might upgrade due to some nasty bugs
<malc> so its mostly very decent quality collection of neatly integrated sw
<jao> then, if other people want to build a package developed using cdk they need to install the cdk?
<malc> well that depends
<malc> you can ofcourse write your build infrastructure to take advantage of cdk when its available or fallback on multiple packages plus vanila ocaml when its not
<jao> i see... so, cdk provides some kind of building apps/infrastucture? make based?
<malc> it provides cdk_config
<jao> i'll give it a try
* malc hopes jao has a lot of hdd space
<jao> how much??!!
<malc> modules$ du /net/src/cdk-3.01+1/ -s
<malc> 151117 /net/src/cdk-3.01+1
<malc> source tree only
<malc> [compiled]
<Submarine> not bad
<Submarine> Little fry compared to XFree86.
<malc> dont remind me
<malc> <shivers>
* jao has room enough :)
<jao> i was going to download cdk: do you know is v. 3.04 is expected soon?
<malc> no idea
malc has quit ["no reason"]
Tian has joined #ocaml
<Tian> hi
jao has quit [Read error: 113 (No route to host)]
<Submarine> hi
<Tian> hi
jao has joined #ocaml
<Submarine> wow
<Submarine> I did not know OCaml was so popular in Spain.
<Submarine> 5 years ago, we used to joke that OCaml was only used at INRIA and ENS/ENSL.
<Tian> Submarine: moi je suis français
<Submarine> ah ah
<Tian> Submarine: perdu ;o)
* jao is a spaniard
<Submarine> Disons que c'est marrant: il y a 5 ans, on blaguait en disant que Caml c'était un truc qui n'était utilisé qu'à l'INRIA et dans les ENS.
<Tian> jao: donde lo aprendiste ?
<Tian> Submarine: disons que ça a une bonne réputation dans le milieu linux
<jao> Tian: el que? ocaml?
<Submarine> Si, Ocaml.
<Tian> pues sí
<Submarine> Tian: Je suis scié.
<Tian> Submarine: tant que ça ?
<jao> lo estoy aprendiendo ahora; lo conoci por internet
<jao> y compre el libro de oreilly en frances
<jao> y el de cousineau/mauny
<Tian> el de cousineau/mauny está muy bueno
<Tian> mejor que el de oreilly
<jao> no te gusta el de oreilly? yo aun tengo que empezar el CM
<Submarine> El de Cousineau e Mauny es viejo.
<Tian> Es verdad pero me parece muchos mas construido
<Tian> más bien pensado
<Tian> no sé
<Tian> Y funciona bien con el ocaml
<Submarine> Describe Caml Light y no Ocaml.
<jao> pero no trae nada de modulos y oo...
<Tian> És verdad pero explica muy bien el funcional
<Submarine> Pero Xavier Leroy no es muy seguro de que hacer con el oo.
<Tian> Submarine: no es para hacer bindings ?
<jao> no le gusta?
<Submarine> El problemo es que hay los clases, los modulos y los typos recursivos.
<Tian> jao: el oo y los modulos es más facil de entender
<Submarine> Y los variantes.
<Tian> Hace de todo ;o)
<jao> si, hace de todo: pero eso es bueno, creo yo
<Tian> pero no es GPL :(
<Submarine> Making classes, modules and types more "unified" would be better.
<Submarine> I know the reason for this.
<Submarine> I mean, I think I know the reasons.
<Tian> But that's rather hard to no, right ?
<jao> Submarine: what do you mean by "more unified"?
<jao> Submarine: and what are the reasons?
<Submarine> 1/ I guess that they were sobered up by the Moscow ML thing.
<Submarine> Some people took Caml Light, stuck a SML frontend, and called this Moscow ML with little credit for INRIA.
<Submarine> Don't forget that a research group lives on recognition, and allowing people to do such things may jeopardize that recognition.
<Tian> Are you serious ?
<Submarine> 2/ I suspect that they don't want a gazillion versions of "improved Caml" that are buggy and give Caml a bad reputation.
<Submarine> I am very serious.
<Tian> But Ocaml is QPL it can't be copied ???
<Submarine> Caml Light had a more lax license.
<Tian> You mean that's because of MoscowML that they put Ocaml in QPL rathen than GPL ?
<jao> i'm not sure i'm understanding: in order to avoid copying, classes modules and types are not well integrated?
<Submarine> I was talking of the license.
<Submarine> Tian: I think so.
<jao> aah!
<Submarine> jao: No, that's because they still don't know what to do for a better type system.
<Tian> That plainly suck
<Tian> At least
<Submarine> But they'll soon add polymorphic methods.
<Submarine> That's basically adding impredicative polymorphism.
<Tian> we can say that Ocaml has a very good reputation cf ICFP, faster than C++, etc...
<jao> in what sense do "polymorphic methods" differ from plain polymorphic (virtual) ones?
<jao> ocaml already implements polymorphism, no?
<Submarine> Not on methods.
<Submarine> And not "full polymorphism".
<Submarine> Do you know the difference between polymorphism as in System F and in Caml ?
<Tian> I don't know
<jao> i'm afraid not... care to explain, please?
<Submarine> Ok. In Caml, the types are all of the form
<Submarine> forall a_1 .... forall a_n (type containing variables a_1 to a_n)
<Submarine> you may want types where the forall can be _inside_
<Submarine> this is far more powerful
<Submarine> for instance, fun f -> (f 1),(f "a") does not type in ocaml
<Submarine> still, this makes sense if f: 'a->'a
<jao> but type inference would be hard in such case...
<Submarine> It's impossible.
<Submarine> That's why it would need explicit declaration.
<jao> right. i'm under the impression that caml people do like inference very much
<Submarine> Well, explicit typing can be painful sometimes.
<Tian> That's pretty clear
<Submarine> Let's not mention Coq. :-)
<foobarquux> :/
<foobarquux> (hi all)
<jao> i come from c++ and java <shudders> and don't find explicit typing painful
<Tian> Submarine: Coq seems like a little harder when one come from imperative world
<Submarine> Coq is worse than that.
<Tian> what do you mean ?
<Submarine> Coq has a horrible user interface.
<Submarine> To do any non trivial proof in Coq, you have to understand very well how the various basic tactics work.
<Submarine> Coq proofs may not work in the next version.
<Tian> Tu veux dire que la première marche est la plus dure...
<Submarine> Coq is incapable to see trivial equivalences.
<Submarine> Je veux dire que Coq est un échec.
<Tian> ouaouh
<jao> excuse me: what is Coq?
<Submarine> A theorem prover based on higher order typed lambda calculus.
<Submarine> aka the calculus of constructions
<Submarine> extended with inductive constructions
<jao> oh, i see
<Submarine> Tian: Et je pense qu'une bonne partie de l'équipe de Coq se fout que l'outil réalisé soit utilisable effectivement.
<Tian> Non
<Tian> C'est bien des chercheurs ça ;o)
<Tian> I have a little question if sb could answer great
<Tian> Why couldn't I define an exception with the polymorphic type 'a ?
<Submarine> Well, think of it for one minute.
<Tian> cool
malc has joined #ocaml
<Submarine> How would you check that the handler that catches it expects the correct argument type?
<Submarine> It would be impossible, except by adding "thrown exceptions" to the type system.
<Tian> But you can do a pattern-matching with the sacro-saint _ so that you can ensure that all exceptions are caught
<Submarine> I don't follow you exactly.
<malc> Tian: show exactly, syntax semantics wise what you want?
<Tian> try ... with TheException data -> match data with ...
<Tian> tu vois ?
<Submarine> Well, in that case data is monomorphic.
<Submarine> Don't you see that what you suggest would either imply static exception typing either force some kind of dynamic typing?
<Tian> well as you say it
<Tian> /me is dumb
<Submarine> mmmh
<Submarine> let us suppose that you do
<Submarine> exception Foo of 'a;;
<Submarine> let f = raise Foo 5;;
<Submarine> let g = raise Foo "Tian";;
<Submarine> oops
<Submarine> rather f() and g()
<Submarine> let foobar h = try h() with Foo x -> print_int x;;
<Submarine> now please tell me how you would evaluate foobar g
<Tian> You could force a pattern matching on the x
<malc> in theory type system could have been extended to accept labeled exception, as ?moo without the default
<malc> i dont see how it would work though
<Tian> I mean let foobar h = try h() with Foo x -> match x with int -> print_int x | x with string -> print_strint x;;
<Submarine> ok, then you're adding pattern matching on types
<Submarine> which implies dynamic typing
<malc> Tian: i gues you have to wait for GCaml to mature
<Tian> Yes I did understood that's far more difficult
<Tian> to implement
<Submarine> That's very different conceptually.
<Submarine> Do you realize that Caml carries very little type information inside the runtime system?
<Submarine> That the polytypic hashes and compare functions are hacks?
<Tian> I didn't look thorougly to the sources
<Tian> Submarine: tu peux l'améliorer ;o)
<Submarine> Well, it would not be an amelioration.
<Tian> Mais bon c'est un peu logique vu que les types sont vérifiés lors de la compilation
<Submarine> Dynamic typing is very very different.
<Submarine> Inside the Caml runtime systems, you actually have very few types.
<Submarine> You have two basic types: integers and pointers.
<Submarine> Pointers can point to structured data, arrays, float arrays and custom data.
<Submarine> That's all.
<Submarine> And closures.
<Submarine> There are very few typing checks.
<Submarine> The interpreter does not distinguish between None and 0.
<Tian> C'est pour ça que Ocaml est plutôt rapide au runtime
<Submarine> If you want to do the kind of things you alluded to, you need something like Lisp.
<Tian> Grrr I don't like to speak english with French peole
<Tian> Grrr I don't like to speak english with French people
<Tian> No it was just a question
<Tian> I mean you can create a polymorphic type
<Tian> You can pass a constructor to an exception
<Tian> but not a polymorphic one
<Tian> that seems rather strange when you experiment this
<Tian> Do you see what I mean ?
<Submarine> malc: This makes the language carry typing information around, doesn't it?
* Submarine suspects such things are implemented using constructors.
<malc> Submarine: C++ templates do not carry anything around, i guess its the same with GCaml (i might be wrong)
<malc> but maybe its along the lines of what Piere Weis described a year ago or more
<Tian> malc: seems great but not really mainstream
<Submarine> malc: C++ templates are recompiled for every instance.
<Submarine> Current polymorphism with OCaml does not carry typing information.
<malc> Submarine: i know
<Submarine> But I don't see how to do proper polytypic functions without this info.
<Submarine> Currently, the runtime system has very little typing info.
<malc> Tian: well after thinking a bit about GCaml this summer i decided that it was dangerous, i.e. should be used with great care
<Submarine> Sufficient to implement marshalling, compare and hash, but...
<Tian> malc: could you detall this ?
<Submarine> Maybe I should go to JFLA.
<malc> Tian: 1 you potentially run from declaration free language, 2 plus inveitably loose the ability to see exactly what function does and on what types (this applied to compiler as well, hence number 1)
<malc> JFLA?
<Submarine> Journées Françaises des Logiciels Applicatifs
<malc> French Journal for what?
<Submarine> French Days for Applicative Programs
<Submarine> er actually it's
<malc> oh boy
<Submarine> Journées Francophones des Langages Applicatifs
<Submarine> French-speaking days of applicative languages
<Tian> malc: I see better to stay with Ocaml
<Submarine> Generic polymorphism means major changes in the compiler and/or runtime system.
<malc> Tian: i derived 'one should be careful', not 'stay away from anything new'
<Tian> malc: I think that you can do a lotta things with the bare Ocaml, so to use anything new it needs to worth it
<malc> Tian: i belive that GCaml development is well justified (if its not about adding typing to runtime system)
smklsmkl has joined #ocaml
smkl has quit [Read error: 54 (Connection reset by peer)]
smklsmkl is now known as smkl
awwaiid has joined #ocaml
Tian has quit ["A10"]
jao has quit ["leaving"]
Submarine has quit ["Client Exiting"]
jao has joined #ocaml
<jemfinch> wow, 12 people.
<jemfinch> O'Caml is becoming more popular.
<awwaiid> yah
<jemfinch> too bad we don't have anyone other than me who wants to hack on an irc bot, though :)
<awwaiid> ha. Its cool enough that you are doing it.
jao_ has joined #ocaml