<lewis1711>
a natively compiled functional object orientated language with a repl and C++ like speed. an advanced type system.
<lewis1711>
ok, not really object orientated. but blah it if C++ is called OOP by some people then so can ocaml:P
<banisterfiend>
haskell?
<mrvn>
lewis1711: ocaml has objects
<banisterfiend>
:P
<lewis1711>
yeah but it's not really object orientated
<lewis1711>
just because it has objects
<lewis1711>
by that logic C is a functional programming language because it has functions
Amorphous has quit [Ping timeout: 272 seconds]
<mrvn>
OOP is a programming style more than a language feature
<lewis1711>
I disagree.
<banisterfiend>
r u mine?
<mrvn>
lewis1711: no, it doesn't have functions as first order values
<banisterfiend>
y/n
<lewis1711>
in the context of this discussion, it's a language feature. languages have dominant paradigms
* NaCl
just realized the imparitive part of ocaml doesn't do what he wants
<NaCl>
*imparative
<lewis1711>
alright then, Python has first order functions. is that functional?
<banisterfiend>
lewis1711: y/n
<lewis1711>
NaCl: what do you want it to do?
<lewis1711>
banisterfiend: to what?
<banisterfiend>
r u mine?
<mrvn>
lewis1711: can it compose functions and return the result?
<NaCl>
lewis1711: trying to determine if a string is a palindrome
<lewis1711>
err
<lewis1711>
mrvn: can't remember
<NaCl>
got a 7-line python function that can do it
<banisterfiend>
lewis1711: y/n
<lewis1711>
NaCl: why does that need to be imperative
<lewis1711>
banisterfiend: fuck off:)
<NaCl>
it doesn't
<lewis1711>
I am pretty sure there's a string.reverse function
<NaCl>
I was trying to clone my python code before trying something "new"
<banisterfiend>
lewis1711: y/n
<thelema>
for i = 1 to (String.length s) / 2 do assert (s.[i] = s.[String.length s - i]); done
* NaCl
looks up what assert does
<lewis1711>
doesn't python have assert?!
<mrvn>
thelema: you forgot s.[0]
<NaCl>
assert in python throws an exception, IIRC
<banisterfiend>
lewis1711: y/n
<banisterfiend>
kfc
<NaCl>
assert is used for debugging, iirc
<banisterfiend>
colonel
<banisterfiend>
sanders
<mrvn>
assert is evil in that it halts the program
<banisterfiend>
kfc
<mrvn>
you better be damn sure it doesn't trigger
<NaCl>
yeah.
<lewis1711>
why doesn't ocaml have a String.rev function. it has one for lists:/
<NaCl>
Thus, since stuff in for() must return (), I can't evaluate boolean stuff in there without checking global variables or whatnot
<mrvn>
lewis1711: because strings are imperative.
<mrvn>
mutable
<lewis1711>
I see
<banisterfiend>
lewis1711: bbl, going to have kfc for lunch. talk later ok?
* NaCl
?1's
<NaCl>
?!'s
<lewis1711>
why would a functional language have mutable strings?:/
<NaCl>
and where I can I find non-mutalbe stings? :P
<mrvn>
lewis1711: and the ocaml upstream are reluctant to add usefull functions to their core lib to make the core modules ahave identical interfaces.
<mrvn>
lewis1711: because life without it is damn uncomfortable.
<mrvn>
NaCl: you can easily strip the string module of the mutable functions.
<lewis1711>
can't say I've ever felt the need for a mutable string
banisterfiend` has joined #ocaml
<NaCl>
I definitely don't need mutable strings for this
<mrvn>
lewis1711: never wanted to do random access on a string?
<lewis1711>
nope
<mrvn>
for i = 1 to (String.length s) / 2 do assert (s.[i] = s.[String.length s - i]); done?
<mrvn>
That sort of things doesn't work in O(1) with immutable strings. At least if you don't want other functions to be O(n).
<lewis1711>
btw NaCl: def is_palindrome (str); if str is reversed(str); return true; else; return false #I think that's shorter than 7 lines
<lewis1711>
5 lines, hooray
<NaCl>
reversed, eh
* NaCl
will look at that in a little bit
<NaCl>
I didn't look hard to determine if python had a string reversal function
banisterfiend`` has joined #ocaml
<banisterfiend``>
mrvn: C does have first order functions
<NaCl>
start from 0, and subtract 1 from String.length, yes
<NaCl>
mrvn: ^
<banisterfiend``>
mrvn: what's not first order about C functions?
banisterfiend has quit [Ping timeout: 272 seconds]
<mrvn>
banisterfiend``: it doesn't have functions as first class values.
<banisterfiend``>
mrvn: in what sense? you can pass them to functinos, return them from functions
<banisterfiend``>
store them in a variable
banisterfiend` has quit [Ping timeout: 255 seconds]
<lewis1711>
using pointers?:P
<banisterfiend``>
mrvn: int f(int blah) { puts("hello world"); } int (*v)(int) = f;
<mrvn>
banisterfiend``: you can pass along pointers and only with breaking an arm and a leg in the syntax. But you can't compose functions or have anonymous functions
<banisterfiend``>
v(10);
Amorphous has joined #ocaml
<banisterfiend``>
mrvn: it's nto an arm and a leg and the syntax isn't that bad. And you dont have to have anonymous functions to have first class functions
<lewis1711>
you could have first class functions in binary if you tried hard enough
<banisterfiend``>
mrvn: python gets along just find without real anonymous functions (no one really uses lambda)
<mrvn>
banisterfiend``: let as_float to_float from_float f x = from_float (f (to_float x))
<mrvn>
banisterfiend``: write me C code for that
<banisterfiend``>
mrvn: i dont care about the syntax
<banisterfiend``>
mrvn: syntax is irrelevant, the ponit is that C functions are first class
<NaCl>
lolz wut?
<lewis1711>
it's just sophistry anyway
<banisterfiend``>
it's not sophistry
<banisterfiend``>
C functions are first class, end of story
<mrvn>
banisterfiend``: nope
<lewis1711>
no they're not. pointers are. end of story;;
<NaCl>
does anyone care outside of academics? :P
<banisterfiend``>
mrvn: look up the definition of first class function on wikipedia, C meets that definnition
<banisterfiend``>
ah ok
<banisterfiend``>
i was wrong
<banisterfiend``>
:)
<mrvn>
banisterfiend``: "Specifically, this means that the language supports constructing new functions during the execution of a program, storing them in data structures, passing them as arguments to other functions, and returning them as the values of other functions."
<banisterfiend``>
to meet first-class-ness it must be able to create functions at runtime
<banisterfiend``>
admittedly C functions catn do that
<banisterfiend``>
yes
<banisterfiend``>
you're right
<banisterfiend``>
sorry
<mrvn>
banisterfiend``: C does not "supports constructing new functions during the execution of a program"
<banisterfiend``>
yes yes
<mrvn>
In C++ you can get around that with operator ()
<mrvn>
i.e. you can define a functional class and combine functional objects through that.
<mrvn>
but that is somewhat cheating. Not realy a first class function.
<thelema>
NaCl: just write string_rev -- let string_rev s = let ret = let ret = String.create (String.length s) s.[0] in for i = 1 to String.length s - 1 do ret.[String.length s - i] <- s.[i]; done; ret (or something like this without all the off-by-one errors, and handling "" properly
<NaCl>
thelema: ya, sure. thanges.
<thelema>
also, I don't know any languages where [if x then true else false] is not redundant
<hcarty>
gildor: I finally got a chance to watch the video of X. Leroy's talk from 2010's OCaml meeting. It was very interesting to watch - thank you very much for putting it together.
lewis1711 has left #ocaml []
opla2 has quit [Read error: Connection reset by peer]
boscop has joined #ocaml
infoe has joined #ocaml
boscop has quit [Ping timeout: 240 seconds]
<mrvn>
thelema: c++
<mrvn>
thelema: x in a boolean context can differ from x itself.
<mrvn>
thelema: there should be a String.init like there is Array.init
dskippy has joined #ocaml
<mrvn>
let string_rev s = let len = String.length s in String.init len (fun i -> s.[len - i - 1])
boscop has joined #ocaml
<mrvn>
or to_list/of_list: let string_rev s = of_list (List.rev (to_list s)) :)
<dskippy>
I have a newbie question. I can't figure out the syntax for getting my top-level module functions to be able to reference each other.
<mrvn>
let rec ... and ...
<dskippy>
I have two top-level functions I want to export. I want them both to reference the same helper.
<mrvn>
then just enter them in the right order
<dskippy>
let foo x = x and bar x = foo x ?
<mrvn>
no need for and
<mrvn>
# let foo x = x let bar x = foo x;;
<mrvn>
val foo : 'a -> 'a = <fun>
<mrvn>
val bar : 'a -> 'a = <fun>
<dskippy>
Oh but order is important.
<dskippy>
I need to put all of my helper functions at the top of the module. That's what I'm doing wrong.
<mrvn>
you can only use what you have defined already
boscop has quit [Ping timeout: 240 seconds]
<dskippy>
Yeah. I'm not used to the top level being order dependent.
boscop has joined #ocaml
<mrvn>
what else should it do?
<dskippy>
This is just not common in languages I've used.
<Axioplase_>
what languages have you used?
<dskippy>
Scheme and Haskell's top level functions reference each other regardless of the order.
<dskippy>
Axioplase_: I'm just talking about in modules.
<mrvn>
Haskell is strictly typed too isn't it?
boscop has quit [Read error: Connection reset by peer]
<dskippy>
I am used to writing top down.
<Axioplase_>
But yes, in Scheme, all top-level defines are turned in a big letrec
boscop has joined #ocaml
<dskippy>
mrvn: It is.
<Axioplase_>
(there are no modules in Scheme)
<mrvn>
and you can't type bar unless foo is already bound
<dskippy>
mrvn: In Haskell this would work too. "bar x = foo x \n foo x = x"
<dskippy>
Axioplase_: PLT-Scheme
<dskippy>
Axioplase_: Most scheme have their own module system. But R5RS, yes, does not have a module system.
<Axioplase_>
And haskell can do it because of the laziness: you don't need the code before you run it. So, if it types, it's ok.
<mrvn>
dskippy: and what does foo x = 1 \n bar x = foo x \n foo x = 2 do?
<Axioplase_>
mrvn: does not work, because of multiple declaration of foo.
<dskippy>
Axioplase_: Its not because of laziness. It works in Scheme as well. Because it's delayed behind function application.
<dskippy>
mrvn: It's just two top-level functions, one referencing the other. \n is my way to say newline in an IRC channel.
boscop_ has joined #ocaml
boscop has quit [Read error: Connection reset by peer]
<Axioplase_>
dskippy: Scheme turns everything in a letrec, that's why it works: all names are known.
<dskippy>
Look I'm not trying to start a language war here. Just saying, maybe languages. Python, Scheme, Haskell, Perl, allow for me to write two level functions out of order but still reference the later defined one.
<dskippy>
and that's what I'm used to.
<dskippy>
Axioplase_: Right.
<Axioplase_>
Haskell does it OK because of everything definition can be recursive without the need of a "rec" keyword.
<dskippy>
Axioplase_: I know why it works.
<Axioplase_>
OCaml distinguishes recursive from non-recursive, and therefore NEEDs definitions to be put in order for the scope to be valid.
<dskippy>
Axioplase_: mrvn ask when I said "I'm used to being able to do this" or something like that he asked "what else should it do" so I explained what other languages do.
<mrvn>
let bar x = foo x;; let foo x = x;; definetly can't work. Without the middle ;; it could but ocaml doesn't work that way.
<dskippy>
mrvn: No kidding. It doesn't work in Ocaml. That's fine.
<mrvn>
# let rec bar x = foo x and foo x = x;;
<mrvn>
val bar : 'a -> 'a = <fun>
<mrvn>
val foo : 'a -> 'a = <fun>
<mrvn>
if you really want to do it out of order
<dskippy>
Sure. I don't. I'll just put them in the order required. I was just confused by the order requirement because, I have said, I am used to other languages where there's not required. I think we're talking pasted each other here.
<Axioplase_>
well, you said "reference each other". If there's mutual recursion, you'll need let rec ... and ...
<dskippy>
Axioplase_: There's not.
<dskippy>
Axioplase_: I said that about top-level's in Scheme and Haskell. I didn't not mean to imply that it's necessary in my program.
<Axioplase_>
that's the first thing you said :)
<Axioplase_>
" I can't figure out the syntax for getting my top-level module functions to be able to reference each other"
<dskippy>
Sure I said that. Sorry.
<dskippy>
Didn't mean to imply that.
<dskippy>
Or say it.
<Axioplase_>
Anyway, it seems your problem is solved.
boscop_ has quit [Read error: Connection reset by peer]
* Axioplase_
goes back to a life with less procrastination
boscop_ has joined #ocaml
boscop_ has quit [Read error: Connection reset by peer]
boscop has joined #ocaml
boscop has quit [Ping timeout: 240 seconds]
boscop has joined #ocaml
dskippy1 has joined #ocaml
dskippy has quit [Read error: Connection reset by peer]
boscop has quit [Read error: Connection reset by peer]
boscop has joined #ocaml
boscop has quit [Ping timeout: 240 seconds]
boscop has joined #ocaml
boscop has quit [Read error: Connection reset by peer]
thatch_ has joined #ocaml
thatch_ has quit [Client Quit]
boscop has joined #ocaml
<dskippy1>
How can I start a REPL with the definitions of my module in File.ml in scope? Running "ocaml" gives me a REPL. "ocaml File.ml" seems to just syntax check my module.
<julm>
ocamlmktop
<dskippy1>
That will make an executable that I can run, right?
<julm>
or #use File.ml IIRC
<julm>
yup
<dskippy1>
Thanks.
<flux>
dskippy1, ocaml takes also -init or something
dskippy1 has left #ocaml []
edwin has joined #ocaml
almaisan-away is now known as al-maisan
Yoric has joined #ocaml
banisterfiend`` has quit [Ping timeout: 255 seconds]
<gildor>
hcarty: thanks for watching does the video arrangement ok for you (slides + windows for the speaker + speaker full screen from time to time)
ulfdoz has joined #ocaml
banisterfiend`` has joined #ocaml
itewsh has joined #ocaml
trch has joined #ocaml
trch has left #ocaml []
trch has joined #ocaml
Associat0r has left #ocaml []
boscop has quit [Read error: Connection reset by peer]
boscop has joined #ocaml
itewsh has quit [Quit: o/]
ulfdoz has quit [Ping timeout: 240 seconds]
shm has quit [Ping timeout: 264 seconds]
shm has joined #ocaml
ikaros has joined #ocaml
mattam has joined #ocaml
Yoric has quit [Read error: Operation timed out]
mnabil has quit [Ping timeout: 260 seconds]
Yoric has joined #ocaml
mnabil has joined #ocaml
rks has quit [Quit: foo]
rks has joined #ocaml
al-maisan is now known as almaisan-away
ikaros has quit [Quit: Leave the magic to Houdini]
edwin has quit [Read error: Connection reset by peer]
edwin has joined #ocaml
shm has quit [Ping timeout: 255 seconds]
shm has joined #ocaml
trch has left #ocaml []
LeNsTR has quit [Ping timeout: 240 seconds]
jm_ocaml has joined #ocaml
almaisan-away is now known as al-maisan
al-maisan is now known as almaisan-away
boscop has quit [Read error: Connection reset by peer]
notk0 has joined #ocaml
<notk0>
hello, doesn't 'a normally match any type?
<notk0>
wouldn't ((float * float * float * float * (float * float * float)) match a 'a?
<julm>
yup
<notk0>
julm, I get a The type constructor forme would escape its scope
<notk0>
error
<notk0>
and that it expect ('a*forme) and not float*float etc
<notk0>
expects*
<julm>
can't help without my seeing the code
<notk0>
julm, there is a lot and lots of code like lots and lots
<notk0>
julm, what is the usual reason for this error?
<julm>
where is forme defined? what kind of structure? a function? a local module?
<julm>
and what is its value
<notk0>
julm, I think I found the problem, it's related to linking
<notk0>
I Am sorry but ocaml sucks
* julm
can't agree more
<notk0>
julm, one quick question, two files disagree over an interface, how can I get more details?
<julm>
ocamlc -i ?
<adrien>
you have a module A and compile B and C which use functions from A
<adrien>
you've compiled B against A-version-1 and C against A-version-2
<adrien>
now you're trying to get B and C into the same executable, which version of A do you want?
<notk0>
adrien, I didn't compile anything yet, I am still using the top-level and #loading and stuff
<notk0>
well I did compile some stuff into cmas
<julm>
toplevel is evil
<julm>
quit and rerun it
<adrien>
notk0: well, *WHICH* files disagree over *WHICH* interface?
<notk0>
adrien an .cma disagrees with an cmi
<notk0>
with a* .cmi
<adrien>
names?
<notk0>
adrien, #load "objects.cma";;
<notk0>
The files objects.cma and objects.cmi disagree over interface Objects
<edwin>
how about the timestamps on objects.cma, objects.cmi and objects.ml, objects.mli?
<notk0>
I deleted them and compiled them one after another
<adrien>
rebuild .cmi and then rebuild .cma, in that order
<adrien>
you have a .mli I guess
jm_ocaml has quit [Ping timeout: 255 seconds]
<notk0>
yes I build a .cmi then a .cmo then the cma
jm_ocaml has joined #ocaml
<edwin>
you can run ocamlobjinfo on the .cmi, .cmo and .cma and see which one has a different hash for the Objects interface
<notk0>
do I need a cma file to compile? or cmo works?
<edwin>
you can #load a .cmo if thats what you want
<edwin>
also you can use ocamlbuild to build the files for you, just tell it the name and type of the main module, like ocamlbuild objects.cma, or ocamlbuild main.byte, ocamlbuild main.native to build executables
<edwin>
you'll find the built files in a _build directory
<notk0>
edwin, when building an excutable I don't need a #load right? I am trying to compile and I think I fail, I will try ocamlbuild
joelr has joined #ocaml
<joelr>
good day
<joelr>
any camlp4 experts here?
<edwin>
notk0: when you build an executable, you don't run it inside the toplevel, you run it from your shell
<edwin>
notk0: so no #load there
<notk0>
edwin, I know, when making a .cma do I pass it other .cma it depends upon or .cmos ?
<joelr>
npouillard: ping
<edwin>
notk0: ocamlbuild only needs 1 target, it will figure out its dependencies on its own
<edwin>
(and build/rebuild them as necessary)
<notk0>
edwin, what target does it need?
<edwin>
notk0: I think it can build anything that ocamlc/ocamlopt can. So if you tell it to build foo.byte it will create a bytecode executable called foo.byte, where the main module is in foo.ml
<edwin>
if you tell it to build foo.native it does the same but using ocamlopt to build a native module
<notk0>
edwin, I see let me try
<edwin>
foo.cmo builds the module from foo.ml
<edwin>
etc.
<notk0>
Exiting due to hygiene violations.
<notk0>
:(
<edwin>
if you want to put more than one module into a .cma you will need to create another file that lists which modules go into which cma
<edwin>
run _build/sanitize.sh
<hcarty>
gildor: Yes, I thought the arrangement of the video worked wonderfully. It made it easy to follow what was going on in the talk.
<edwin>
notk0: does it work now?
<npouillard>
joelr: pong (reading backlog)
<joelr>
npouillard: woohoo
<joelr>
npouillard: please check your mailbox
notk0 has quit [Ping timeout: 264 seconds]
asmanur_ has joined #ocaml
asmanur has quit [Ping timeout: 246 seconds]
notk0 has joined #ocaml
<notk0>
hello, how can I tell ocamlbuilt to use graphics.cma elsewhere?
<notk0>
build*
<adrien>
elsewhere?
<edwin>
you mean use the ocaml provided graphics.cma?
<notk0>
edwin, else, I get the following error No implementations provided for the following modules:
<notk0>
Graphics referenced from Main.cmx
<hcarty>
npouillard: The "OCaml history using Gource" video you put up looks quite cool
<npouillard>
hcarty: it was fun to watch indeed
<npouillard>
joelr: short answer (workaround), put more parenthesis (match (...) with ...)
<joelr>
npouillard: oh... hmm... is that a change from < 3.09?
<joelr>
from the old camlp4
<edwin>
notk0: create a tags file with this contents: <main.{byte,native}>: use_graphics
<edwin>
notk0: the tags file must be called _tags
<npouillard>
joelr: maybe
<joelr>
npouillard: and what is the longer answer?
<notk0>
edwin, I tried -lib and it seems to work for now
<npouillard>
joelr: this extension, extends the expr entry from its top
<notk0>
youpi!!!!!
<joelr>
npouillard: is that a problem?
<npouillard>
and the rule for match is something like "match"; sequence; "with"
<npouillard>
sequence being defined as sem_expr, which in turn use «expr LEVEL "top"»
<joelr>
npouillard: is it possible to fix this without adding extra parenthesis?
<npouillard>
Adding LEVEL "top" at the end of line 74 in swigp4 seems to fix the problem (hoping it does not creates others)
<npouillard>
hcarty: oh, there is zero-support for "module type of"?
joelr has quit [Quit: joelr]
<hcarty>
npouillard: It seems that way - it works without camlp4, but fails with it. I'm not sure if it's a complete lack of support, or a smaller bug somewhere.
<npouillard>
hcarty: after a second look it seems completely implemented, I rembember delaying waiting for other devs to pick it up
<hcarty>
npouillard: Is it a smaller bug then? Anything I can do to help test/isolate/fix it?
<npouillard>
oops I meant "completely UNimplemented"
<hcarty>
Ah, ok
<hcarty>
npouillard: Do you think there is any chance it will be implemented before 3.12.1?
<hcarty>
any reasonable chance, rahter
<hcarty>
rather
notk0 has quit [Ping timeout: 265 seconds]
<npouillard>
not with a patch quickly
notk0 has joined #ocaml
<hcarty>
Ok, thanks
mnabil has quit [Ping timeout: 265 seconds]
<notk0>
hello
<notk0>
inside a function let's say I have a let x=5; and I later need to redefine x if it meets a certain condition
<notk0>
ex if x>5 then let =5?
<adrien>
let x = if x > 5 then 42 else 0
<notk0>
do I have to use a reference?
<adrien>
but that's not redefine
<adrien>
that'd be a new: if you want to change the value, you have ot use a ref
<notk0>
adrien, I have to do it for 3 varaible then return them all
<notk0>
adrien, I see, only way to do it?
opla2 has joined #ocaml
<opla2>
how do i define a a list can contain subclasses of a given class?
<adrien>
notk0: if the variables are only in your function, you can use references or not, and the if...then...else is the only thing I can think
<adrien>
of
<adrien>
opla2: iirc you want to use ':>' to coerce back to the common ancestor
<opla2>
so : let myList : :> SomeType ?
<opla2>
?
<opla2>
let myList : :> SomeType = []
<opla2>
adrien, <-
<adrien>
no, for the elements you put in
<hcarty>
notk0: You could use pattern matching - let x, y, z = if ... then 1, 2, 3, else 4, 5, 6
<opla2>
adrian oh ok
opla2 is now known as Squarism
mnabil has joined #ocaml
<mrvn>
notk0: redefining is usualy better since references make the GC slower.
Smerdyakov has joined #ocaml
Squarism has quit [Ping timeout: 240 seconds]
drunK has joined #ocaml
notk0 has quit [Quit: bye bye]
init1 has joined #ocaml
opla2 has joined #ocaml
Pip has joined #ocaml
ygrek has joined #ocaml
ikaros has joined #ocaml
<jm_ocaml>
does anyone know what the state of oasis-db is? will it be ready to replace, say, GODI anytime soon?
WonTu has joined #ocaml
WonTu has left #ocaml []
<gildor>
jm_ocaml: oasis-db is still in alpha version
<gildor>
jm_ocaml: it won't completely replace GODI, esp. due to the fact that oasis-install will rely on external source for C libraries
<gildor>
jm_ocaml: e.g. GODI compiles and installs its C libraries (e.g. libpcre)
<Pip>
mattam, Hi
<gildor>
jm_ocaml: whereas oasis-install will need that you install the same C libraries using apt-get/yum/whatever is the current pkg manager on your distro
<gildor>
jm_ocaml: concerning the timeline, it will be ready for OCaml Meeting 2011 (i.e. April 2011) probably sooner if I don't encounter problem
<Pip>
mattam, Does this channel belong to a group named "OCaml" ?
<adrien>
s/whatever/yypkg\0/ =P
opla2 has quit [Ping timeout: 240 seconds]
<jm_ocaml>
gildor: Thanks, that's great news! Getting decent C libraries package is usually not an issue but an OCaml package manager (with up-to-date packages) would simplify my life tremendously!
<mrvn>
jm_ocaml: apt-get install debian
<gildor>
jm_ocaml: hope you'll be happy soon ;-)
<gildor>
mrvn: BTW, oasis will also improve Debian packaging for OCaml
<jm_ocaml>
mrvn: My linux system works just fine. I have no reason to switch to a completely different distribution. Also, I use OCaml on different machines with different OSs so a package manager just for OCaml would be really neat.
krktz has quit [Ping timeout: 250 seconds]
krktz has joined #ocaml
fraggle_ has quit [Ping timeout: 272 seconds]
fraggle_ has joined #ocaml
mattam has quit [Read error: Operation timed out]
fraggle_ has quit [Ping timeout: 240 seconds]
mattam has joined #ocaml
fraggle_ has joined #ocaml
banisterfiend`` has joined #ocaml
gildor has quit [Ping timeout: 246 seconds]
gildor has joined #ocaml
Pip has quit [Quit: It's not my problem.]
Pip has joined #ocaml
banisterfiend`` is now known as banisterfiend
Pip has quit [Quit: It's not my problem.]
Pip has joined #ocaml
Pip has quit [Changing host]
Pip has joined #ocaml
ftrvxmtrx has quit [Read error: Connection reset by peer]
smerz has joined #ocaml
ftrvxmtrx has joined #ocaml
mnabil_ has joined #ocaml
rks has quit [Quit: j're]
rks has joined #ocaml
ftrvxmtrx has quit [Quit: Leaving]
ftrvxmtrx has joined #ocaml
mnabil_ has quit [Ping timeout: 260 seconds]
coucou747 has joined #ocaml
edwin has quit [Remote host closed the connection]
init1 has quit [Quit: Quitte]
ygrek has quit [Ping timeout: 240 seconds]
Pip has left #ocaml []
asmanur_ has quit [Ping timeout: 276 seconds]
explodus has quit [Ping timeout: 276 seconds]
Yoric has quit [Quit: Yoric]
ikaros has quit [Quit: Leave the magic to Houdini]
Smerdyakov has quit [*.net *.split]
jm_ocaml has quit [*.net *.split]
shm has quit [*.net *.split]
mfp has quit [*.net *.split]
rixed has quit [*.net *.split]
nejimban has quit [*.net *.split]
hyperboreean has quit [*.net *.split]
Obfuscate has quit [*.net *.split]
srcerer has quit [*.net *.split]
mikemc has quit [*.net *.split]
mcclurmc has quit [*.net *.split]
mrvn has quit [*.net *.split]
svenl has quit [*.net *.split]
adrien has quit [*.net *.split]
jlouis has quit [*.net *.split]
krktz has quit [*.net *.split]
infoe has quit [*.net *.split]
Smerdyakov has joined #ocaml
jm_ocaml has joined #ocaml
shm has joined #ocaml
mfp has joined #ocaml
rixed has joined #ocaml
nejimban has joined #ocaml
mrvn has joined #ocaml
hyperboreean has joined #ocaml
Obfuscate has joined #ocaml
srcerer has joined #ocaml
mcclurmc has joined #ocaml
mikemc has joined #ocaml
svenl has joined #ocaml
adrien has joined #ocaml
jlouis has joined #ocaml
asmanur has joined #ocaml
krktz has joined #ocaml
infoe has joined #ocaml
srcerer has quit [Ping timeout: 240 seconds]
fraggle_ has quit [*.net *.split]
hto has quit [*.net *.split]
almaisan-away has quit [*.net *.split]
shachaf has quit [*.net *.split]
cods has quit [*.net *.split]
emias has quit [*.net *.split]
asmanur has quit [*.net *.split]
krktz has quit [*.net *.split]
infoe has quit [*.net *.split]
cods has joined #ocaml
hto has joined #ocaml
shachaf has joined #ocaml
emias has joined #ocaml
almaisan-away has joined #ocaml
asmanur has joined #ocaml
krktz has joined #ocaml
infoe has joined #ocaml
fraggle_ has joined #ocaml
Smerdyakov has quit [Quit: Leaving]
Pip has joined #ocaml
fraggle_ has quit [*.net *.split]
jm_ocaml has quit [*.net *.split]
shm has quit [*.net *.split]
mfp has quit [*.net *.split]
rixed has quit [*.net *.split]
nejimban has quit [*.net *.split]
hyperboreean has quit [*.net *.split]
Obfuscate has quit [*.net *.split]
mikemc has quit [*.net *.split]
mcclurmc has quit [*.net *.split]
mrvn has quit [*.net *.split]
svenl has quit [*.net *.split]
adrien has quit [*.net *.split]
jlouis has quit [*.net *.split]
emias has quit [*.net *.split]
coucou747 has quit [*.net *.split]
rks has quit [*.net *.split]
joewilliams_away has quit [*.net *.split]
theDroggl has quit [*.net *.split]
fraggle_ has joined #ocaml
emias has joined #ocaml
theDroggl has joined #ocaml
joewilliams_away has joined #ocaml
rks has joined #ocaml
coucou747 has joined #ocaml
jm_ocaml has joined #ocaml
shm has joined #ocaml
mfp has joined #ocaml
rixed has joined #ocaml
nejimban has joined #ocaml
mrvn has joined #ocaml
hyperboreean has joined #ocaml
Obfuscate has joined #ocaml
mcclurmc has joined #ocaml
mikemc has joined #ocaml
svenl has joined #ocaml
adrien has joined #ocaml
jlouis has joined #ocaml
explodus has joined #ocaml
joewilliams_away is now known as joewilliams
smerz has quit [Quit: Ex-Chat]
joewilliams is now known as joewilliams_away
jm_ocaml has quit [Remote host closed the connection]