<bernardofpc>
If to use the Makefile one has to have OASIS installed and the _oasis file, then what convenience is there to have those files checked in ?
<bernardofpc>
It might spare one run of oasis setup dynamic ?
<Drup>
yes
<bernardofpc>
is this worse than having to checkin setup/Make/configure each time a change to _oasis happens ?
<Drup>
it's not the case with the dynamic setip
<Drup>
setup*
maattdd has quit [Ping timeout: 240 seconds]
rgrinberg has joined #ocaml
tlockney_away is now known as tlockney
ollehar has quit [Ping timeout: 240 seconds]
SethTisue has joined #ocaml
maattdd has joined #ocaml
rgrinberg has quit [Quit: Leaving.]
tiglionabbit has quit [Quit: tiglionabbit]
eikke__ has quit [Ping timeout: 252 seconds]
eikke__ has joined #ocaml
dsheets has joined #ocaml
tnguyen has quit [Quit: tnguyen]
maattdd has quit [Ping timeout: 240 seconds]
SethTisue has quit [Quit: SethTisue]
eikke__ has quit [Ping timeout: 276 seconds]
mcclurmc has joined #ocaml
mcclurmc has quit [Remote host closed the connection]
caligula has quit [Quit: Konversation terminated!]
WraithM has quit [Ping timeout: 245 seconds]
tiglionabbit has joined #ocaml
lopex has quit [Quit: Connection closed for inactivity]
jeregrine has quit [Ping timeout: 265 seconds]
WraithM has joined #ocaml
tlockney is now known as tlockney_away
tlockney_away is now known as tlockney
jeregrine has joined #ocaml
jeregrine has quit [Ping timeout: 252 seconds]
tlockney is now known as tlockney_away
rgrinberg has joined #ocaml
racycle has quit [Quit: ZZZzzz…]
SethTisue has joined #ocaml
SethTisue has quit [Client Quit]
dsheets has quit [Ping timeout: 276 seconds]
WraithM has quit [Ping timeout: 258 seconds]
f[x] has joined #ocaml
jao has joined #ocaml
jao has quit [Changing host]
jao has joined #ocaml
johnnydiabetic has joined #ocaml
johnnydiabetic has quit [Quit: Leaving]
WraithM has joined #ocaml
tiglionabbit has quit [Quit: tiglionabbit]
fraggle_laptop has quit [Remote host closed the connection]
Nuki has quit [Ping timeout: 264 seconds]
Nuki has joined #ocaml
tiglionabbit has joined #ocaml
jao has quit [Ping timeout: 264 seconds]
rgrinberg has quit [Quit: Leaving.]
S11001001 has quit [Quit: ERC Version 5.3 (IRC client for Emacs)]
rgrinberg has joined #ocaml
Bynbo7 is now known as Axman6
tiglionabbit has quit [Quit: tiglionabbit]
tlockney_away is now known as tlockney
testcocoon has quit [Quit: Coyote finally caught me]
WraithM has quit [Ping timeout: 240 seconds]
tiglionabbit has joined #ocaml
tiglionabbit has quit [Client Quit]
axiles has quit [Quit: Quitte]
yacks has joined #ocaml
Submarine has joined #ocaml
tiglionabbit has joined #ocaml
f[x] has quit [Ping timeout: 258 seconds]
WraithM has joined #ocaml
tiglionabbit has quit [Quit: tiglionabbit]
dapz has joined #ocaml
dapz has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
jeregrine has joined #ocaml
dapz has joined #ocaml
jeregrine has quit [Ping timeout: 258 seconds]
dapz has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
malc_ has joined #ocaml
f[x] has joined #ocaml
chris2 has quit [Ping timeout: 245 seconds]
chris2 has joined #ocaml
Kakadu has joined #ocaml
tiglionabbit has joined #ocaml
tiglionabbit has quit [Client Quit]
testcocoon has joined #ocaml
NoNNaN has quit [Remote host closed the connection]
NoNNaN has joined #ocaml
philtor has joined #ocaml
malc_ has quit [Quit: leaving]
tlockney is now known as tlockney_away
f[x] has quit [Ping timeout: 265 seconds]
philtor has quit [Ping timeout: 276 seconds]
eizo has joined #ocaml
pyon has joined #ocaml
ggole has joined #ocaml
dapz has joined #ocaml
rand000 has joined #ocaml
Nuki has quit [Ping timeout: 252 seconds]
alpounet has joined #ocaml
ggole has quit [Read error: Connection timed out]
Nuki has joined #ocaml
michael_lee has joined #ocaml
dapz has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
ggole has joined #ocaml
studybot_ has quit [Remote host closed the connection]
Nuki has quit [Remote host closed the connection]
tiglionabbit has joined #ocaml
rgrinberg has quit [Quit: Leaving.]
robink has quit [Ping timeout: 264 seconds]
tiglionabbit has quit [Quit: tiglionabbit]
robink has joined #ocaml
robink has quit [Quit: No Ping reply in 180 seconds.]
pgomes has joined #ocaml
robink has joined #ocaml
Nuki has joined #ocaml
pminten has joined #ocaml
rand000 has quit [Ping timeout: 245 seconds]
tiglionabbit has joined #ocaml
tiglionabbit has quit [Client Quit]
ollehar has joined #ocaml
Submarine has quit [Quit: Leaving]
WraithM has quit [Ping timeout: 245 seconds]
tane has joined #ocaml
Submarine has joined #ocaml
Submarine has quit [Changing host]
Submarine has joined #ocaml
<whitequark>
Drup: convenience <<< silly sense of "clean-ess"...
<whitequark>
but even with oasis dynamic setup, you can regenerate the files & make a tag with one make target, so you don't even give that up
alpounet has quit [Remote host closed the connection]
alpounet has joined #ocaml
tiglionabbit has joined #ocaml
alpounet has quit [Ping timeout: 276 seconds]
tiglionabbit has quit [Ping timeout: 276 seconds]
AeroNotix_ is now known as AeroNotix
rand000 has joined #ocaml
* pgomes
is away: auto-away
ollehar has quit [Ping timeout: 240 seconds]
* pgomes
is back (gone 00:04:58)
<adrien>
pgomes: please disable that
<adrien>
it's annoying at best
<pgomes>
sorry
<pgomes>
did not realise that ..:(
<pgomes>
It should be disabled now
<adrien>
thanks
lopex has joined #ocaml
alpounet has joined #ocaml
pminten has quit [Remote host closed the connection]
<Kakadu>
Why does this code typechecks? http://paste.in.ua/9612/raw/ Why ocaml doesn't get angry about labeled arguments?
<kerneis>
Kakadu: the function takes 2 parameters
<kerneis>
you give 2 parameters
<kerneis>
so there is no ambiguity
<Kakadu>
It should be an error
<Kakadu>
There was compiler switch which allows to ignore lableled arguments
<kerneis>
read again the first section of this page
Nuki has joined #ocaml
<kerneis>
"As an exception to the above parameter matching rules, if an application is total (omitting all optional arguments), labels may be omitted. "
rand000 has quit [Ping timeout: 252 seconds]
<Kakadu>
ok
darkf has quit [Quit: Leaving]
tobiasBora has joined #ocaml
michael_lee has quit [Remote host closed the connection]
alpounet has quit [Remote host closed the connection]
jao has quit [Ping timeout: 252 seconds]
eikke__ has joined #ocaml
bunzen has left #ocaml [#ocaml]
dsheets has joined #ocaml
tobiasBora has quit [Quit: Konversation terminated!]
Nuki has quit [Remote host closed the connection]
rand000 has joined #ocaml
fraggle_laptop has joined #ocaml
pgomes has quit [Ping timeout: 252 seconds]
tobiasBora has joined #ocaml
tane has quit [Quit: Verlassend]
ontologiae has joined #ocaml
pgomes has joined #ocaml
michael_lee has joined #ocaml
rand000 has quit [Ping timeout: 276 seconds]
q66 has joined #ocaml
q66 has quit [Changing host]
q66 has joined #ocaml
oriba has joined #ocaml
tane has joined #ocaml
oriba has quit [Quit: Verlassend]
studybot has joined #ocaml
alpounet has joined #ocaml
alpounet has quit [Ping timeout: 240 seconds]
ontologiae has quit [Ping timeout: 252 seconds]
f[x] has joined #ocaml
eikke__ has quit [Ping timeout: 252 seconds]
eikke__ has joined #ocaml
<tobiasBora>
Hello !
<tobiasBora>
I would like to know what is the best way to edit a file in place. I mean I would like to replace some works in the text, one way would be to read line by line, replace, and write in an other file (or put it in RAM but for huge files it's not very proper...) but I don't like the idea of writting all the code in an other file when only one or two words are going to change.
<mrvn>
sed -i
<tobiasBora>
mrvn: Yes I would like to implement something like sed -i, but in Ocaml ^^ (I don't want to be system dependant)
<mrvn>
consider what happens when power fails alf way through. It's best to modify while copying to a new file and in the end atomically replace the old file with the new file.
<mrvn>
s/alf/half/
<tobiasBora>
Really ? And for huge files, is this method usable ?
<tobiasBora>
And how can I choose the temp file "properly" ?
<Drup>
name of your app + random number, put it in /tmp
<adrien>
errrr
<mrvn>
tobiasBora: for huge files use a COW filesystem, make a shallow copy and modify that in place.
<gasche>
no need to
<gasche>
Filename.open_temp_file
<mrvn>
does ocaml support O_TMPFILE yet?
<adrien>
that ^ is way better than rolling your own temp file stuff
<adrien>
mrvn: no
<mrvn>
O_TMPFILE is cool though.
<adrien>
considering it has existed for less than 6 months that was doubtful
<tobiasBora>
Thank you !
* tobiasBora
is looking what is a cow... filesystem
<adrien>
copy on write
alpounet has joined #ocaml
<gasche>
(COW is the mainstream name for "persistent data structure")
<mrvn>
gasche: nope
<companion_cube>
it's rather the mainstream implementation
<mrvn>
modern filesystems fall into 2 categories: journaling and COW.
<mrvn>
journaling first records what it is going to do and then does it. After a crash it redoes what it was going to do before the crash.
<mrvn>
COW flesystems always write by copying the data to a fresh location and whe done they atomically switch some pointer to point to the new place.
<tobiasBora>
But that means that if I want to modify a 5Go file I need to first copy the 5Go, then modify them, and finaly modify the pointers
<tobiasBora>
?
<gasche>
COW generally also refers to the fact that no actual copy is done between the "copy" call and the first actual write
<mrvn>
tobiasBora: they usualy work is block, e.g. 4k.
<gasche>
(a lazyness optimization to implement mutable datatypes with a persistent-like path-sharing structure in the backend)
<tobiasBora>
Hum... And if the new block is larger than 4k ?
<mrvn>
tobiasBora: a file is made up of a collection of 4k blocks.
<mrvn>
tobiasBora: usualy a B-Tree is used to handle all the metadata, which in itself uses 4k blocks too.
<mrvn>
tobiasBora: every change to the FS creates a new B-Tree root and new nodes along the path down the B-Tree up to the leaf block that actualy gets modified. Then when everything is written you atomically record the block number for the new root.
<gasche>
tobiasBora: what is your use case?
<mrvn>
Then there are lots of tricky things you can do to reduce the number of blocks needed to make a change. Primarily combine lots of changes into a single new root.
ollehar has quit [Ping timeout: 240 seconds]
<tobiasBora>
mrvn: And is it possible to record block smaller or greater than 4k ? For example if I want to add one char in a block, the block will be too large to fit in 4k, and if the additional char is shift in others block, every thing should be shift and that's quite ugly !
<mrvn>
tobiasBora: how do you insert a char in a file?
<tobiasBora>
gasche: My use case is a basic one (like sed) so I will use temp files, but I don't really know how files are registers in memory and that's a big mystery I'd like to explain ^^ (for example, why doesn't EXT4 need refragmentation ?)
<mrvn>
tobiasBora: because it does need it
<tobiasBora>
mrvn: Well... Actually I don't know, I always add chars at the end of the file !
<tobiasBora>
mrvn: Because it uses referencies to the blocks ?
<gasche>
if you're interested in this kind of things, you should consider subscribing to Linux Weekly News
<mrvn>
tobiasBora: you can't insert into a file. Only overwrite or append.
<gasche>
high-quality technical articles on the Linux ecosystem each week
<gasche>
at a modest price
<mrvn>
tobiasBora: inserting requires first moving everything after the insertion and then filling in the new part. ugly.
<gasche>
(you can even not pay anything and get the articles the week after their publication, but I prefer to support the authors)
<tobiasBora>
gasche: Oh nice, I'll give it a further look !
<tobiasBora>
mrvn: Uhm that's clearer now... So when I edit a file with emacs for example, the whole new file is written in another place, the old one destroyed, and the memory pointer is changed ? Does these editor uses a temp file and a move command, or can the temp file be in RAM ?
<NoNNaN>
tobiasBora: what is your tipical and largest file sizes ? and what kind of modification do you apply?
<mrvn>
tobiasBora: emacs always safes to a tempfile, then renames the original to *~ and the temp to *
<mrvn>
tobiasBora: but that is independent of the FS
<NoNNaN>
tobiasBora: and how often these modifications happen ?
<tobiasBora>
NoNNaN: In my case I have basic text files, and modifications aren't made often so the basic method with temp file is good for me, but I'm curious to know what is the proper way to deal with very large files.
<companion_cube>
the journalization techniques sounds "easier"
<companion_cube>
you can modify, overwrite, etc. in place but need to keep a journal
<tobiasBora>
mrvn: Ok ^^ I though that these temp file was only for the user
<NoNNaN>
tobiasBora: and what should happen when you delete a char in the beginning of a 100GB file ?
<tobiasBora>
companion_cube: Like with git ? So to read a file you need to read each modification since the creation ?
<companion_cube>
tobiasBora: the file is the current snapshot
<companion_cube>
well yes you can also apply all the modifications from start ("event sourcing")
<tobiasBora>
companion_cube: And each time you wrote a letter, emacs write a new file in /tmp, then replace the tempfile with the one in /tmp ?
<tobiasBora>
sorry
<companion_cube>
of course not, I don't use emacs
<companion_cube>
;)
<companion_cube>
but you can keep a snapshot in memory of course
<ggole>
FALLOC_FL_PUNCH_HOLE doesn't remove the space afaik
<Drup>
(I read "FALCON PUNCH")
<ggole>
If you want to remove a char, gotta rewrite the whole thing
<tobiasBora>
companion_cube: You mean that the journaling is "back time" ? (the snapshot is the current file and to journal contains the old versions ?
<NoNNaN>
if you delete a char at the beginning of a file, the size will be smaller, and _PUNCH_HOLE require linux with XFS (since Linux 2.6.38), ext4 (since Linux 3.0), Btrfs (since Linux 3.7), tmpfs (since Linux 3.5)...
<tobiasBora>
NoNNaN: That's all the question ^^
<companion_cube>
tobiasBora: if you keep the whole journal from the beginning, in a file, you would append recent events to the end of the journal
<companion_cube>
event= modification
jeregrine has joined #ocaml
<tobiasBora>
companion_cube: And how could I read the file if I don't use event courcing ?
<tobiasBora>
*sourcing
<companion_cube>
you need to, if files are stored this way
<companion_cube>
I'm just talking about a way to implement durability for files
<tobiasBora>
uhm ok
jeregrine has quit [Ping timeout: 264 seconds]
Averell has quit [Ping timeout: 255 seconds]
zebr has quit [Ping timeout: 255 seconds]
zebr has joined #ocaml
<tobiasBora>
Well that's a bit clearer in my mind now, thank you every body for your help !
Averell has joined #ocaml
rand000 has joined #ocaml
studybot has quit [Remote host closed the connection]
<companion_cube>
tobiasBora: :)
<NoNNaN>
tobiasBora: if you have lot's of operation, you should check the rope data structure, you can combine your edits with the original file in a user space filesystem (fuse) using a redo log
<NoNNaN>
assuming no other modification (other program) is change that file, in this way you provide an updated "view" to the file with your modifications, if it's correct, you could apply the log to the original file (with lock ranges)...
<tobiasBora>
NoNNaN: It only works on specific fs no ? (using redo log)
acieroid` has joined #ocaml
passiveo- has joined #ocaml
samebcha1e has joined #ocaml
clog_ has joined #ocaml
Shozan has joined #ocaml
Shozan has quit [Changing host]
Shozan has joined #ocaml
demonimin_ has joined #ocaml
<NoNNaN>
tobiasBora: you implemented the virtual a file system and files, eg.: including what should happen (original file + redo log) when somebody open a file, read it from byte=1024 to 2048
<companion_cube>
so the file modification log contains reversible changes?
<tobiasBora>
NoNNaN: Oh I think I see what you mean... But it works only if I'm the only one using this file, while it's a custom organisation
fraggle_laptop has quit [*.net *.split]
michael_lee has quit [*.net *.split]
clog has quit [*.net *.split]
passiveobserver has quit [*.net *.split]
samebchase has quit [*.net *.split]
fraggle_ has quit [*.net *.split]
acieroid has quit [*.net *.split]
SHODAN has quit [*.net *.split]
demonimin has quit [*.net *.split]
<mrvn>
tobiasBora: others can use the file too, but only through our fuse
<mrvn>
s/our/your/
<NoNNaN>
tobiasBora: you mean other users may also do some modifications on the file, while you read it ?
pgomes has quit [Ping timeout: 240 seconds]
dapz has joined #ocaml
fraggle_ has joined #ocaml
fraggle_laptop has joined #ocaml
<tobiasBora>
I don't think so but why not :P
<tobiasBora>
And is it complicated to build such a fuse ?
<NoNNaN>
tobiasBora: and they access it from the same machine or an another machine ?
<tobiasBora>
I would say that it's more logical they access it from another machine, but again, I'm just curious, it's not a real case I have for the moment
<tobiasBora>
Oh ocamlfuse exists...
<whitequark>
fuse -_-
mcclurmc has quit [Remote host closed the connection]
fraggle_laptop has quit [Remote host closed the connection]
alpounet has quit []
dapz has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
dapz has joined #ocaml
tnguyen has joined #ocaml
ollehar has joined #ocaml
eikke__ has quit [Ping timeout: 240 seconds]
michael_lee has quit [Ping timeout: 252 seconds]
mcclurmc has joined #ocaml
<Drup>
I'm surprised, I though -unsafe replaced the get/set functions by unsafe_get/set, not just the syntactic operators .[]/.()
<adrien>
that'd be really "unsafe" :)
avsm has joined #ocaml
<Drup>
well, it's named "unsafe"
<Drup>
also, by greping the compiler, I discovered that -unsafe also disable the check for division by zero
<Drup>
(at least some of them, not sure where or what)
<Drup>
"fast" is the name of the internal flag turned on by -unsafe
avsm has quit [Quit: Leaving.]
<AeroNotix>
is there something like XMonad but written in OCaml?
<Drup>
not as far as I know
<AeroNotix>
:(
eikke__ has joined #ocaml
<Drup>
adrien : actually, this part is just weird, it's when the fast flag is not on
tobiasBora has quit [Quit: Konversation terminated!]
clog_ has quit [Quit: ^C]
clog has joined #ocaml
tlockney_away is now known as tlockney
mcclurmc has quit [Remote host closed the connection]
eikke__ has quit [Ping timeout: 240 seconds]
philtor has joined #ocaml
pgomes has joined #ocaml
racycle_ has joined #ocaml
ollehar1 has joined #ocaml
soze has joined #ocaml
<soze>
Hello
ollehar1 has quit [Ping timeout: 240 seconds]
<soze>
is there anyone interested in interpretation and theoric stuff
<soze>
I couldnt figure out difference between s expressions in Lisp and expressions in OCaml
<Drup>
what do you want to know exactly ?
<soze>
OK , do you know Metacircular Interpretation part on SICP
f[x] has quit [Ping timeout: 252 seconds]
<Drup>
nope
<soze>
Book claims reading programs as s expression type data is called metacircular how about a ocaml interpreter written in ocaml, why it is not metacircular
WraithM has joined #ocaml
<tane>
soze, that's a matter of how lisp represents lisp programs
<tane>
which is the same way it represents data
<tane>
a lisp program IS lisp data
<tane>
from wp: "In a homoiconic language the primary representation of programs is also a data structure in a primitive type of the language itself."
<soze>
yeah, but is it possible to make that way in ocaml too
<tane>
nope
<tane>
ocaml is not homoiconic, as far as i got it
<soze>
thank you, i got to point but I also wonder, if there is interpreter at all how Lisp evaluate data for first time
<tane>
what do you mean by that?
<soze>
sorry, I mean, as I understand, there is no interpreter, s expressions should be interpreted and be interpreter, how this process run for first time
<tane>
not really
<tane>
the thing is, lisp programs are lists of lists, whilest the main data structure in lisp are lists of lists
<tane>
so, the interpreter can represent programs the same way it represents usual data
<companion_cube>
ocaml programs are trees, and trees are a most important structure in OCaml ;)
<tane>
tree's aren't primite though :)
<companion_cube>
with extension-points OCaml is getting closer to lisp
<tane>
primitive*
<companion_cube>
tane: well you can define them very easily, so they are
<tane>
that's not the definition of primitive type in that context
<companion_cube>
I'm not sure primitive types are the same thing in a dynamically typed language, and in a statically typed on
<companion_cube>
one
<companion_cube>
because in lisp only shape matters
<companion_cube>
whereas in OCaml trees can have many flavors thanks to (due to?) typing
<ggole>
Datatypes would be the equivalent
<tane>
well, things inside a lisp list can have different dynamic types, the list is made up of the same cons cells
<ggole>
But a datatype to represent ocaml programs would be a lot more complicated than lisp data structures
* ggole
looks at camlp4
<Drup>
ggole: that's only the parse tree :)
<ggole>
Right, but that's fairly close to s-expressions
<Drup>
except quite more complicated
<NoNNaN>
and if you run native code, memory representation would be also interesting..
<ggole>
Indeed
<tane>
wikipedia considers "julia" being a homoiconic language, i wonder why
<ggole>
I think the real thing that lisp adds isn't homoiconicity per se, but a built-in and easily available way of moving between the term and data worlds
<ggole>
quote and defmacro are right there.
<soze>
I got Programming Languages course for first time, writing interpreter for ocaml and lexers, parsers etc, but approach of Lisp in SICP looks very interesting to me
demonimin_ has quit [Remote host closed the connection]
typedlambda has quit [Ping timeout: 252 seconds]
<mrvn>
tane: because it is such a nce long word that nobody will understand so we can link that to another page explaining the term and get the page rangd higher.
acieroid` is now known as acieroid
<tane>
mrvn, politics yeah? :)
<Drup>
julia people tend to be a little crazy on buzz word
<Drup>
they even consider julia a dependently type language, which is slightly backward.
<Drup>
some do, at least
<tane>
julia looked promising, but as i read the forums about the very slow startup time they categorized that as low priority, so it's done for me :)
typedlambda has joined #ocaml
<whitequark>
that's what you get for using LLVM...
<Drup>
JIT LLVM*
<whitequark>
well, LLVM isn't really a general-purpose JIT
<whitequark>
it's slow in batch mode and slow in JIT mode, but in the first case it doesn't hurt
<ggole>
Things that are good at things that they are designed for aren't necessarily good at what they aren't designed for? Who knew?
<whitequark>
it has a FastISel, but apparently emitting code suitable for it is "hard" for frontends
<ggole>
I guess people use it because it's low effort.
<whitequark>
ggole: well, people that keep using LLVM as a JIT, apparently, do not
pyon has quit [Read error: Connection reset by peer]
<ggole>
Wonder how difficult it was to adapt LLVM for a dynamically typed language
<ggole>
Unless they just compile the typed bits
<whitequark>
why would it be hard?
<whitequark>
it just won't execute very fast :p
<companion_cube>
llvm has been used for dynamic languages
<companion_cube>
e.g. "pure"
<whitequark>
LLVM doesn't really allow you to replace a function with an optimized version, so once you compile it to something, it's set in stone
<tane>
rubinius ruby implementation uses llvm as well
<whitequark>
so you'll have a ton of dispatch tables
yacks has quit [Quit: Leaving]
<ggole>
I was thinking of things like removing redundant type checks, etc
<whitequark>
yep, can't really do that
<whitequark>
you can emit code for checking inline caches and branching, but you can't really fully remove checks
dapz has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
WraithM has quit [Ping timeout: 252 seconds]
racycle_ has quit [Quit: ZZZzzz…]
typedlambda has quit [Ping timeout: 252 seconds]
typedlambda has joined #ocaml
soze has quit [Quit: Page closed]
WraithM has joined #ocaml
WraithM has quit [Ping timeout: 258 seconds]
tnguyen has quit [Quit: tnguyen]
WraithM has joined #ocaml
pgomes has quit [Quit: Leaving]
samebcha1e is now known as samebchase
demonimin has joined #ocaml
demonimin has quit [Changing host]
demonimin has joined #ocaml
Submarine has quit [Quit: Leaving]
tlockney is now known as tlockney_away
octachron has joined #ocaml
WraithM has quit [Ping timeout: 252 seconds]
eizo has quit [Ping timeout: 240 seconds]
JokerDoom has joined #ocaml
octachron has quit [Quit: Page closed]
ggole has quit []
ebzzry has quit [Remote host closed the connection]
ebzzry has joined #ocaml
Kakadu has quit [Quit: Konversation terminated!]
rgrinberg has quit [Quit: Leaving.]
mort___ has joined #ocaml
rgrinberg has joined #ocaml
rgrinberg has quit [Quit: Leaving.]
tane has quit [Quit: Verlassend]
keen_____ has quit [Ping timeout: 240 seconds]
Arsenik has joined #ocaml
mort___ has quit [Quit: Leaving.]
keen_____ has joined #ocaml
WraithM has joined #ocaml
eikke__ has joined #ocaml
strobegen has quit [Quit: Leaving.]
mcclurmc has joined #ocaml
ollehar has quit [Ping timeout: 240 seconds]
ebzzry has quit [Ping timeout: 258 seconds]
ebzzry has joined #ocaml
tlockney_away is now known as tlockney
eikke__ has quit [Ping timeout: 252 seconds]
eikke__ has joined #ocaml
eikke__ has quit [Ping timeout: 252 seconds]
eikke__ has joined #ocaml
Arsenik has quit [Remote host closed the connection]
darkf has joined #ocaml
eikke__ has quit [Ping timeout: 240 seconds]
Smerdyakov has joined #ocaml
rand000 has quit [Quit: leaving]
tiglionabbit has joined #ocaml
rgrinberg has joined #ocaml
eikke__ has joined #ocaml
madroach has quit [Ping timeout: 252 seconds]
madroach has joined #ocaml
NoNNaN has quit [Remote host closed the connection]