flux changed the topic of #ocaml to: Discussions about the OCaml programming language | http://caml.inria.fr/ | Grab OCaml 3.10.2 from http://caml.inria.fr/ocaml/release.html (featuring new camlp4 and more!)
jeddhaberstro has joined #ocaml
comglz has quit ["Lost terminal"]
rstites has joined #ocaml
<Jedai> Well it's late but :
<Jedai> f (a:_) | pred1 a = ...
<Jedai> f (a:b:_) | pred2 b = ...
<Jedai> f (0::li) = thing
<Jedai> f li | pred3 li = thing
<Jedai> where thing = ...
<Jedai> That's more or less how we would do it in Haskell, or we could use a "case ... of" to avoid repeating the name of the function
<Myoma> you can't use where like that
<Myoma> it only scopes over a single clause/equation
<Jedai> Myoma: Nope
<Jedai> Myoma: Ah wait, you may be right
<Myoma> I am right.
<Jedai> Myoma: I was thinking of the case where you have multiple guards
<Jedai> then I guess either the common part is interesting enough that you would make it a top-level function, or you could use case ... of, or you could just use another guard
<thelema> jeddhaberstro: let f = function a::_ where pred1 a -> ... | (a::b::_) where pred2 b -> ... | 0::li -> thing | li where pred3 li -> thing2
<thelema> err, meant for you Jedai
<Jedai> f xs | not null xs && head xs == 0 || pred3 xs = ...
<Jedai> thelema: ?? (you meant when and not where here, no ?)
<thelema> Jedai very likely.
<Jedai> thelema: And what did you want to ask ?
<thelema> I don't use guards much.
hsuh has joined #ocaml
hsuh has left #ocaml []
<thelema> not ask. I was suggesting how to do what you wanted in ocaml
<bluestorm> thelema: this is actually an attempt to translate an original OCaml code skeleton
<bluestorm> Jedai: notice that my last OCaml pattern is actually slightly more complicated because (0::li | li) are subject to the same guard
<Jedai> bluestorm: Really ? That seems a little bit confusing.
<bluestorm> hm
<bluestorm> it's actually quite useful
<bluestorm> eg.
<Myoma> there is a good example of this on the pattern matching page of rosettacode
<bluestorm> let rec simplify_mult = function (e, g) | (g, e) when is_identity e -> g | (a, b) -> (a, b)
<bluestorm> hmm
<bluestorm> typing won't accept that
Associat0r has quit []
<bluestorm> but you get the idea
<Jedai> bluestorm: I get the idea anyway
Associat0r has joined #ocaml
<Jedai> That's nice sugar I guess, the example doesn't seem very convincing to me (I would just use an || there) but it might make for pretty code
<Myoma> compare the haskell and ocaml code on the site I mentioned
<bluestorm> hm
<bluestorm> it is actually possible to factorize the OCaml a little more
<bluestorm> (i mean the patterns)
<bluestorm> but at some point it hurts readability if generously spaced
<bluestorm> +not
bohanlon has quit ["leaving"]
<Jedai> bluestorm: Yes, the capacity to factorize the pattern is pretty nice by itself I think (the guards applying to the whole factorization seems a little bit to clever for my taste)
<bluestorm> Jedai: and it sometime get annoying when you want to apply different guards to the factorized patterns (you can't because guards are "toplevel" construct at the pattern level)
<Jedai> bluestorm: note by contrast that the capacity to have multiple guards for one pattern is nice in the insert function in Haskell
<bluestorm> well
<bluestorm> i wrote a pa_cond extension
<bluestorm> cond x < y -> ... | x > y -> ...
<bluestorm> and as flux noticed
<bluestorm> you can get that with
<bluestorm> match () with x < y -> ... | x > y -> ...
<bluestorm> not exactly beautiful though
<bluestorm> hm
<bluestorm> | () when x > y -> ... for the last clause
<bluestorm> hm
<Myoma> You can't have multiple guards in ocaml?
<bluestorm> match () with () when x < y -> ... | () when x > y -> ...
<bluestorm> Myoma: "multiple" ?
<Jedai> Myoma: Not on the same pattern (unless I'm mistaken)
<Myoma> bluestorm: I've seen haskell code does this too, case () of () | foo -> ...
<Jedai> or case () of _ | ... -> ...
<Myoma> what would the ocaml version of this be?: foo x | p x = a | q x = b
<Jedai> Myoma: an if else if
<bluestorm> let foo x = if p x then a else if q x then b
<bluestorm> let foo x = match () with () when p x -> a | () when q x -> b
<Myoma> can you do it in the pattern
<bluestorm> let foo x = cond p x -> a | q x -> b (with the pa_cond extension)
<bluestorm> hum
<Myoma> so you must translate: foo x | p x = a ; foo x | q x = b
<bluestorm> let foo = function x when p x -> a | x when q x -> b
<Myoma> i.e. the pattern must be written twice?
<bluestorm> hm
<bluestorm> wich pattern are you talking about, "x" ?
<Myoma> yes
<bluestorm> in the first three versions it wasn't
<bluestorm> the function one does
<bluestorm> but it also has the nice side effect that you can play on naming
<bluestorm> eg.
<bluestorm> let abs = function neg when neg < 0 -> - neg | pos -> pos
CoryDambach has joined #ocaml
<bluestorm> (hm this one use one guard only so not so great)
CoryDambach has quit [Client Quit]
<bluestorm> there is also a syntax extension that adds a quite nice "with" construct : http://code.google.com/p/ocaml-patterns/wiki/PatternGuards
<bluestorm> but i haven't seen it used so far, and the extension inself is still evolving
bohanlon has joined #ocaml
<bluestorm> hm Myoma
<bluestorm> « The scoping rules for E's if and || allow balance in this example to reuse the same output expression; this is unusual among pattern-matching systems. »
<bluestorm> this comment is quite fun given that OCaml do exactly the same thing
<bluestorm> « In E, a pattern can be used almost anywhere a variable name can. »
<bluestorm> well
<bluestorm> Jedai: i was disappointed when i discovered that Haskell can't mix two function declarations at the same time
<bluestorm> (i mean you can separate the patterns by repeating the function name, but they actually have to stay together)
<bluestorm> if you could do that, that would allow an expressive way to write some intricate mutually recursive functions
<Jedai> bluestorm: It seems dangerous, because then you wouldn't be able anymore to be sure you spotted all the case for a function definition
<bluestorm> well
<bluestorm> Haskell doesn't check that anyway
<bluestorm> does it ?
<bluestorm> ah you mean visually
<bluestorm> well if you have two mutually recursive functions, it can actually be easier to check them with interleaved patterns
<Jedai> bluestorm: Yes (You can ask GHC to check you have all the possible patterns)
<Jedai> bluestorm: Yeah, but that require some complicated rule or too much freedom
<bluestorm> hm
<bluestorm> that would be expected from the current "quite independent patterns" syntax
<bluestorm> (and actually, my never-released proof-of-concept camlp4 extension mimicking the Haskell syntax was able to do that, and it was fun)
<bluestorm> i'm not sure how that freedom would hurt actually
<Jedai> -fwarn-incomplete-patterns
<bluestorm> if you keep the "grouped" style
<bluestorm> all you don't know anymore is if all the patterns in the file are at this place
<bluestorm> but you have a "least patternity bound", same as before
<Jedai> bluestorm: Well sure, but it won't add much (only some mutually recursive functions) and you would add uncertainty to the human parsing of the source
<bluestorm> hm
<bluestorm> you would still check locally that a group of declaration are exhaustive
<bluestorm> if they were not, you'd think "Let's look at the rest of the file : if they're not i'm in troubles"
<bluestorm> were you thought before "i'm in trouble"
<bluestorm> that's not that much worse
<bluestorm> -l
<Jedai> bluestorm: The convention would probably stay the same, but right now, that means the compiler will catch when you try to define two things with the same name (in a long unfamiliar file it can happen) whereas with your proposition it won't see it (it will probably see overlapping patterns though)
bluestorm has quit [zelazny.freenode.net irc.freenode.net]
pango_ has quit [zelazny.freenode.net irc.freenode.net]
jlouis has quit [zelazny.freenode.net irc.freenode.net]
r0bby has quit [zelazny.freenode.net irc.freenode.net]
acatout has quit [zelazny.freenode.net irc.freenode.net]
huangjs has quit [zelazny.freenode.net irc.freenode.net]
thelema has quit [zelazny.freenode.net irc.freenode.net]
tsuyoshi has quit [zelazny.freenode.net irc.freenode.net]
authentic has quit [zelazny.freenode.net irc.freenode.net]
tsuyoshi_ has joined #ocaml
huangjs has joined #ocaml
bluestorm has joined #ocaml
thelema has joined #ocaml
authentic has joined #ocaml
jlouis has joined #ocaml
<bluestorm> that was evil.
<bluestorm> Jedai: name conflict, agreed.
<bluestorm> hm
pango_ has joined #ocaml
<bluestorm> Jedai: i suppose the pattern checker inside GHC is rather naïve ?
<bluestorm> iirc you have a sophisticated tool
<bluestorm> (by Mitchell or someone like that)
<bluestorm> hm
<bluestorm> Catch ?
<Jedai> Yes
<bluestorm> is it possible to explicitely disable the warning for a specific pattern ?
<Jedai> But I think Catch is actually better than just a "pattern checker", I think it can determine if a function won't ever see certain case and so it's okay to not handle this pattern
<bluestorm> hmm
<Jedai> For local or not exported functions (but I'm not sure about that)
r0bby has joined #ocaml
<Myoma> the author has said catch is the start of an automated theorem prover for haskell
<bluestorm> i suppose you can't check all cases of this
<Jedai> Myoma: That seems to confirm what I just said
r0bby has quit [Client Quit]
<Myoma> Jedai: but at the moment all it is is the start of,
<bluestorm> Myoma: he's working on supercompilation and what not
<Myoma> i.e. it only cares about patterns at the moment
<bluestorm> so that makes sense
acatout has joined #ocaml
r0bby has joined #ocaml
<Jedai> Myoma: You can check all uses of a local/not exported function, so you can determine what cases it needs to handle (and then you're pessimistic on everything else because you can't control their input)
<bluestorm> i think that even statically (without relying on unknown input) you could encode proofs on integers as a pattern exhaustiveness problem
<bluestorm> hm
<Myoma> oh yes
<Myoma> pattern matching and recursion
bluestorm has quit [Remote closed the connection]
Associat0r has quit []
Jeff_123 has joined #ocaml
Jeff_123 has quit []
seafood has joined #ocaml
<jeddhaberstro> What's the difference between the guarded pattern with "with" and a guarded pattern with "when"?
<thelema> jeddhaberstro: one is a syntax error
<jeddhaberstro> heh
<jeddhaberstro> so, only when can be used
coucou747 has quit ["bye ca veut dire tchao en anglais"]
seafood_ has joined #ocaml
seafood has quit [Read error: 110 (Connection timed out)]
<Jedai> jeddhaberstro: with is an extension (camlp4)
<jeddhaberstro> oh, ok
Associat0r has joined #ocaml
seafood has joined #ocaml
netx has quit [Read error: 110 (Connection timed out)]
seafood_ has quit [Read error: 110 (Connection timed out)]
seafood has quit []
netx has joined #ocaml
code17 has joined #ocaml
code17 has quit [Remote closed the connection]
code17 has joined #ocaml
l_a_m has joined #ocaml
ygrek has joined #ocaml
jeddhaberstro has quit []
code17 has quit ["Leaving."]
code17 has joined #ocaml
Asmadeus has joined #ocaml
bluestorm has joined #ocaml
Snark has joined #ocaml
fremo has quit [Remote closed the connection]
Yoric[DT] has joined #ocaml
fremo has joined #ocaml
mishok13 has joined #ocaml
hkBst has joined #ocaml
seafood has joined #ocaml
seafood has quit []
Demitar has joined #ocaml
ChristopheT has joined #ocaml
ChristopheT has left #ocaml []
arquebus has joined #ocaml
arquebus has left #ocaml []
palomer has quit [Remote closed the connection]
code17 has quit [Remote closed the connection]
code17 has joined #ocaml
rby has joined #ocaml
mgodshall has quit ["leaving"]
seafood has joined #ocaml
Camarade_Tux_ has joined #ocaml
Camarade_Tux has quit [Read error: 110 (Connection timed out)]
vbmithr_ has joined #ocaml
vbmithr_ has quit [Client Quit]
Camarade_Tux_ is now known as Camarade_Tux
asmanur has joined #ocaml
Demitar has quit [Read error: 110 (Connection timed out)]
Demitar has joined #ocaml
Ched- has joined #ocaml
gildor has joined #ocaml
Demitar has quit [Read error: 110 (Connection timed out)]
toxygen has quit [Remote closed the connection]
Associat0r has quit []
toxygen has joined #ocaml
guillem_ has joined #ocaml
ygrek has quit [Remote closed the connection]
<Yoric[DT]> And now, back to testing my parser combinator library.
<Smerdyakov> And now, back to boiling babies.
petchema has joined #ocaml
<Yoric[DT]> Oh, yeah, that, too.
seafood has quit []
coucou747 has joined #ocaml
<Myoma> huh?
<flux> what advantages are there in using a parser combinator versus a parser generator?
<flux> I suppose there's lower barrier of starting to use (say, if you want to parse a date or some other small thing) when you don't have to use a separate file to describe the syntax
<flux> but then again, aren't parser generators capable, atleast in theory, providing better feedback than a library?
<Yoric[DT]> In my experience, parser combinators tend to provide better feedback.
<Yoric[DT]> But in that case, that was just for the pleasure of writing a library which made use of my lazy lists.
<bluestorm> :p
<bluestorm> iirc the Arrow movement was created by parser combinator implementors that encountered efficiency issues with the monadic approach
<Yoric[DT]> At least, that's what the papers on arrow seem to indicate.
Jeff_123 has joined #ocaml
marmotine has joined #ocaml
<Jeff_123> hi!
Jeff_123 has quit []
cyrax_ has joined #ocaml
mishok13 has quit [Read error: 110 (Connection timed out)]
petchema has quit [Remote closed the connection]
petchema has joined #ocaml
pango_ has quit [Remote closed the connection]
coucou747 has quit ["bye ca veut dire tchao en anglais"]
jonafan has quit [Read error: 113 (No route to host)]
bluestorm has quit [Remote closed the connection]
pango_ has joined #ocaml
Demitar has joined #ocaml
hnr has quit [Read error: 110 (Connection timed out)]
besiria has joined #ocaml
Jeff_123 has joined #ocaml
hnr has joined #ocaml
jlouis has quit ["Leaving"]
jlouis has joined #ocaml
jlouis has quit [Read error: 104 (Connection reset by peer)]
jlouis has joined #ocaml
wlmttobks has joined #ocaml
jderque has joined #ocaml
Mr_Awesome has quit ["aunt jemima is the devil!"]
jeddhaberstro has joined #ocaml
rhar has joined #ocaml
mfp has quit [Read error: 110 (Connection timed out)]
mfp has joined #ocaml
Jeff_123 has quit []
bluestorm has joined #ocaml
rhar has quit [Remote closed the connection]
rhar has joined #ocaml
<cyrax_> hello everyone,is there a specific channel for ocsigen(web server)?
Kopophex has joined #ocaml
<bluestorm> there isn't
<cyrax_> ah too bad,thank you
<bluestorm> and i'm not sure ocsigen developpers are active here
<bluestorm> you should try the mailing-list
<Smerdyakov> cyrax_, don't bother, you will be using Laconic/Web soon. ;) http://laconic.sf.net/
<cyrax_> i am on it already
<cyrax_> mm..checking
<cyrax_> id like to talk directly with the lead developers,but no worries
<cyrax_> >cyrax_, don't bother, you will be using Laconic/Web soon. ;) http://laconic.sf.net/
<cyrax_> very interesting
<Smerdyakov> Yup! I hope to release a redone version of it by ICFP.
<cyrax_> youre the lead dev?
<Smerdyakov> And the only. ;)
<cyrax_> ^^
<cyrax_> youre implementing it with ocaml?
<Smerdyakov> No. Mostly SML.
<cyrax_> ah neat
<cyrax_> i want to learn SML,soon.
<cyrax_> mm..do you find a lot of difference between it and ocaml?
<cyrax_> TY
<cyrax_> mm..youre using *nix,eh?
<Smerdyakov> Sure, like most everyone on Freenode....
<cyrax_> ;)
<cyrax_> the ocaml channel isnt really active though
<Smerdyakov> We're too busy getting real work done.
<Smerdyakov> An active programming language channel is often just a sign that that community doesn't know how to find/read documentation. ;)
<cyrax_> true ^^
<Myoma> yeah
<Camarade_Tux> and it's summer and especially august, for instance Paris really feels empty right now ;)
<Myoma> it's kind of a shame too, some of the people aren't really interested in programming, they just want to be $language cultists
<bluestorm> Myoma: hm
* Smerdyakov gets a mental image of #haskell.
<cyrax_> functional programming is not that famous as well
<bluestorm> haven't noticed actually
<cyrax_> compared to imperative languages
<xevz> It is famous, but not that widely used on the professional market.
<Smerdyakov> Really, good language design discourages random questions. Even if everyone knew about OCaml, its channel would have comparatively few questions.
<cyrax_> yeah its used for academia mostly,not much in real world applications
<Smerdyakov> In case you don't realize it, there aren't really good reasons anymore _not_ to use FP in practical applications.
<Smerdyakov> As long as you're competent
<cyrax_> true,i use it as a learning experience,im only 15,most of the coding i do is for preparing myself for uni
<xevz> Each to his own, I guess. Some people like "conventional" paradigms better...
<cyrax_> anyone around here read ocaml for scientists ?
<Yoric[DT]> I did.
<cyrax_> oh,do you recommend it?
<Yoric[DT]> It's probably somewhat too oriented if you're only 15.
<Yoric[DT]> But the first few chapters are definitely interesting.
<Smerdyakov> What does "too oriented" mean?
<cyrax_> ah too bad
<Yoric[DT]> So is the rest, btw.
<Yoric[DT]> Smerdyakov: John Harrop was aiming for a very specific public.
<Smerdyakov> Gotcha.
<Yoric[DT]> Perhaps "targetted" rather than "oriented".
<cyrax_> scientists
<Yoric[DT]> A subset of scientists :)
<Yoric[DT]> Numerical analysts, I'd say, although that's perhaps too restrictive.
<cyrax_> ah well its no problem ^^
<Smerdyakov> I don't even have to read the book to know that it's embarrassing for OCaml.
<Smerdyakov> Too much grunt work when you have such a weak type system.
<Yoric[DT]> Actually, the book is quite interesting.
<Myoma> Smerdyakov, any more expressive type systems around?
<cyrax_> > Actually, the book is quite interesting..
<Smerdyakov> Myoma, are you serious? Coq is pretty much as expressive as it goes, and it's worlds ahead of OCaml.
<cyrax_> ive read a lot of good reviews
<Myoma> I get the feel that one can do anything in Coq, but to do it somebody else has to tell you how :/
<Smerdyakov> Myoma, types in Coq can capture any property you want, more or less.
<Smerdyakov> Myoma, that applies just the same to any technical tool.
<Yoric[DT]> Coq is impressive.
<Yoric[DT]> But it's definitely not fit for beginners.
<Yoric[DT]> It's worlds ahead of OCaml in complexity, too.
<Smerdyakov> Coq is quite fit for beginners.
<Smerdyakov> The issue is that Coq can be used in so many more ways than OCaml can.
<Smerdyakov> You have to pick the right way.
* Yoric[DT] wishes to see a beginner using Coq...
<Yoric[DT]> I mean, starting with dependent types?
<Yoric[DT]> And kinds?
<Yoric[DT]> Not to mention co-induction and stuff.
<Yoric[DT]> I could believe in Epigram being for beginners.
<bluestorm> i had a problem with the Coq documentation
<Myoma> I don't think Epigram is any easier than Coq
<Smerdyakov> See, you incorrectly assume that you need to use dependent types to use Coq.
<Myoma> infact I am sure it (Epigram 1) is much harder to do anything with
<bluestorm> i have no idea what "intensive" or "extensive equality" means
<Smerdyakov> Also, Coq has no concept of "kind."
<Yoric[DT]> Smerdyakov: are you sure?
<Smerdyakov> bluestorm, don't worry. My book will clear it up.
<bluestorm> :D
<Smerdyakov> Yoric[DT], sure about what?
<Yoric[DT]> No kinds.
<Smerdyakov> Yoric[DT], absolutely. There is only one syntactic class for the whole language. You might mean "universes."
* Yoric[DT] was nearly certain that the first thing one needed to define in Coq when starting from a blank universe was kinds.
<Yoric[DT]> Oh, possibly.
<Yoric[DT]> I may be confusing with [Tw]elf.
<Smerdyakov> But the universes of Coq are built-in and fixed.
<Yoric[DT]> Well, I haven't touched Coq in something like 6 years.
<Yoric[DT]> Or 7.
<bluestorm> anyway
<bluestorm> it may be due to the present teaching approach
<bluestorm> but i've noticed that Coq relies on concepts wich require a quite deep mathematical knowledge
<bluestorm> to deep for me at least
<Myoma> I think intensional equality is like syntactic equality, and extensional equality is like more like leibniz, what properties it has
<Myoma> is that true?
<bluestorm> so it may be, with a proper introduction, compatible with a certain sort of "beginners"
<bluestorm> but probably the one you find in the street, learning an usual programming language
<Smerdyakov> Myoma, yes.
<Smerdyakov> Myoma, of course, there are much more specific technical definitions.
<bluestorm> +not
wlmttobks has quit [K-lined]
<cyrax_> <Smerdyakov>,i saw SMLweb,very neat ^_^
<Smerdyakov> cyrax_, not so neat compared to Laconic.
<cyrax_> yeah ^^
Associat0r has joined #ocaml
<Myoma> perhaps I should use translate some of my prolog code into Coq
<Myoma> trying to do functional programming with it is very hard
<Smerdyakov> With Prolog, you mean?
<Myoma> no
<Smerdyakov> Functional programming is not hard in Coq with a minimal introduction.
<Smerdyakov> If you just want to write Haskell-like code, then it's really trivial.
<Myoma> are there any examples around I can pull apart to learn from?
<Smerdyakov> There will be.
<Smerdyakov> I think my Lambda Tamer library is in pretty good shape: http://ltamer.sf.net/
l_a_m has quit [Remote closed the connection]
cyrax_ has quit [Client Quit]
Snark has quit ["Ex-Chat"]
rhar has quit [Read error: 104 (Connection reset by peer)]
Jeff_123 has joined #ocaml
Jeff_123 has quit [Client Quit]
rhar has joined #ocaml
jeremiah has joined #ocaml
bluestorm has quit [Remote closed the connection]
cyrax has joined #ocaml
netx has quit ["Leaving"]
redocdam has joined #ocaml
sporkmonger has quit [Read error: 104 (Connection reset by peer)]
Yoric[DT] has quit ["Ex-Chat"]
Axioplase is now known as Axioplase_
jeddhaberstro_ has joined #ocaml
jeddhaberstro has quit [Read error: 110 (Connection timed out)]
besiria has quit [Remote closed the connection]
jonafan has joined #ocaml
Jeff_123 has joined #ocaml
jderque has left #ocaml []
Jeff_123 has quit []
asmanur has quit [Read error: 110 (Connection timed out)]
Jeff_123 has joined #ocaml
Kopophex has quit ["Leaving"]
Asmadeus has quit ["timotei~~"]
Amorphous has quit [Read error: 110 (Connection timed out)]
Amorphous has joined #ocaml
hkBst has quit ["Konversation terminated!"]
rhar has quit ["Leaving"]
jlouis has quit [Remote closed the connection]
fremo has quit [Remote closed the connection]
rog1 has left #ocaml []
cyrax has left #ocaml []
fremo has joined #ocaml
Jeff_123 has quit [Read error: 110 (Connection timed out)]
Demitar has quit [Read error: 110 (Connection timed out)]
code17 has quit ["Leaving."]
marmotine has quit ["mv marmotine Laurie"]
flux has quit [zelazny.freenode.net irc.freenode.net]
Hadaka has quit [zelazny.freenode.net irc.freenode.net]
thelema has quit [zelazny.freenode.net irc.freenode.net]
rwmjones has quit [zelazny.freenode.net irc.freenode.net]
sbok has quit [zelazny.freenode.net irc.freenode.net]
cmeme has quit [zelazny.freenode.net irc.freenode.net]
r0bby has quit [zelazny.freenode.net irc.freenode.net]
tsuyoshi_ has quit [zelazny.freenode.net irc.freenode.net]
mwhitney has quit [zelazny.freenode.net irc.freenode.net]
TaXules has quit [zelazny.freenode.net irc.freenode.net]
munga has quit [zelazny.freenode.net irc.freenode.net]
Smerdyakov has quit [zelazny.freenode.net irc.freenode.net]
ertai has quit [zelazny.freenode.net irc.freenode.net]
r0bby has joined #ocaml
thelema has joined #ocaml
tsuyoshi_ has joined #ocaml
rwmjones has joined #ocaml
flux has joined #ocaml
Hadaka has joined #ocaml
TaXules has joined #ocaml
cmeme has joined #ocaml
ertai has joined #ocaml
mwhitney has joined #ocaml
sbok has joined #ocaml
Smerdyakov has joined #ocaml
munga has joined #ocaml
guillem_ has quit [Remote closed the connection]
redocdam has quit []
bzzbzz has joined #ocaml
Jedai has quit [Read error: 110 (Connection timed out)]
bohanlon is now known as kg4qxk