<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>
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)
<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?
<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)]