<whitequark>
so anything that is not directly made to interoperate with the ocaml gc would break if it's invoked
<Drup>
but according to the documentation "To avoid problems with the garbage collector, values passed using Ctypes.string are copied into immovable C-managed storage before being passed to C."
<whitequark>
yes. you aren't using my ocaml thingies
<Drup>
oh, you are talking about "string ocaml" ?
<whitequark>
yes
<Drup>
ok, right
<Drup>
(the bug report is about the view string)
<whitequark>
yes
<whitequark>
no idea really about that
<whitequark>
well, I could unwrap gdb, but then you could do it all the same
<Drup>
ok
<Drup>
(in my case, the string ptr may be captured, I think, so I don't want to use a "string ocaml")
<whitequark>
yes
<whitequark>
you're doing it correctly
<whitequark>
I'm quite sure it is a ctypes bu
<whitequark>
bug*
<Drup>
ok
<Drup>
I walked arount it by creating a CArray and copying the content of the string in it
<Drup>
I should check the C code to see if the pointer is actually captured or if the content is just copied somewhere else, but that will be for later.
strobegen has quit [Read error: Connection reset by peer]
Arsenik has joined #ocaml
strobegen has joined #ocaml
<adrien>
whitequark: well, would you spend time working on GTK+3 support?
f[x] has quit [Ping timeout: 272 seconds]
<whitequark>
adrien: "it depends"
<adrien>
would you help out someone who might start soon on it?
Arsenik has quit [Remote host closed the connection]
<whitequark>
adrien: that would be possible
ivan\ has quit [Ping timeout: 276 seconds]
hhugo has joined #ocaml
ivan\ has joined #ocaml
parcs has quit [Read error: Connection reset by peer]
<adrien>
we'll see how it goes and how the gtk+3 effort is rebooted then
parcs has joined #ocaml
<adrien>
the idea being to start with the core by hand and keep the GTK+2 API for now (except the functions not available anymore)
<adrien>
and then see for the generation of the new code (through gobject-introspection but it's gir is crap and it seems to still cause issues [ there's a reason I nuked my project related to gir ])
f[x] has joined #ocaml
alpounet has joined #ocaml
claudiuc has quit [Ping timeout: 264 seconds]
claudiuc has joined #ocaml
Kakadu has joined #ocaml
sagotch has joined #ocaml
Oejet has joined #ocaml
hhugo has quit [Quit: Leaving.]
ontologiae has joined #ocaml
hhugo has joined #ocaml
Eyyub has quit [Ping timeout: 272 seconds]
maufred has joined #ocaml
claudiuc has quit [Ping timeout: 255 seconds]
cago has joined #ocaml
yacks has quit [Ping timeout: 255 seconds]
ggole has joined #ocaml
<companion_cube>
o/
BitPuffin has quit [Ping timeout: 244 seconds]
<ggole>
Sup cc
octachron has joined #ocaml
<companion_cube>
been up late
<companion_cube>
what about you ggole?
<ggole>
I just finished working in the garden
<companion_cube>
you have a garden? nice
<ggole>
Well, it's mostly scrub and trees. The actual garden bit is minimal (because I don't care for the work :) ).
<ggole>
But every now and then something dies and I gotta clean it up.
AltGr has joined #ocaml
thomasga has joined #ocaml
Simn has joined #ocaml
BitPuffin has joined #ocaml
adrien_oww has joined #ocaml
<jpdeplaix>
whitequark: oh well I've looked too fast at the changes
<jpdeplaix>
mmmh but I see nothing interesting for me
maattdd has joined #ocaml
thomasga has quit [Quit: Leaving.]
Moataz-E has joined #ocaml
<rwmjones>
where did labltk upstream move to?
<adrien_oww>
github and one fork on the forge :P
<adrien_oww>
the fork on the forge gives the link to the one on github I think
<rwmjones>
ok found it thanks
Nahra has joined #ocaml
Moataz-E has quit [Quit: Leaving]
maattdd has quit [Ping timeout: 255 seconds]
yacks has joined #ocaml
thomasga has joined #ocaml
thomasga has quit [Client Quit]
thomasga has joined #ocaml
rand000 has joined #ocaml
ollehar has joined #ocaml
lordkryss has joined #ocaml
rand000 has quit [Quit: leaving]
skchrko has joined #ocaml
sagotch has quit [Remote host closed the connection]
thomasga has quit [Quit: Leaving.]
q66 has joined #ocaml
jludlam has joined #ocaml
pminten has joined #ocaml
mort___ has joined #ocaml
ollehar has quit [Ping timeout: 245 seconds]
divyanshu has joined #ocaml
hhugo has quit [Quit: Leaving.]
<jpdeplaix>
whitequark: well done for the ppx support in ocamlfind !
<companion_cube>
+1, looks great
<companion_cube>
is "bytes" a specific package provided by ocamlfind? I'm not sure after reading the announcement
ebzzry has quit [Read error: Connection reset by peer]
pminten has quit [Quit: Leaving]
q66 has quit [Ping timeout: 252 seconds]
lordkryss has quit [Read error: Connection reset by peer]
lordkryss has joined #ocaml
f[x] has quit [Ping timeout: 240 seconds]
ddosia has quit [Quit: Leaving.]
maufred has quit [Ping timeout: 272 seconds]
maufred has joined #ocaml
ontologiae has quit [Ping timeout: 255 seconds]
q66 has joined #ocaml
hhugo has joined #ocaml
siddharthv is now known as siddharthv_away
maufred has quit [Ping timeout: 245 seconds]
maufred has joined #ocaml
madroach has quit [Ping timeout: 252 seconds]
vincentbalat has joined #ocaml
Nahra has quit [Remote host closed the connection]
engil has quit [Remote host closed the connection]
squiggnet has quit [Ping timeout: 240 seconds]
mort___ has quit [Ping timeout: 255 seconds]
squiggnet has joined #ocaml
avsm has joined #ocaml
thomasga has joined #ocaml
penglingbo has quit [Ping timeout: 264 seconds]
Simn has quit [Ping timeout: 240 seconds]
Sim_n has joined #ocaml
racycle has joined #ocaml
shinnya has joined #ocaml
vfoley- has quit [Ping timeout: 240 seconds]
racycle has quit [Quit: ZZZzzz…]
darkf has quit [Quit: Leaving]
pyon has quit [Remote host closed the connection]
pyon has joined #ocaml
manizzle has quit [Ping timeout: 240 seconds]
mort___ has joined #ocaml
Hannibal_Smith has joined #ocaml
madroach has joined #ocaml
f[x] has joined #ocaml
penglingbo has joined #ocaml
SethTisue has joined #ocaml
cago has quit [Ping timeout: 260 seconds]
pminten has joined #ocaml
thomasga has quit [Ping timeout: 240 seconds]
parcs has quit [Remote host closed the connection]
avsm has quit [Quit: Leaving.]
nlucaroni has joined #ocaml
lordkryss has quit [Ping timeout: 272 seconds]
mort___ has quit [Ping timeout: 244 seconds]
thomasga has joined #ocaml
yacks has quit [Ping timeout: 244 seconds]
cago has joined #ocaml
ddosia has joined #ocaml
thomasga has quit [Quit: Leaving.]
madroach has quit [Ping timeout: 252 seconds]
thomasga has joined #ocaml
Kakadu has left #ocaml [#ocaml]
Kakadu has joined #ocaml
cago has quit [Ping timeout: 264 seconds]
<companion_cube>
it's quiet in here
* adrien_oww
shouts in companion_cube's ear
BitPuffin has quit [Ping timeout: 245 seconds]
Puffin has joined #ocaml
<companion_cube>
awww
* companion_cube
slaps adrien_oww with a wiki
Puffin is now known as BitPuffin
<adrien_oww>
:D
<adrien_oww>
thanks!
ontologiae has joined #ocaml
ontologiae has quit [Client Quit]
ontologiae has joined #ocaml
pminten has quit [Read error: Connection reset by peer]
philtor_ has joined #ocaml
axiles has quit [Quit: Quitte]
axiles has joined #ocaml
typedlambda has quit [Ping timeout: 252 seconds]
slash^ has joined #ocaml
jludlam has quit [Remote host closed the connection]
philtor_ has quit [Ping timeout: 244 seconds]
typedlambda has joined #ocaml
thomasga has quit [Quit: Leaving.]
ontologiae has quit [Ping timeout: 240 seconds]
thomasga has joined #ocaml
<BitPuffin>
do you even need to start a scheduler with Lwt at all?
<companion_cube>
BitPuffin: you need to call Lwt_main.run
<BitPuffin>
does that return?
<Drup>
"Lwt_main.run 'a Lwt.t -> 'a"
<companion_cube>
yes, once all Lwt.t threads terminate
<Drup>
the type should answer your question
<BitPuffin>
well shit
<companion_cube>
but in most cases you never need it to return
<BitPuffin>
Guess ocaml is out of the question hten
<adrien>
?
<BitPuffin>
well it's supposed to be a library
<adrien>
run it in a thread
<adrien>
no choice
<adrien>
or have it spawn a thread
<BitPuffin>
well I need to be able to call it
Arsenik has joined #ocaml
<adrien>
if you don't want something to block you can either "run the mainloop" yourself which means pumping events and calling everything, lots of work by hand
<adrien>
or use a thread
<adrien>
inter-thread synchronizations
<adrien>
not sure which alternative you have
<companion_cube>
BitPuffin: you write a library that uses Lwt, is that it?
<companion_cube>
then the library caller should call Lwt_main.run herself
<BitPuffin>
companion_cube: yaeh that will be called *outside* of ocaml
<adrien>
and, why lwt/async in the first place?
<BitPuffin>
ie the ocaml library will expose a C interface
<companion_cube>
oh
<BitPuffin>
adrien: because it needs an internal operation queue that runs asynchronously
<adrien>
run it in a thread and use inter-thread communication and synchronization
<adrien>
I don't think you have the choice
<adrien>
no matter the language
<BitPuffin>
well ocaml doesn't really have any good inter-thread communication does it?
<companion_cube>
or a caml thread that will call Lwt_main.run
<companion_cube>
it has the standard apparatur
<companion_cube>
s*
<adrien>
BitPuffin: it does
<adrien>
and even more with lwt
<ousado>
if ocaml is only used in that thread it doesn't really matter
<adrien>
actually, yeah
<adrien>
if you only need it to run parallel, you only need to start the thread, get a notification when it's done, that's it
<BitPuffin>
companion_cube: well what I was hoping to do was to have an init function that starts a thread + scheduler
<adrien>
it's quite trivial and like 3 lines of code
<adrien>
(right companion_cube, 3 lines of code!)
thomasga has quit [Quit: Leaving.]
<BitPuffin>
well then
<BitPuffin>
what would these 3 lines be like :P
<Drup>
adrien :]
<adrien>
man pthread_<tab> :D
<adrien>
need to afk quite quickly unfortunately
<adrien>
(true)
seanmcl has joined #ocaml
alpounet has quit [Remote host closed the connection]
<ousado>
is the library users code assumed to be async, too?
<BitPuffin>
ousado: no
<BitPuffin>
the idea is that the init function sets up the background thread for the library
lordkryss has joined #ocaml
<BitPuffin>
and then you call the other API functions after that
<Drup>
(I suppose letting ocaml drive is not possible ?)
<BitPuffin>
nope
<Drup>
(not to say C is a bad driver, but he's clearly not a safe one :p)
<BitPuffin>
front end stuff will have to be Obj-C and C# etc
<ousado>
what's the point of doing async IO in the background if the main app blocks?
<BitPuffin>
and the front end will drive what the library does
<BitPuffin>
ousado: well the app doesn't necessarily block, just that the library doesn't make any assumption
<BitPuffin>
it has its internal thread and is happy
<ousado>
APIs for anync and sync code usually look quite different
<ousado>
*async
<BitPuffin>
well all the calls to the library are synchronous kind of
<BitPuffin>
in that for example when you start a file handle the function returns a value that is a handle to the operation in the internal operation queue
<BitPuffin>
so it's not fire and forget for the client
<BitPuffin>
it still gets something back
<BitPuffin>
the point is that the operation queue needs to live in the background
ontologiae has joined #ocaml
<ousado>
that's a deferred/promise/future/whatever you want to call it, then, so it does make the assumption of the users code to be async.
<BitPuffin>
ousado: well no the handle is just like an int or something that you can use to query the queue
<ousado>
you want to require the user to poll for the result?
<BitPuffin>
no
<BitPuffin>
you register a callback function
<BitPuffin>
for when an operation completes
<ousado>
right after you get that handle you register the callback?
<BitPuffin>
nono
<BitPuffin>
before
<BitPuffin>
the callback sends the handle again
<BitPuffin>
so if you need to compare
<BitPuffin>
you can
avsm has joined #ocaml
racycle has joined #ocaml
<ousado>
so there will be an event loop on both sides
<BitPuffin>
kinda yeah
<BitPuffin>
I haven't completely decdided how I want it to deal with things
<BitPuffin>
the idea though is to have the complex stuff like the operation queue in one code base
<ousado>
in that case the second thread sounds like unnecessary overhead.
<ousado>
I'd integrate the event loops
<BitPuffin>
well I'm not sure the "consumer" needs an event loop
<BitPuffin>
it really depends on what they are currently doing
<ousado>
it sure does if it provides callbacks
AltGr has left #ocaml [#ocaml]
<BitPuffin>
well maybe GCD in objective C is an event loop
<BitPuffin>
but there what you would do when you get the callback is that you'd dispatch_async on the thread you want to execute the callback on
avsm has quit [Quit: Leaving.]
<BitPuffin>
actually the way it was was that you called the functions and provided a callback for pretty much every API call
<BitPuffin>
(in the form of an objective-c block)
<BitPuffin>
so when you called it it would dispatch_async on some background thread, and then when it was done it dispatch'd_async the callback on the main thread
<BitPuffin>
because you had to do gui stuff on the main thread
<BitPuffin>
so if GCD in ios is an event loop which I think it might be, then yes, there needs to be two event loops
<BitPuffin>
well it uses a thread pool apparently
<ousado>
a thread pool of threads with an event loop each
<BitPuffin>
yeah
<BitPuffin>
that sounds right
<ousado>
yes, there's no way to make an existing thread execute a callback that didn't exist before the thread was created, otherwise
<BitPuffin>
no that's not what I want
octachron has quit [Quit: Page closed]
<BitPuffin>
so what you'd do is that you registerCallback(callback) before doing any operations. And for every operation that completes it calls that callback
manizzle has joined #ocaml
<BitPuffin>
although that might not fit in well with object oriented languages
<BitPuffin>
hrm
<whitequark>
jpdeplaix: companion_cube: thanks
<ousado>
BitPuffin: that's independent of the language used
<BitPuffin>
ousado: well I mean it doesn't really fit the way it usually works in those languages
<ousado>
there's no way around some kind of callback in whatever language for async code
<BitPuffin>
it might be better if each operation has an associated callback
<BitPuffin>
the internal operation queue however is very important because it is crucial that the operations happen in order
<BitPuffin>
and not at the same time
<BitPuffin>
and I can't think of any way to make it work properly without the lib having its own internal event loop
<BitPuffin>
unless I do something like create a thread if the operation queue is empty, and then have it die out once the operation queue is filled
<BitPuffin>
so when you call a function that adds an operation to the queue it locks the queue, which shouldn't stop the current operation from completing, instead, if that operation completes while you are appending it has to wait for the lock to be unlocked
<BitPuffin>
before picking the next operation if any
<BitPuffin>
do you think that would work ousado
ontologiae has quit [Ping timeout: 255 seconds]
jwatzman|work has joined #ocaml
<whitequark>
Wow, Gerd released findlib
* whitequark
jumps up and down
lambdahands has joined #ocaml
f[x] has quit [Ping timeout: 264 seconds]
<whitequark>
now there's going to be a flurry of releases
<BitPuffin>
so uh
mcclurmc has quit []
<BitPuffin>
if Lwt contains some thread communication stuff for pthreads
<BitPuffin>
will that stuff work on windows? more specifically windows with msvc, _not_ mingw
mcclurmc has joined #ocaml
<Drup>
not sure Lwt_preemptive works there
<Drup>
but you probably don't need it for what you're trying to do
<Drup>
(and maybe it does, try)
<BitPuffin>
by the looks of the README for ocaml on windows it says that the threads library works with 64 bit native windows toolchain
<BitPuffin>
good
<BitPuffin>
then I shall panic less
yacks has joined #ocaml
mcclurmc has quit [Remote host closed the connection]
<Drup>
Don't Panic
<Drup>
have a shovel.
<BitPuffin>
to bury myself? :P
<Drup>
towel*
<BitPuffin>
there is a way to check if a thread has terminated right?
<BitPuffin>
that should be all I need for my approach hopefully
<Drup>
same vowels, different instrument.
<companion_cube>
Drup: have a voyelle
lambdahands has quit [Quit: Page closed]
Arsenik has quit [Remote host closed the connection]
<nlucaroni>
is there remote viewing or hacking for those sessions?
<BitPuffin>
def`: do me a solid and finish up the concurrent GC :P
shinnya has quit [Ping timeout: 244 seconds]
Kakadu has quit [Ping timeout: 246 seconds]
mcclurmc has joined #ocaml
shinnya has joined #ocaml
<adrien>
findlib.cmxs
<adrien>
so ocamlbuild could use that directly? :)
<Drup>
nlucaroni: well, I plan to hack during the same period of time, does that count as remote hacking ? :D
BitPuffin has quit [Ping timeout: 264 seconds]
<def`>
Drup: there is a presentation about multicore GC right now, but I don't think you can remote view :'
<Drup>
:(
<Drup>
(do want presentation about multicore GC)
<adrien>
def`: transcribe it on IRC for us :)
ssbr has quit [Ping timeout: 240 seconds]
<nlucaroni>
Drup: heh, yes. I was just thinking coordination-wise. I'd love to help sometime and take a couple days off work.
philtor_ has joined #ocaml
jnott has joined #ocaml
jao has joined #ocaml
jao has quit [Changing host]
jao has joined #ocaml
skchrko has quit [Quit: Leaving]
tane has quit [Read error: Connection reset by peer]
tane has joined #ocaml
philtor_ has quit [Ping timeout: 245 seconds]
Kakadu has joined #ocaml
ssbr has joined #ocaml
madroach has joined #ocaml
manizzle has joined #ocaml
hhugo has quit [Quit: Leaving.]
lordkryss_ has joined #ocaml
lordkryss has quit [Ping timeout: 244 seconds]
alpounet has joined #ocaml
penglingbo has quit [Ping timeout: 240 seconds]
slash^ has quit [Read error: Connection reset by peer]
squiggnet has quit [Ping timeout: 244 seconds]
nlucaroni has quit [Quit: leaving]
<Drup>
def`: since you have access to a large bunch of compiler hackers right now, can you ask where to find the the REPL printer in the compiler's sources ?
hhugo has joined #ocaml
<def`>
Drup: PM
manizzle has quit [Remote host closed the connection]
manizzle has joined #ocaml
mcclurmc has quit [Remote host closed the connection]
shallow has quit [Ping timeout: 240 seconds]
mcclurmc has joined #ocaml
hexo has joined #ocaml
hexo has quit [Excess Flood]
hexo has joined #ocaml
lordkryss has joined #ocaml
lordkryss__ has joined #ocaml
lordkryss_ has quit [Ping timeout: 255 seconds]
lordkryss has quit [Ping timeout: 255 seconds]
thomasga has quit [Quit: Leaving.]
ikaros has quit [Quit: Ex-Chat]
arj has joined #ocaml
NoNNaN has joined #ocaml
Hannibal_Smith has quit [Quit: Sto andando via]
rand000 has joined #ocaml
Arsenik has joined #ocaml
ggole has quit []
vfoley- has joined #ocaml
claudiuc has joined #ocaml
Eyyub has joined #ocaml
hhugo has quit [Quit: Leaving.]
hhugo has joined #ocaml
madroach has quit [Ping timeout: 244 seconds]
SethTisue has quit [Quit: SethTisue]
hhugo has quit [Ping timeout: 245 seconds]
tnguyen1 has quit [Quit: tnguyen1]
SethTisue has joined #ocaml
SethTisue has quit [Client Quit]
BitPuffin has joined #ocaml
mcclurmc has quit [Remote host closed the connection]
Arsenik has quit [Remote host closed the connection]
<BitPuffin>
hmm I'm actually wondering if ocaml will work. The approach I want to take with the library requires that I need to spin up a separate physical thread when the queue gets filled and let it die once the queue is empty. And I also need to share some data that I lock, for example having a mutex for accessing database values, so that you can't set values at certain times that the queue might need to lock it. And
<BitPuffin>
the OCaml runtime doesn't allow data sharing between real operating system threads right?
<adrien>
it does
jnott has left #ocaml ["Leaving"]
<BitPuffin>
real world ocaml said it didn't
<adrien>
but you do your own synchronization; it doesn't impose a model
<adrien>
hmmmmmmmmmm
<BitPuffin>
I think at least
<adrien>
context is probably everything
<BitPuffin>
that's what I took from it
<adrien>
going to bed now, good night
<BitPuffin>
we can talk about it in the mooornin
<BitPuffin>
unless someone else has input
<BitPuffin>
goodnight adrien!
mcclurmc has joined #ocaml
<BitPuffin>
actually maybe it said that you can do it but three is no safety guarantees
<BitPuffin>
if so it's not worse than C \o/
arj has quit [Remote host closed the connection]
<whitequark>
hrm, I would think I missed the hacking session
<whitequark>
Drup: or not?
<BitPuffin>
are you in cambridge?
<whitequark>
I have 3 hours of hacking, or whatever's until my notebook dies
<whitequark>
BitPuffin: nope
<Drup>
well, they weren't actually any thing remotely
<def`>
whitequark: Drup is sleeping :)
<def`>
whitequark: hacker session is going
<Drup>
hum, well :D
<def`>
Drup is NOT sleeping
<whitequark>
def`: but there's nothing done remotely?
<def`>
whitequark: nop :'
<whitequark>
a pity
<Drup>
def`: I started looking at the file you pointed me too
<Drup>
to*
<BitPuffin>
I think maybe I'll make my first language less special than initially planned. It seems like an ocaml style language that doesn't hate manually managed memory and some knowledge about threads and stuff could be nice.
<BitPuffin>
Ie sharing GC'd data between threads is a static error
<BitPuffin>
and with manually managed memory it's on you
<whitequark>
just use rust
<whitequark>
I was where you are and it's no fun.
<BitPuffin>
well Rust is trying to appeal too much to C++ devs
<whitequark>
who cares
<BitPuffin>
but yeah rust would be some inspiration for the language
<whitequark>
you're going to waste your time.
<BitPuffin>
I am starting to like ML syntax, what can I say :P
<BitPuffin>
and rust doesn't do currying and stuff does it?
<whitequark>
well, from the runtime point of view, they're equal with ocaml
<whitequark>
a complete application is a single call, a partial application creates an intermediate closure
<BitPuffin>
oh so they allow partial application?
<whitequark>
no
<BitPuffin>
or is it like a special keyword
<whitequark>
not syntactically
<BitPuffin>
ah
<BitPuffin>
a lib thing?
<whitequark>
no, you just make a closure.
<BitPuffin>
ah
<BitPuffin>
lol
<BitPuffin>
well we do as well
<BitPuffin>
underneath
<BitPuffin>
kinda
<BitPuffin>
isn't let foo a b = a + b short for let foo = fun a -> (fun b -> a + b)
<whitequark>
I'm not sure
<BitPuffin>
rwo told me it means the same thing but I don't know if the first one is supposed to be sugar
<BitPuffin>
semantically they are the same at least
<whitequark>
the native compiler optimizes the first case
<whitequark>
but I'm not sure about the second
<BitPuffin>
optimizes how?
<whitequark>
"foo 1 2" is a single call instruction
<BitPuffin>
yeah, but I think you can call foo 1 2 on the second one as well
<BitPuffin>
I *think*
<BitPuffin>
let's try
<whitequark>
you can
<whitequark>
but it wouldn't necessarily generate the same code
<BitPuffin>
yep you can
<BitPuffin>
would have to disassemble and check I guess
<BitPuffin>
the returned val is the same at least
<whitequark>
well, duh
<whitequark>
of course it is
<BitPuffin>
and if it's a good boy it should see them as the same :P
philtor_ has joined #ocaml
avsm has quit [Quit: Leaving.]
axiles has quit [Remote host closed the connection]
<def`>
BitPuffin: they are the same yes
<def`>
when in doubt, just run the toplevel with -dlambda: it prints an untyped scheme-like language which is what will actually be sent to the backend
<BitPuffin>
the ast?
philtor_ has quit [Ping timeout: 240 seconds]
<def`>
the ast?
<BitPuffin>
is that what it prints?
squiggnet has joined #ocaml
tnguyen1 has joined #ocaml
jao has quit [Ping timeout: 240 seconds]
alpounet has quit [Remote host closed the connection]
tnguyen1 has quit [Client Quit]
alpounet has joined #ocaml
mcclurmc has quit [Remote host closed the connection]
mcclurmc has joined #ocaml
Sim_n has quit [Quit: Leaving]
avsm has joined #ocaml
seanmcl has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
Eyyub has quit [Ping timeout: 240 seconds]
tnguyen has joined #ocaml
thomasga has joined #ocaml
SethTisue has joined #ocaml
tane has quit [Quit: Verlassend]
Eyyub has joined #ocaml
hexo has quit [Excess Flood]
hexo has joined #ocaml
hexo has quit [Excess Flood]
hexo has joined #ocaml
studybot_ has quit [Remote host closed the connection]
studybot_ has joined #ocaml
IbnFirnas has quit [Ping timeout: 244 seconds]
jzelinskie has quit [Ping timeout: 264 seconds]
emmanueloga has quit [Ping timeout: 264 seconds]
ggherdov has quit [Ping timeout: 264 seconds]
leifw has quit [Ping timeout: 264 seconds]
lopex has quit [Ping timeout: 264 seconds]
leifw has joined #ocaml
lopex_ has joined #ocaml
IbnFirnas has joined #ocaml
jzelinskie has joined #ocaml
emmanueloga has joined #ocaml
alpounet has quit [Remote host closed the connection]
alpounet has joined #ocaml
alpounet has quit [Read error: Connection reset by peer]
WraithM has quit [Ping timeout: 264 seconds]
IbnFirnas has quit [Ping timeout: 244 seconds]
ggherdov has joined #ocaml
mcclurmc has quit [Remote host closed the connection]
IbnFirnas has joined #ocaml
asmanur has quit [Quit: quit]
tnguyen has quit [Quit: tnguyen]
asmanur has joined #ocaml
avsm has quit [Quit: Leaving.]
darkf has joined #ocaml
lordkryss__ has quit [Ping timeout: 264 seconds]
WraithM has joined #ocaml
Kakadu has quit [Quit: Konversation terminated!]
SethTisue has quit [Quit: SethTisue]
NoNNaN has quit [Remote host closed the connection]
philtor_ has joined #ocaml
waneck has joined #ocaml
thomasga has quit [Quit: Leaving.]
SethTisue has joined #ocaml
philtor_ has quit [Ping timeout: 245 seconds]
SethTisue has quit [Client Quit]
mcclurmc has joined #ocaml
mcclurmc has quit [Remote host closed the connection]