marmotine has quit [kornbluth.freenode.net irc.freenode.net]
ulfdoz has quit [kornbluth.freenode.net irc.freenode.net]
marmotine has joined #ocaml
johnnowak has left #ocaml []
ulfdoz has joined #ocaml
Camarade_Tux has quit [""sleep""]
psnively has joined #ocaml
vixey has quit [Network is unreachable]
vovkaii has quit [Read error: 110 (Connection timed out)]
loufoque has quit [Remote closed the connection]
<middayc>
a newbie question.. how do I compare two strings for equality? String.compare seems to be for it but I don't get the whole thing with String.t (t being alias of string)?
<Yoric[DT]>
String.t is the same thing as string.
<middayc>
but I get this error: "This expression has type string -> string list but is here used with type String.t list"
<Yoric[DT]>
The alias is just for uniformity: while string is a built-in type, the convention is that, if you create a new type, rather than calling it [my_new_type], you should create a module [My_new_type] and call your type [My_new_type.t].
<Yoric[DT]>
Well, the problem is that you have two strings on the left side, only one on the right side.
<middayc>
aha, so it's not the problem in String.t .. thanks!
<Yoric[DT]>
My pleasure.
ikaros has joined #ocaml
ikaros_ has joined #ocaml
ikaros_ has quit [Read error: 104 (Connection reset by peer)]
ikaros has quit [Read error: 54 (Connection reset by peer)]
ikaros has joined #ocaml
ikaros has quit [Read error: 104 (Connection reset by peer)]
ikaros has joined #ocaml
ikaros has quit [".quit"]
seafood has joined #ocaml
_jedai_ has quit [Read error: 110 (Connection timed out)]
ikaros has joined #ocaml
|jedai| has joined #ocaml
psnively has quit []
marmotine has quit ["mv marmotine Laurie"]
ofaurax has quit ["Leaving"]
Yoric[DT] has quit ["Ex-Chat"]
ikaros has quit [".quit"]
ikaros has joined #ocaml
ikaros has quit [".quit"]
schme has quit ["leaving"]
schme has joined #ocaml
ched has quit [Remote closed the connection]
seafood has quit []
brendan has joined #ocaml
prime2 has joined #ocaml
Associat0r has quit []
jeddhaberstro has joined #ocaml
jeddhaberstro has quit [Client Quit]
psnively has joined #ocaml
seafood has joined #ocaml
<middayc>
where did the coThreads website disappear?
schmx has joined #ocaml
tab_ has quit [Read error: 104 (Connection reset by peer)]
schme has quit [Read error: 60 (Operation timed out)]
pango has quit [Remote closed the connection]
prime2 has quit [Read error: 110 (Connection timed out)]
tab has joined #ocaml
|jedai| has quit [Read error: 145 (Connection timed out)]
|jedai| has joined #ocaml
middayc has quit [Read error: 110 (Connection timed out)]
psnively has quit []
jlouis has quit [Remote closed the connection]
orbitz has left #ocaml []
middayc has joined #ocaml
|jeremiah has quit [Read error: 104 (Connection reset by peer)]
<middayc>
I fell down
<mjonsson>
what tool/library would you guys recommend for writing a parser?
alexyk has joined #ocaml
schmx has quit ["leaving"]
|jeremiah has joined #ocaml
middayc has left #ocaml []
<mrvn>
mjonsson: the lex/yacc equivalent one from the manual
schme has joined #ocaml
schme has quit [Client Quit]
<mjonsson>
mrvn, thanks
schme has joined #ocaml
alexyk has quit []
_jedai_ has joined #ocaml
|jedai| has quit [Read error: 110 (Connection timed out)]
munificent has joined #ocaml
munificent has left #ocaml []
alexyk has joined #ocaml
alexyk has quit []
_jedai_ has quit [Read error: 110 (Connection timed out)]
|jedai| has joined #ocaml
bohanlon has joined #ocaml
_zack has joined #ocaml
_jedai_ has joined #ocaml
|jedai| has quit [Read error: 110 (Connection timed out)]
_jedai_ has quit [Read error: 60 (Operation timed out)]
|jedai| has joined #ocaml
alexyk has joined #ocaml
alexyk has quit []
|jedai| has quit [Read error: 60 (Operation timed out)]
|jedai| has joined #ocaml
caligula_ has joined #ocaml
alexyk has joined #ocaml
caligula__ has quit [Read error: 113 (No route to host)]
|jeremiah has quit [Read error: 104 (Connection reset by peer)]
Snark has joined #ocaml
_zack has quit ["Leaving."]
bohanlon has quit [Remote closed the connection]
bohanlon` has joined #ocaml
|jeremiah has joined #ocaml
Camarade_Tux has joined #ocaml
|jeremiah has quit [Read error: 104 (Connection reset by peer)]
|jedai| has quit [Connection timed out]
pango has joined #ocaml
|jedai| has joined #ocaml
|jeremiah has joined #ocaml
|jeremiah has quit [Read error: 104 (Connection reset by peer)]
|jeremiah has joined #ocaml
|jeremiah has quit [Read error: 104 (Connection reset by peer)]
alexyk has quit []
|jeremiah has joined #ocaml
comglz has joined #ocaml
|jedai| has quit [Connection timed out]
|jedai| has joined #ocaml
alexyk has joined #ocaml
alexyk has quit [Client Quit]
jlouis has joined #ocaml
marmotine has joined #ocaml
<flux>
mjonsson, btw, if you get a feeling that ocamlyacc is missing some nice features, take a look at menhir. it's backwards compatible.
tab has quit [Remote closed the connection]
tab has joined #ocaml
Maghnus has joined #ocaml
|jedai| has quit [Read error: 110 (Connection timed out)]
|jedai| has joined #ocaml
<mrvn>
flux: I always found it difficult to write a parser for the rfc822 style Packages/Sources files from Debian. You can't define "Version" as a token because it might also appear in the Description text unless you allow the value part of each pair to also contain key tokens. That always seemed totaly ugly.
<mrvn>
Does menhir need seperate tokenizer and parser steps too?
ched has joined #ocaml
<flux>
yes
<flux>
packrat parsers don't need separate steps
<flux>
aurochs is one such parser library
<mrvn>
I would love one that can use literal strings instead of tokens as in "Package" ":" STRING: { package = $3; }
<flux>
well, I think 'P' 'a' 'c' 'k' 'a' 'g' 'e' might work? however, it will result in huge parsers
<flux>
possibly they might not even go through if there are some built-in limits
<flux>
check out aurochs. you might want to read the white paper on packrat parsers before actually using it, though.
<flux>
unfortunately its error messages were less than helpful last time I used it
<det>
Can the tokenizer match beginning of line ?
ikaros has joined #ocaml
<det>
Then tokenizing rfc822 becomes easy
<mrvn>
det: That would be another solution to that porblem.
<mrvn>
One could match "\n...." except for the first line
<flux>
you could use your own tokenizer if you wanted
<mrvn>
yeah. The default lexer can't match to begining of line, right?
<flux>
I don't think so
<flux>
it might be possible to use your lexer in combination with ocamllex lexer..
<mrvn>
could it do "Package" when start_of_line, like match foo with bla when start_of_line?
<flux>
I don't think that kind of syntax is supported
<det>
pcre can do it, at least
Waleee has joined #ocaml
_jedai_ has joined #ocaml
|jedai| has quit [Read error: 110 (Connection timed out)]
fschwidom has joined #ocaml
seafood has quit []
seafood has joined #ocaml
_jedai_ has quit [Read error: 60 (Operation timed out)]
|jedai| has joined #ocaml
vixey has joined #ocaml
<det>
Findlib is annoying how the META is different all over the place :<
<det>
lablgtk, for instance
<det>
Debian/GODI/Gentoo
<det>
All vary in whether or not they link gtkInit and gtkThread
<det>
So now, thanks to findlib trying to do thing automatically, I have to write a configure script to detect what is being "helpfully" linked and adjust my Makefile accordingly :<
seafood_ has joined #ocaml
Anarchos has joined #ocaml
<det>
Oh yeah, and camlzip is called zip on debian
<det>
and camlzip everywhere else
seafood has quit [Read error: 110 (Connection timed out)]
|jeremiah has quit [Read error: 104 (Connection reset by peer)]
|jedai| has quit [Read error: 60 (Operation timed out)]
comglz has quit [Read error: 110 (Connection timed out)]
<olegfink>
what would be the appropriate source for some ocaml fun?
<olegfink>
official cvs, thelema's ocaml-community or something else that I'm not aware of?
<tsuyoshi>
seems like a lot of ocaml users hate oop
<tsuyoshi>
kind of ironic, considering the "o"
itewsh has joined #ocaml
* maskd
doesn't hate oop
<Yoric[DT]>
olegfink: what do you mean, "some ocaml fun"?
<flux>
oop in ocaml is nice. it does make it a little bit more involved to find the source for a method, though, unless you've used a certain naming convention.
smimou has quit ["bli"]
<flux>
also it would be nice if the performance hit was less
smimou has joined #ocaml
<olegfink>
Yoric[DT]: as if I knew. I'd like to check some ideas about byterun, so for the moment I just need the latest and greatest(tm) sources with the ability to track changes
<Yoric[DT]>
Well, for most things, OOP doesn't add much to OCaml.
<Yoric[DT]>
olegfink: For the moment, thelema's ocaml-community tracks the official CVS.
<Yoric[DT]>
But he's probably more willing to accept patches.
<Yoric[DT]>
(atm the main difference is the library)
<flux>
yoric[dt], it adds the capability to not spell out the type of a variable you're dealing with all the time, like FooMap.find a, FooMap.add etc :)
<Yoric[DT]>
flux: :)
<Yoric[DT]>
Sure, it's nice.
<Yoric[DT]>
But that's no killer feature.
<olegfink>
Yoric[DT]: so it's 'backwards'-compatible with inria sources?
<tsuyoshi>
it seems to me that with any language with first class functions, oop is less necessary
<Yoric[DT]>
olegfink: should be.
<Yoric[DT]>
flux: I mean, IOClasses are a nice feature to have.
<olegfink>
aha, so I should prefer it to ocaml.git, thanks.
<tsuyoshi>
but I think ocamlers seem to hate oop more than, say, haskellers or lispers
<flux>
I'm not sure if that assesment is correct for haskellers
<Yoric[DT]>
flux: but besides IOClasses (which are not so widely used, I believe) and probably some UI toolkit, the OCaml community doesn't seem to need OOP.
<Yoric[DT]>
Well, the Haskell version of OOP is essentially a very complex encoding of objects.
<Yoric[DT]>
I'm not sure it's that used.
<Yoric[DT]>
(I believe it's based on HList, which is a bad start)
<Yoric[DT]>
(at least for performances)
<tsuyoshi>
I don't really have any experience with haskell but as I understood it they didn't really have objects
<Yoric[DT]>
No, they don't.
<Yoric[DT]>
They encode extendable polymorphic records using type-level lists.
<Yoric[DT]>
And I believe they build objects on top of extendable polymorphic records.
<Yoric[DT]>
I haven't seen the resulting syntax or types, but I doubt it's nice.
<tsuyoshi>
I wonder if.. ocaml users, when they are trying out the language at first, try to use objects, but they run into the issue with no automatic subtyping
<flux>
yeah, ocaml's problem with oop is that it's an advanced topic, IMO
<tsuyoshi>
and then they either stop using ocaml, or they develop an aversion to objects (or already had one)
<flux>
but it is quite poerful in any case
<Yoric[DT]>
It's quite powerful. But since OCaml already has structures, modules and functors, it's often difficult to convince oneself that it does add something.
<Yoric[DT]>
By opposition to OO languages, OCaml doesn't force you to use objects, so you often find something smaller/nicer to implement whatever you need to implement.
<flux>
yet at times people ask for first-class modules ;)
<Yoric[DT]>
:)
<Yoric[DT]>
And once in a while, you realize that you should have used objects because your solution ends up being unextendable and you're screwed.
smimou has quit ["bli"]
<flux>
I prefer to use objects over records of functions. most of the time passing just one or two functions is all you need, though, and then I use neither
<tsuyoshi>
but it's funny because they renamed it "objective caml" and yet objects are not used very much
<det>
I like Haskell type-classes more than Ocaml objects
<Yoric[DT]>
det: for most purposes, so do I.
<Yoric[DT]>
However, I have the impression that Haskell type-classes don't add any feature to the language, while objects do.
<Yoric[DT]>
(i.e. overloading and "this")
<Yoric[DT]>
Oh, and structural subtyping.
<maskd>
i'm writing a particle simulator with objects. it seems easier than using record types
<det>
It is easier, yeah
<det>
but Ocaml doesnt do a whole lot to try to optimize them
<det>
It's not like C++ where a known type will be a known function call
<det>
object#foo will _always_ have to dispatch
<maskd>
that's unfortunate
* vixey
tries to understand what that dalton program is about
<tsuyoshi>
hmm.. that's fixable though
<tsuyoshi>
well, there are a lot of things you could do to get the compiler to emit faster code
seafood_ has quit []
<tsuyoshi>
method dispatch wouldn't be my first choice of things to work on
<det>
Yoric[DT], I dont understand what you mean about objects adding language features, but type classes not
|jeremiah has quit [Read error: 104 (Connection reset by peer)]
<det>
Using the object system, I dont think it is possible to write a function that takes an arbitrary numeric and adds it to itself.
<det>
Well, you can, but it is so ugly compared to type classes
<Smerdyakov>
Like I always say, if you really care about performance, you should be using SML instead.
<vixey>
det, yeah I was saying yesterday, typeclasses are purely cosmetic -- this is the only reason they are popular, rather that being useful they just look pretty
<det>
Would be so much cleaner in Haskell, with type classes
<Smerdyakov>
vixey, not true. The automatic resolution is more than cosmetic.
|jeremiah has joined #ocaml
<Smerdyakov>
Does anyone have a pointer to WWW documentation of the [Obj] module?
<det>
Yeah, type classes are a lot more than cosmetic.
<vixey>
det, because they let you write + instead of +., or do ... instead of do Error ...?
<det>
You can call "show x" on any value in any part of your source.
<vixey>
writing show x instead of showFloat x is something I consider cosmetic
<det>
but
<flux>
vixey, except your code can be polymorphic on x
<det>
waht flux said
_jedai_ has joined #ocaml
<Yoric[DT]>
det: my point is that type-classes make programs cleaner but *I believe* that's nothing you can't do without type-classes just by adding arguments.
<Yoric[DT]>
I *believe* you can do more with objects.
<Yoric[DT]>
Again, just a gut feeling.
<det>
Oh sure, you can always just pass functions around. Point of type-classes is that they do it implicitly.
<det>
Also, you get default implementations.
|jedai| has quit [Read error: 110 (Connection timed out)]
<det>
I dont see objects being any more powerful.
<det>
by default implementations, I mean, just defining "read_char" on your type, and getting read_line for free, but having the option defining your own more efficient read_line instead using the default. This is much like inheritance using objects.
<maxote>
i want the next generation of OCaml of dynamic-style, Oberon2-like.
<maxote>
/of /of less /
<det>
How do I get ghci to show me the type of a value
<det>
I am a Haskell newb
<Smerdyakov>
maxote, what do you mean?
<Smerdyakov>
det, ":t"?
<maxote>
i think there is a overload of dynamically typed objects
<Yoric[DT]>
I'm currently on a type system which hopefully should be a tad nicer than type classes, though :)
<Yoric[DT]>
Well, type+dispatch system, that is.
<det>
Yoric[DT], "currently working", you mean?
<Yoric[DT]>
Yep.
<Yoric[DT]>
Gottago, though.
<det>
Ok, ttyl!
<det>
Smerdyakov, Problem with SML is MLton isnt developed anymore.
<Smerdyakov>
The kinds of basic optimizations that OCaml lacks are easy to implement, so you can always create a new implementation!
<det>
Yes, ML world really needs a bazaar-style developed implementation of a language.
<det>
MLton was too tied to "The definition of Standard ML"
<det>
and Ocaml is too tied to Inria
<Anarchos>
why am i not able to debug a .a library created by ocamlopt.opt, with all debug options set on ?
ikaros has quit [Remote closed the connection]
ikaros has joined #ocaml
ikaros has quit [Remote closed the connection]
Associat0r has joined #ocaml
behemoth has joined #ocaml
jlouis has quit [Remote closed the connection]
smimou has joined #ocaml
vixey has quit [Remote closed the connection]
Anarchos has quit ["Vision[0.8.5-0418]: i've been blurred!"]
|jedai| has joined #ocaml
_jedai_ has quit [Read error: 110 (Connection timed out)]
pango has quit [Remote closed the connection]
pango has joined #ocaml
|jedai| has quit [Read error: 60 (Operation timed out)]
|jedai| has joined #ocaml
middayc has joined #ocaml
iwannalog has joined #ocaml
iwannalog has left #ocaml []
smimou has quit ["bli"]
middayc has quit [Read error: 60 (Operation timed out)]
|jedai| has quit [Read error: 60 (Operation timed out)]
middayc has joined #ocaml
|jedai| has joined #ocaml
<middayc>
I fell down, don't know if my text got here?ž
<maskd>
it didn't
<maskd>
Smerdyakov: do you know why these optimizations haven't been implemented in ocaml yet?
<Smerdyakov>
maskd, because there is no incentive for the people in charge to do so.
<Smerdyakov>
Or, rather, not enough incentive
<Smerdyakov>
middayc, I saw no text from you prior to "I fell down."
<middayc>
ok, thanks
<middayc>
hm.. I realized my question is more related to linux in general than OCaml..
<Smerdyakov>
Does anyone want to help test if the new Ynot release is basically working? http://ynot.cs.harvard.edu/
<Smerdyakov>
(Please don't distribute that URL yet; hopefully I'll make an official release announcement later today.)
* Yoric[DT]
is working on something important atm, I'm afraid.
smimou has joined #ocaml
ygrek has joined #ocaml
pango has quit [Remote closed the connection]
ygrek_ has joined #ocaml
_zack has joined #ocaml
pango has joined #ocaml
_jedai_ has joined #ocaml
|jedai| has quit [Read error: 110 (Connection timed out)]
ygrek has quit [Remote closed the connection]
pango has quit [Remote closed the connection]
_zack has quit ["Leaving."]
<middayc>
I am making a word stemmer in ocaml. Now I need it to talk ( accept text -> return stemmed text) to other processes on same machine (one is php front, other rebol crawler) ..
<middayc>
what would be the best way to achieve this, should I just make a tcp server that does this or is it better to use some other mechanism for interproc communication
<Smerdyakov>
middayc, why not use pipes, just like shell scripts do?
<middayc>
pipes, I saw some usage of this in command shell, but I am more a newbie linux user.. I will google to find out more about pipes (I looked at message queues a little)
<middayc>
I don't know if this is important but ocaml process in my case should start, load all data and run while communicating to othe processes without restarting
<middayc>
I remember this, I was exploring ocaml a while back and I saw it. Yes it looks very interesting.. are you making Ur?
<middayc>
otherwise I am using php at this project just for simple few page frontend to search engine
pango has joined #ocaml
<Smerdyakov>
Yes, I'm the author.
fschwidom has quit [Remote closed the connection]
ikaros has joined #ocaml
<middayc>
I was reading the pdf, looks quite advanced language vise, although the examples looked more understandable to me
ikaros has quit [".quit"]
ikaros has joined #ocaml
<flux>
ullman sets don't appear to be all that useful in context of ocaml, where an array cannot be allocated without initializing it
<Smerdyakov>
flux, then, whatever they are, they must be interesting only because of performance?
<flux>
indeed
ikaros has quit [".quit"]
<flux>
and it's a mutable data structure
ikaros has joined #ocaml
<flux>
assuming allocation takes no time and arrays can be allocated without initializing the elements, constructing and clearing them and adding, removing and testing for membership are constant time
_jedai_ has quit [Read error: 110 (Connection timed out)]
<middayc>
Smerdyakov: thanks for the pipes hint, I see not that they are very simple vay of achieving simple communication
|jedai| has joined #ocaml
<flux>
fun how the simplest typo can totally reverse the meaning of a sentence.. ;)
<middayc>
ups not = now :)
_zack has joined #ocaml
<flux>
I imagine it should be well possible to implement an Array module with uninitialized values without undue performance hit
<flux>
but then again the places where that would help would be small
<Smerdyakov>
flux, how would you do it _safely_?
jeddhaberstro has joined #ocaml
<flux>
smerdyakov, well, disregarding the possible issues with gc, it would grow (using a configured value) to the predetermined size whenever an element beyond the current actual size was accessed
<flux>
the issues with gc might be difficult to overcome though
<Smerdyakov>
flux, so you assume initialization happens in a fixed order?
jlouis has joined #ocaml
<flux>
it would happen in that case
<flux>
so if you set element at index 5, it would initialize elements [0..4] prior to assignment
_zack has quit ["Leaving."]
<olegfink>
what use is byterun/terminfo.c and what will I face in case I remove it?
vixey has joined #ocaml
|jedai| has quit [Read error: 110 (Connection timed out)]
|jedai| has joined #ocaml
<middayc>
if I remember corretly some functions in Unix module work on windows too.. is it documented anywhere which ones do and which don't ?
<Yoric[DT]>
middayc: yes, it's in the official documentation.
<Yoric[DT]>
Smerdyakov: if I understand correctly, you've implemented a few type systems.
<Smerdyakov>
Yoric[DT], yes.
<Yoric[DT]>
Do you use a constraint solver>
<Yoric[DT]>
Do you use a constraint solver?
<Yoric[DT]>
Or hand-coded unification?
<Smerdyakov>
Yoric[DT], the latter.
<Yoric[DT]>
ok
<Yoric[DT]>
Do you have any library you would consider handy for that task (in OCaml)?
* Yoric[DT]
has always used unification so far but would like the process to be a tad less painful.
<Smerdyakov>
I've never even heard of a library for this.
<Yoric[DT]>
ok
<Smerdyakov>
It would be really hard to do efficiently in OCaml.
<vixey>
what are you planning on Yoric?
<Yoric[DT]>
Well, I'm toying with a type system for OCaml.
<Yoric[DT]>
s/for OCaml/for ML/
<vixey>
and different in some way?
<vixey>
to what ocaml already has
<Yoric[DT]>
Simpler, more precise and an overloading mechanism.
<Yoric[DT]>
(downside: I'm pretty sure that there's no principal typing or that, if there's one, we don't want to see it)
itewsh has quit [Read error: 110 (Connection timed out)]
<vixey>
have you been following recent developments in haskell?
itewsh has joined #ocaml
<Yoric[DT]>
Now, it's quite early in the design, so I just wanted to toy with it before attempting formal proofs.
<Yoric[DT]>
vixey: some of them.
<Yoric[DT]>
Which one do you mean, in particular?
comglz_ has quit [Client Quit]
<vixey>
Yoric[DT], on second thoughts, most of these things probably don't make much sense for ocaml
<vixey>
(most useful things that come to mind were GADTs and FPH)
|jedai| has quit [Read error: 110 (Connection timed out)]
<Yoric[DT]>
I need to check but I believe GADTs don't apply to the language I have in mind.
|jedai| has joined #ocaml
<Smerdyakov>
Yoric[DT], by "don't apply," do you mean "can't be encoded"?
<vixey>
it seems like a terrible mistake to not support GADTs in any ML like language to me
<Yoric[DT]>
More like "have a very large intersection with other features".
<vixey>
maybe there is some problems they bring along with them that I don't know about though
<Smerdyakov>
I don't know. It's not obvious to me that using Coq (or a successor) in such cases isn't the right move.
<Yoric[DT]>
I believe that the usual examples of GADTs I have in mind can easily be encoded with the type system I have on paper.
<Yoric[DT]>
So I guess we could say that type system "has GADT".
<Yoric[DT]>
This needs to be checked properly, of course.
<vixey>
usual examples of GADTs aren't useful
<Yoric[DT]>
Fair enough.
<vixey>
(if you mean well type interpreter for some boring language)
<Yoric[DT]>
Yeah, well :)
<vixey>
but you can do generic programming with them, it's just awkward without proper computation in types, and having them closed is a shame too
|jedai| has quit [Connection timed out]
zerny has joined #ocaml
<zerny>
Hi, does anybody know if there is support for OCaml in CMake somewhere?
|jedai| has joined #ocaml
<Yoric[DT]>
I believe there's support for C in OMake, does this count ? :)
<zerny>
Yoric[DT]: Sorry, not really. I am trying to extend an existing system (using CMake) with OCaml, so I can't just change the active build system :(
<zerny>
A few lists contain some discussion on OCaml and CMake, but nothing seems to be implemented.
<zerny>
Well, I will give it a jab myself.
<Yoric[DT]>
Good luck.
<zerny>
i.e. try extending CMake with *simple* OCaml support
<zerny>
Yoric[DT]: thanks
<det>
Yoric[DT], what is your extension to type-classes ?
<zerny>
Does anybody know where OCaml's default installation path is on windows?
<middayc>
I have it installed on c:\Program Files\Objective Caml\
<middayc>
but I don't remember if it was default
<zerny>
middayc: thanks, I will add that for now.
behemoth_ has joined #ocaml
<hcarty>
zerny: I wrote OCaml bindings for PLplot, and PLplot uses CMake as its build system
<hcarty>
I did not write the CMake integration though, and I think it is rather hackish at the moment
<Yoric[DT]>
det: I'm not going to say more until I've checked that it actually works :)
<hcarty>
Or so I have been told
<zerny>
hcarty: ok, I would be more than glad to hear your approach? Right now I am creating versions of all the CMakeDetermineOCamlCompiler.cmake and related scripts
<Yoric[DT]>
det: but essentially, it's just a different overload/late binding mechanism
<zerny>
middayc: hmm, I have an example script here that reads out the path from a windows registry key. Do you think you could find the path you mentioned through the registry?
<hcarty>
zerny: Please let me know what you come up with! If it's a better approach then the PLplot devs would be quite interested
<zerny>
hcarty: sure thing :)
purple_ has joined #ocaml
behemoth has quit [Read error: 110 (Connection timed out)]
middayc has left #ocaml []
alexyk has joined #ocaml
ched has quit [Remote closed the connection]
<det>
Yoric[DT], maybe if you said it outloud someone might tell you why it can or cannot work :-)
<Yoric[DT]>
Let me check a little further first.
ched has joined #ocaml
_jedai_ has joined #ocaml
|jedai| has quit [Read error: 110 (Connection timed out)]
seafood has joined #ocaml
alexyk has quit []
sporkmonger has quit []
jeddhaberstro_ has joined #ocaml
_jedai_ has quit [Read error: 60 (Operation timed out)]
|jedai| has joined #ocaml
vovkaii has joined #ocaml
jeddhaberstro has quit [Read error: 110 (Connection timed out)]
Snark has quit [Read error: 113 (No route to host)]
seafood has quit []
_zack has joined #ocaml
ygrek_ has quit [Remote closed the connection]
middayc has joined #ocaml
_zack has quit ["Leaving."]
ikaros_ has joined #ocaml
ikaros has quit [".quit"]
ikaros_ is now known as ikaros
vixey has quit [Remote closed the connection]
seafood has joined #ocaml
itewsh has quit ["There are only 10 kinds of people: those who understand binary and those who don't"]
zerny has quit [Remote closed the connection]
marmotine has quit ["mv marmotine Laurie"]
_zack has joined #ocaml
silentbicycle has joined #ocaml
_zack has quit [Client Quit]
_zack has joined #ocaml
_zack1 has joined #ocaml
schme_ has joined #ocaml
fschwidom has joined #ocaml
Jedai has quit [Read error: 110 (Connection timed out)]
Jedai has joined #ocaml
_jedai_ has joined #ocaml
|jedai| has quit [Read error: 110 (Connection timed out)]
_zack1 has quit ["Leaving."]
schme has quit [Read error: 145 (Connection timed out)]
_zack has quit [Read error: 110 (Connection timed out)]
_jedai_ has quit [Read error: 60 (Operation timed out)]
|jedai| has joined #ocaml
ikaros has quit [".quit"]
Waleee has quit [Read error: 104 (Connection reset by peer)]
ched has quit [Remote closed the connection]
_zack has joined #ocaml
<brendan>
anyone know if extlib is still being developed? I've just discovered that the nsplit implementation doesn't scale (not tail-recursive, produces lots of string objects for the GC) and wonder if it's worth trying to get a fix upstream
<brendan>
ExtString.nsplit, that is
<brendan>
the mailing list archive seems to be nothing but spam for several months
<mfp>
brendan: the development of extlib sort of continues --- within Batteries
Amorphous has quit [Read error: 110 (Connection timed out)]
_zack has quit ["Leaving."]
<mfp>
brendan: rwmjones should be able to give you a better answer (he's an extlib devel IIRC)
_jedai_ has joined #ocaml
Amorphous has joined #ocaml
|jedai| has quit [Read error: 110 (Connection timed out)]
<brendan>
ok, I'll look into batteries, thanks
<Yoric[DT]>
brendan: feel free to submit a feature request.
<brendan>
will do
<brendan>
looks like batteries has the same nsplit