adrien changed the topic of #ocaml to: Discussions about the OCaml programming language | http://caml.inria.fr/ | OCaml 4.00.1 http://bit.ly/UHeZyT | http://www.ocaml-lang.org | Public logs at http://tunes.org/~nef/logs/ocaml/
ulfdoz_ has joined #ocaml
BiDOrD_ has joined #ocaml
BiDOrD has quit [Ping timeout: 245 seconds]
ulfdoz has quit [Ping timeout: 255 seconds]
ulfdoz_ is now known as ulfdoz
zip has joined #ocaml
lolcathost has quit [Quit: leaving]
lolcathost has joined #ocaml
lolcathost has quit [Ping timeout: 244 seconds]
eikke has quit [Ping timeout: 244 seconds]
madroach has quit [Ping timeout: 244 seconds]
lolcathost has joined #ocaml
madroach has joined #ocaml
<lolcathost> What Emacs package would you recommend for OCaml programming?
lorilan has joined #ocaml
<lorilan> hello !
<lorilan> i need some help to compile js_of_ocaml
<lorilan> i've been one it since 2 hours
<lorilan> it says
<lorilan> Files /usr/lib/ocaml/findlib/findlib.cmxa and /usr/lib/ocaml/stdlib.cmxa make inconsistent assumptions over implementation Filename
<lorilan> but i've just reinstalled findlib using my package manager
<lorilan> and I don't know where this Filename come from ...
<lorilan> please help ?
lorilan has quit [Remote host closed the connection]
lorilan has joined #ocaml
Yoric has joined #ocaml
Yoric has quit [Ping timeout: 252 seconds]
myx has joined #ocaml
leoncamel has quit [Quit: WeeChat 0.3.9.2]
milosn has quit [Ping timeout: 265 seconds]
lolcathost has quit [Ping timeout: 252 seconds]
lolcathost has joined #ocaml
lolcathost has quit [Ping timeout: 244 seconds]
lorilan has quit [Quit: Quitte]
fayden has quit [Ping timeout: 255 seconds]
lolcathost has joined #ocaml
fayden has joined #ocaml
lolcathost has quit [Ping timeout: 246 seconds]
weie has joined #ocaml
Yoric has joined #ocaml
cdidd has quit [Remote host closed the connection]
fasta has quit [Quit: No Ping reply in 180 seconds.]
fasta has joined #ocaml
jewel has joined #ocaml
Yoric has quit [Ping timeout: 252 seconds]
Yoric has joined #ocaml
fantasticsid has joined #ocaml
Snark_ has joined #ocaml
<wmeyer> morning
<adrien> o/
ikaros has joined #ocaml
<adrien> wmeyer: I wrote http://caml.inria.fr/mantis/view.php?id=5201#c8615 and I'm waiting for comments
<adrien> some things mean quite a lot of work
<adrien> and some other mean breaking API with ocamlbuild plugins (well, _maybe_ breaking; I don't know what is officially in the API)
<adrien> I think I'm going to write a small build driver in ocaml for yypkg
<adrien> few features but usable and portable
<wmeyer> adrien: thx, will try implement a testsuite first
<wmeyer> there is one, but not very good
fantasticsid has quit [Quit: ERC Version 5.3 (IRC client for Emacs)]
<adrien> ok, that's a good idea :-)
<wmeyer> :-)
<wmeyer> this is a lot of work though, but I have idea how it should work and it's going to be OCaml.
<fasta> How can I use a syntax extension and a library with oasis?
<fasta> The oasis website is in a broken state: http://oasis.forge.ocamlcore.org/documentation.html (try clicking on e.g. the most relevant link).
<wmeyer> fasta: use *.syntax package with Oasis trunk
<fasta> wmeyer: can I install that in some easy way?
<fasta> I kind of like the opam way of installing things.
<wmeyer> fasta: you can pin to the git version of Oasis - I think
<wmeyer> I like opam too
<fasta> wmeyer: how do you mean?
<wmeyer> fasta: I didn't use this feature of opam, and not sure if that will do the work at all in this case, but smth like $opam pin oasis <url_to_git> should work
<wmeyer> then you do $opam update and it get's up to date
<adrien> wmeyer: since bash is only used to get unix argument parsing on windows, I'm going to try to get a small independant tool to do that
<adrien> that'll leave the calls to cp/find/rm/mv/... but that'll already help a lot
<fasta> wmeyer: ok, that worked. Now, where is *.syntax documented?
<adrien> sounds like ocamlfind stuff
<adrien> if it's what I think it is, then packages provide a foo.syntax package usually
<wmeyer> fasta: here, in irc logs for time being ;-)
<wmeyer> adrien: so there was commit yesterday to make sure foo.syntax will trigger using pre-procesor with syntax extension
<wmeyer> i am happy it happened and it was a good idea
<adrien> ah, ok =)
<fasta> I checked man ocamlc and the reference manual, but the -syntax option is not documented anywhere.
pango has quit [Remote host closed the connection]
<adrien> fasta: it's ocamlfind
<adrien> wmeyer: making a tool that achieves the same purpose as "bash -c" in ocamlbuild should be hostable on mingw-w64
<wmeyer> adrien: ok, that should work. In a long term however we want to remove this dependencies
<fasta> wmeyer: all I want to do is use ocamlfind ocamlopt -syntax camlp4o -package dyntype.syntax -c t.ml in oasis.
<wmeyer> fasta: not possible - trunk automatically do this for the whole library once you say BuildDepends: foo.syntax
* wmeyer off to do the x-mas shopping
<fasta> wmeyer: that's what I wanted to hear.
<fasta> Or rather, it should be possible to modify the -syntax argument too somewhere, no?
<wmeyer> fasta: _tags. GTG, see you a bit later.
<adrien> wmeyer: yeah, definitely but that should reduce the amount of work to do at once and it can be used by other projects
<fasta> adrien: what kind of tool do you need exactly?
<fasta> adrien: you might want to look in the doctopts library.
<fasta> adrien: it's available for multiple programming languages.
<fasta> adrien: including those that have interpreters on Windows.
<fasta> adrien: I had no idea it was designed to badly on WIndows.
<fasta> Can't we just let Windows die?
<fasta> It was a fun OS at the end of the 1990s, but I'd say its time has passed.
<fasta> If MS comes out with a singularity based OS or something like that, then they would be worthy of attention again.
<adrien> fasta: docopt is interesting (I didn't know about it) but I think it still
<adrien> bah
<adrien> but I think it doesn't handle the issue with quoting
<adrien> it's really a specific treatment
<adrien> also, having it as a standalone executable means it can be easily dropped-in
<fasta> adrien: so, you basically just want to have a Windows program to which you give a sequence of characters, which then interprets it is done on UNIX platforms?
<adrien> yup
<fasta> as is done*
<adrien> that's how ocamlbuild uses bash currently
<fasta> Why do I get undefined global Dyntype with this? print_endline (Dyntype.Value.to_string (value_of_t t))
<adrien> how are you invoking the compiler?
<fasta> I added oasis to the BuildDepends and did oasis setup (and then configure and then build)
<fasta> I mean dyntype.syntax.
<adrien> you need both dyntype.syntax and dyntype I guess
<fasta> ocamlfind ocamlc -g -linkpkg -package batteries -package dyntype.syntax main.cmo -o main.byte
<adrien> -package batteries,dyntype,dyntype.syntax
<fasta> adrien: works
<fasta> adrien: then the dyntype documentation was wrong.
<fasta> I have the impression that there are a lot of libraries for OCaml.
<adrien> basically dyntype.syntax is _only_ for the syntax
<fasta> Some even documented really well.
<fasta> It's like 95% there.
<adrien> but when you use the Dyntype module, you need the "dyntype" package
<fasta> (if you can ignore the parallelism weak spots)
<adrien> well, people don't document what they believe is obvious unfortunately
<fasta> I believe that things which are marked up as commands for a computer must be 100% correct.
<adrien> agreed; I wonder if that issue is not caused by a lack of update after packaging has changed
eni has joined #ocaml
<fasta> Ok, dyntype works.
<fasta> Now, can I also get my lexer and grammar types automatically annotated with dyntype?
<fasta> Or would that just require some horrible sed script?
* adrien has no idea
<fasta> Do you know what the 4 stands for? E/t/4/<Foo;E/r/3/{name:S(Foo);age:I(100)}>
<fasta> I had expected just {name:S(Foo);age:I(100)}> as output.
<adrien> I don't know either
mye has joined #ocaml
eikke has joined #ocaml
eikke has quit [Ping timeout: 252 seconds]
ontologiae has joined #ocaml
Kakadu has joined #ocaml
ontologiae has quit [Ping timeout: 255 seconds]
ontologiae has joined #ocaml
myx has quit [Ping timeout: 264 seconds]
Snark_ is now known as Snark
ontologiae has quit [Ping timeout: 264 seconds]
ontologiae has joined #ocaml
myx has joined #ocaml
ontologiae has quit [Ping timeout: 260 seconds]
smerz has joined #ocaml
Kakadu has quit [Ping timeout: 250 seconds]
dmilith has left #ocaml []
ulfdoz has quit [Quit: kernel update]
dmilith has joined #ocaml
ulfdoz has joined #ocaml
eikke has joined #ocaml
cdidd has joined #ocaml
Kakadu has joined #ocaml
dmilith has left #ocaml []
Yoric has quit [Ping timeout: 252 seconds]
lolcathost has joined #ocaml
mathieui_ has joined #ocaml
mathieui has quit [Read error: Connection reset by peer]
mathieui_ is now known as mathieui
mattrepl has joined #ocaml
Kakadu has quit [Ping timeout: 265 seconds]
Kakadu has joined #ocaml
bobry_ has quit [Remote host closed the connection]
lopex_ has quit [Write error: Broken pipe]
lolcathost has quit [Read error: Connection reset by peer]
Catnaroek has joined #ocaml
Catnaroek is now known as lolcathost
larhat has joined #ocaml
<testcocoon> just a question about opam: is there a buildbot existing which check that all pckages can be installed?
larhat has quit [Quit: Leaving.]
larhat has joined #ocaml
mye has quit [Quit: mye]
lopex_ has joined #ocaml
larhat has left #ocaml []
mye has joined #ocaml
bobry_ has joined #ocaml
ftrvxmtrx has joined #ocaml
gnuvince has quit [Ping timeout: 252 seconds]
rwmjones has quit [Ping timeout: 250 seconds]
dmilith has joined #ocaml
milosn has joined #ocaml
<orbitz> testcocoon: not that i'm aware of
<testcocoon> orbitz: this would certainly something that would not be too difficult to implement and which could be a big value for all maintainers
rwmjones has joined #ocaml
<orbitz> testcocoon: maybe not hard to implement, but resource intensive
<testcocoon> orbitz: you mean in compilation time? but it would be a good sign of qualitity.
<orbitz> testcocoon: storage, bandwidth
<orbitz> testcocoon: also, what does it mean "to install"?
<orbitz> testcocoon: you need test environment sfor os x, linux, windows, various flavours of linux
milosn has quit [Quit: Reconnecting]
<testcocoon> orbitz: run opam install for ean package/compiler
milosn has joined #ocaml
<orbitz> testcocoon: installing on X doesn't mean it installs on Y
<testcocoon> orbitz: yes, but it is better as saying: "we don't know"
<orbitz> how is it better?
<testcocoon> orbitz: GODI has such package tests
<testcocoon> wait I give you the link
<orbitz> testcocoon: i don't don't, GODI is much more mature. Right now the limiting factors of opam don't seem to be package consistency, it will be a limitation eventually
<orbitz> testcocoon: feel free to setup an opam compile server though, i'm sure people will appreciate it
<testcocoon> orbitz: let me see what I can provide
eikke has quit [Ping timeout: 256 seconds]
Yoric has joined #ocaml
pango has joined #ocaml
<mk270> testcocoon: i had the same question about a checker for opam
<mk270> is there a seed crystal project for it?
<mk270> i mean, the stupid version might be a script which tries to download everything in a given repo and build/install it, and returns a bool
<mk270> we can worry about wrapping does_opam_repo_build : unit -> bool later
milosn has quit [Ping timeout: 244 seconds]
milosn has joined #ocaml
<orbitz> is ocaml smart enough to free a variable that is not used anymore in a program but a reference to it still exists in the current executing function's scope?
<jewel> I haven't come across any compilers that zero out stack slots when they are no longer referenced
<jewel> so it's likely the object is still alive from the GC's perspective
<orbitz> I have code in CPS style, but some of the varaibles could be large and should be removed after certain points because i won't need them
<jewel> then you'll need to zero them yourself
lopex_ has quit [Ping timeout: 260 seconds]
<orbitz> what do you mean? how do I zero out an immuatble strucutre
<orbitz> is shadowing the variable sufficient?
<jewel> You only need to zero the reference to the structure, immutable or not
<orbitz> i don't have a refence here, so is shadowing the variable name sufficient?
<jewel> I don't know the details of the ocaml compiler but I would be surprised if shadowing had the effect that you intend
<orbitz> thanks!
<orbitz> will keep it in mind when memory consumption becomes a problem
tane has joined #ocaml
tane has quit [Client Quit]
<wmeyer> orbitz: no, I don't think if there is no reference to the value in your program it will stay on the heap after collection. Aliasing (or shadowing) yet creates a new name for value, shadowing the old name.
iZsh has quit [Quit: Coyote finally caught me]
wmeyer has quit [Remote host closed the connection]
myx has quit [Ping timeout: 245 seconds]
gour has joined #ocaml
lopex_ has joined #ocaml
<gour> evening
<gour> few ocaml-related questions
<gour> in general, i like FP, but found haskell a bit too steep with monads causing few potential contributors to our project to simply run away :-)
<gour> after giving up on idea to just use python+cython, i was considering D(v2) for some time, but i'm not happy with its stability and lack of GUI binding
<gour> in the OOP camp i'm still looking at Ada and considered Modula-2 (R10) but the latter is not ready
<gour> while looking at Ada, i've become interested for one (obscure) lang - small community etc., but nice features, clean syntax etc.
<gour> otoh, i know from before that ocaml is very FP-capable although i remember not being thrilled with the syntax when first looking at it before trying haskell
<gour> now i wonder what is the size of ocaml community?
<gour> is compiler actively developed?
ikaros has quit [Quit: Ex-Chat]
<gour> what about state of GUI bindings usable for multi-platform desktop app?
<gour> i hope there are some bindings for sqlite3...for the rest we need to provide bindings for 3rd party C lib - how is FFI?
<gour> the rest is probably covered by standar libs..
<gour> that's all..for now ;)
<gour> number of users here is very decent - more than 2x of #ada :-)
<Kakadu> so
<Kakadu> I thinks you can use gtk or wxwidgets bindings
<Kakadu> think*
<Kakadu> also You can write QML gui and write connectors from C++ to OCaml manually
<adrien> compiler is developed actively enough to move faster than I :P
<gour> there are wx bindings?
<adrien> hmmmm
<Kakadu> AFAIR
<adrien> some people have done ocaml -> python -> qt/wx/...
<gour> that would be cool, since wx is , i believe, still the best looking toolkit
<adrien> there are bridges with python and perl
<gour> wxocaml - from '04...not very alive, i bet
<orbitz> The issue with lablgtk or whatver is there is no compaction
<gour> adrien: i'd like to avoid too much glue and stay within one lang (preferably strongly-typed), otherwise i could use python+cython
<gour> orbitz: what does it mean compaction? is it just wrapper without type-safety?
<orbitz> gour: the garbage collector can't move data around
<adrien> nah
<orbitz> is that no longer a problem adrien ?
<adrien> the *automatic* compaction is disabled
<adrien> hold on
<gour> let me check status of gtk bindings
<adrien> http://git.ocamlcore.org/cgi-bin/gitweb.cgi?p=lablgtk/lablgtk.git;a=blob;f=README;h=6c2719a20de10356f34edd7f7f06bd433aefc861;hb=HEAD#l282
<adrien> orbitz: ^
<adrien> read the whole paragraph (probably more than once)
<gour> a bit behind...2.16 is latest
<adrien> not exactly
<adrien> it's hard to provide version number to bindings unless you have fully generated bindings
<adrien> lablgtk gets more API when people ask for it (mostly) so that there are people using and testing the API
<adrien> it's dangerous to add more API, not test it enough, have bugs lurking for years before someone stumble on them
<orbitz> adrien: ah notbad
<adrien> also lablgtk has more recent API than 2.16
<gour> what about gtk3?
<adrien> work in progress
<Qrntz> I am working on well-typed SMOKE-based Qt bindings in my free time but I can't promise anything yet
<Qrntz> well, s/well-typed/type-safe/
pango has quit [Ping timeout: 244 seconds]
<adrien> to be honest GTK+3 is high-work/low-reward
<gour> type-safe Qt bindigns would be great addition
<gour> otherwise, by reading the lang's overview. it seems as nice ecosystem...contiuing to read
<adrien> C++ is difficult to bind to non-dynamic languages
<Qrntz> yes, it's proving to be a bit of a pain
<adrien> it has some dynamic components so...
<adrien> and I gues moc isn't helping :P
<Qrntz> I am fairly desperate on this one, though
<adrien> :D
Kakadu has quit []
<Qrntz> it uses GADTs to ensure type safety and is overall shiny
* gour is aware of the C++-libs bindigns pain
<Qrntz> I'll get the code up at GitHub once it stops randomly segfaulting :-p
<gour> does ocaml has pattern matching like haskell?
<gour> *have
<Qrntz> OCaml is the pattern matching language
<gour> hmm...we'll need some time to swallow it :-)
<gour> i also hope/believe IO is not as convoluted in haskell?
<orbitz> ocaml is not pure
<Qrntz> pattern matching is much more pervasive in OCaml than in Haskell I'd say, but then again I'm not a huge Haskell expert
<gour> orbitz: but is it possible to define 'pure' functions without side-effects?
<orbitz> you can write pure functions, there is no type-level enforcement of it
<Qrntz> you can certainly have pure functions, but the compiler doesn't distinguish pure and unpure
<gour> ahh, ok..i spoke with the guy working on R10 for modula-2 and he plans to add some pragma to enforce it...similarly ihn
<gour> *in nimrod language
pango has joined #ocaml
<testcocoon> mk270: we have the same complains, but I think we need to implement this selftest, if we want to have it.
Snark has quit [Quit: Quitte]
<gour> Qrntz: with your QT bindings, ocaml would be almost perfect...honestly, i like wx nativity, but qt is nicely supported
<orbitz> i suspect it will be awhile before Qrntz's QT bindignsare productionworthy
<gour> my wheezy shows ocaml-3.12, is it much behind current 4.0?
<gour> orbitz: so, ocaml-ers are not very much into gui-apps or the whole world is becoming interesting only for clouds&web
<adrien> third option: lablgtk is mature
<adrien> and beating it is difficult
<orbitz> gour: Given ocaml's pedigree, strong GUI's haven't been the number one concern
<adrien> gour: 3.12 is perfectly fine; 4.00(.1) has some nice updates but you probably won't feel the need for them that soon
<gour> adrien: ohh, if gtk is stable and still actively developed, that's fine with me :-)
<gour> orbitz: same in haskell, D. Ada is a bit better with strong gtk and some Qt support
<adrien> it is; it's been a bit silent for the past 3 months but it's still alive ;-)
<adrien> (if you hadn't guessed, I'm a maintainer of lablgtk)
* gour is reading ocaml history
<Qrntz> orbitz, indeed
<Qrntz> I'll make sure to notify this channel once I get them into a stable state, though :-)
ontologiae has joined #ocaml
* gour looking at language shootout table to check about performance
<gour> ..although i'm aware it does not speak much
<orbitz> ocaml's performance is generally pretty good
jewel has quit [Ping timeout: 265 seconds]
<orbitz> and ocaml provides access to fast array's, whcih is how you get faster in every language
<adrien> any idea for a nice-ish set data structuer with an "iter" function that respects the insertion order?
<gour> is type-inference engine on apr with haskell's one?
<gour> *part
<gour> *par
<gour> or is it better to declare types and help compiler?
<orbitz> i declare types on api boundaries
<orbitz> .mli files
<Qrntz> defining interfaces is generally a good idea
<orbitz> It's HM type inferencing
<Qrntz> but it's not strictly needed
<adrien> I don't know haskell much but afaik, ocaml can infer everything in your program while haskell cannot
<adrien> (actually there are some limits with objects)
<thizanne> adrien: if you don't need to remove often things, I guess an usual set + a list would be fine
<gour> orbitz: haskell also has HM, right?
<orbitz> yes
<adrien> thizanne: hmmm, that could work, thanks
<gour> what about unicode/utf8 support?
<orbitz> I don't know
<Qrntz> you'll need additional libraries if you need actual Unicode awareness
<adrien> ocaml strings can include any byte including NULLs so they can store unicode
<adrien> Camomille is a mature unicode library
<flux> utf8 doesn't have zero-bytes
<Qrntz> and yes, Haskell's type inference is augmented HM IRRC
<flux> oh, well maybe that wasn't your point :)
<adrien> I said unicode, not utf-8 :P
<adrien> I wonder if utf-16 really uses null bytes
<flux> I think it doesn't, but I'm not sure
<flux> but it seems I was wrong
<Qrntz> s/R/I/
<gour> can one use FFI in REPL?
<adrien> use, yes
<adrien> code, no
<gour> ok
<adrien> it's possible (and fairly easy) to write them outside of the REPL, build them and use them directly from the REPL
<fasta> adrien: if that's possible it 's also possible to define it on the REPL.
<fasta> adrien: just not directly.
<fasta> (and, it would also mean that any 'improved REPL' could have this feature)
<Qrntz> technically, you can output to files from the REPL and call compilers from within it
<Qrntz> I don't think anyone was interested in that enough, though
<fasta> Haskell can infer just about everything which isn't rank-2 or higher polymorphism.
<flux> usually FFI means writing bits of C
<flux> (FFI in OCaml that is)
<fasta> Almost all programs have trivial (computable) types.
<fasta> It would be nice if type-inferencers would assume everything is trivial.
<gour> any helper for binding C libs? iirc, there is support in SWIG...
lopex_ is now known as lopex
<fasta> It could then cache whatever types it has inferred in the background and only come back to the developer when an actual issue has been found.
<fasta> Probably Visual Studio 2120 has such a feature.
<adrien> fasta: no, the issue is that you need to write C to make the bindings
<adrien> and you need to write _mostly_ C
<fasta> Why doesn't ocaml come with FFI like Haskell does?
<adrien> gour: noooooo, not SWIG!
<Qrntz> gour, there is, doesn't mean you should use it though
<adrien> SWIG makes ugly and weird code
<Qrntz> yep
<fasta> I have the impression that these are just evil schemes to make people write more code in the language for which the compiler was written.
<fasta> Or to keep the language more academic.
* gour is aware of swig's quirks
<adrien> the ocaml FFI isn't that hard
<fasta> adrien: it is tedious.
<adrien> of course it's probably not what you'd start with
<fasta> adrien: I have more than average experience with FFI programming.
<adrien> fasta: if the API you're binding is sane it's only a matter of creating a few macros
<gour> the point is that i do not want just wrapper over 3rd party C lib, so some helper to create higher-level ocamlish API, like c2hs tool in haskell?
<adrien> "cowboy" :P
<fasta> c2hs is not high-level.
<adrien> but the question is: is the C API "regular"
<adrien> ?
<adrien> meaning, does it having naming conventions, a good organization, conventions for the order and name of parameters of functions, ...
<fasta> adrien: you can solve that problem by introducing a standard.
<adrien> on the C side
<adrien> which is a task that rates as "impossible" I'd say =)
<fasta> adrien: yes, that covers the 'OCaml is too slow, let's write that part in C'-case..
<gour> yep, pretty regular C, e.g. int swe_calc(double tjd_et, int ipl, int iflag, double *xx, char *serr)
<fasta> adrien: that way, you can just open C.MyModule and everything works.
<adrien> gour: what is the meaning of "double *xx"
<gour> if int < 0 then report error and fill *serr...result is stored as in 6 double[]...i would like to have exception instead of this C error mechanism and possibly have my own data structure to store result into instead
<adrien> ?
<adrien> ah, out parameter =)
<gour> :-)
<adrien> that's something that needs special care or at least is not guessable
<adrien> unless you never ever use arrays of double
<adrien> and all occurences of "double *" are out parameters
<gour> fasta: c2hs allows one to tailor haskell's part of interface, iow. to create higher-level API, not automagically, but there are helpers for common marshalling stuff at least
<adrien> that's the sort of questions you need to answer =)
<fasta> gour: there are better tools available.
<gour> swig has some support with typemaps or how they're called instead of writing everything by hand
<gour> fasta: good. i'm all eary
<adrien> well, lablgtk's binding code is generally close to: ML_2 (gtk_notebook_get_nth_page, GtkNotebook_val, Int_val, Val_GtkWidget)
<gour> *ers
<gour> *ears
<fasta> gour: unfortunately, I forgot the name of these libraries.
<gour> fasta: ok
<fasta> gour: it's on Hackage, but I cannot find it now.
<fasta> gour: I did look for a few minutes.
<fasta> gour: it's something like bindings*
lolcathost has quit [Quit: leaving]
<gour> fasta: but that's for haskell only?
<fasta> gour: yes
<gour> fasta: ok. i know there were few tools...but i'm not more interested in haskell
<fasta> gour: you are now insterested in OCaml?
Catnaroek has joined #ocaml
<fasta> interested*
<gour> well, reading about it...i was looking at it several years ago, before started reading haskell and then ocaml's syntay was not quite ok with me
<gour> typerex, that's for emacs only?
<gour> i used emacs for some time, but had pain in my wrist :-(
<gour> what is editor support for ocaml in general? vim ,geany..?
<Qrntz> I use Kate for my OCaml needs
<Qrntz> Vim is well smart as well
<fasta> gour: Emacs can be configured to use spacebar as meta key.
<fasta> gour: typerex is a dead project currently.
<fasta> gour: just use tuareg-mode.
<fasta> Typerex is the beginning of something cool, but alas, it's just the beginning.
<gour> :-(
<fasta> gour: (or any of the other options mentioned)
<gour> fasta: is don still active in haskell?
<fasta> gour: he works for Galois, so, I suppose yes.
<gour> fasta: he is still there? are you sure?
<fasta> Don was just a cheerleader. Who cares?
<fasta> He built on top of some bad ideas to create libraries that every other system already had.
<gour> hmm...i had a feeling that he, dcoutts and co. did a lot of service for haskell
<gour> fasta: you're more here in haskell side?
<fasta> gour: I program in lots of languages.
<fasta> gour: currently, I am trying to use OCaml for some tools that I need.
m_m has joined #ocaml
<fasta> I think I find Scheme to be the most comfortable to program in.
<gour> how is this latest version called?
<fasta> Racket ;)
<fasta> Racket has improved, imho, but if you use it, you shouldn't use it for raw performance.
<fasta> It's a pleasant language to program in now.
<fasta> The whole environment works quite well (not perfect), but good enough.
<fasta> A few years ago it was total crap.
<gour> any gui bindings to write complete desktop app?
<fasta> gour: new applications can be written against a web user interface just fine.
<fasta> gour: if you don't want that, there are some bindings, I think.
<gour> fasta: web is not enough for our use case
<fasta> gour: there is also no shame in writing the GUI in a different language than the application.
<gour> thanks
<fasta> gour: you can even use shared memory if you really want performance.
<gour> one more ocaml question: build system(s)?
<fasta> gour: oasis
<fasta> gour: you also want opam
<fasta> gour: opam is like cabal install, but better.
<fasta> (Everyone thinks cabal is a great program, but it's only 1000 lines or so)
<gour> fasta: has cabal got 'uninstall'?
<fasta> gour: no
<gour> :-)
<fasta> gour: one of the reasons it is a failure.
<fasta> gour: there are many more reasons why cabal is a stupid program.
<fasta> Everyone who knows Haskell knows about these issues.
<fasta> Cabal is one of those programs that have been written as a temporary hack, but it was forgotten that it was meant as a temporary hack.
<gour> lol
<fasta> gour: anyway, good luck with OCaml.
<gour> if i want to include 3rd party C lib in my project, build it, then create bindings and other custom libs in ocaml, plus main gui app and build docs, can oasis do everything?
<fasta> gour: I am _not_ an OCaml expert. I have some book knowledge and I can understand most OCaml, but I am only a beginner.
<gour> otherwise, i played a bit with tup few days ago...
<gour> fasta: thank you. all the best racketing ;)
<fasta> gour: it wouldn't hurt building on top of tup.
<fasta> gour: that is, a tool which is designed for ocaml which compiles to tup files.
<gour> ok
<fasta> Throw in an automatic /dev/shm storage mode, and you got something useful.
<fasta> If I ever get Intel graphics, I will probably dare to do something like that, because currently my system is not stable enough to do that.
<gour> i'd prefer to simply have stable ecosystem, 'cause there will be lot of work on the project itself and not time to really build ecosystem
<fasta> gour: if you want stability, pick e.g. Common Lisp.
<fasta> gour: OCaml is also relatively stable.
<gour> fasta: lispy languages are somehow not my taste
<fasta> gour: Haskell doesn't appear to be.
<fasta> gour: C++ is also quite stable, since there are standards.
<gour> fasta: ocaml could possibly nicelly fulfill my past love for FP & haskell :-)
<fasta> One advantage of OCaml is that it has an actual module system compared to C++.
<fasta> The linker also doesn't appear to be so terribly slow.
<gour> fasta: i used C+++ manyb years ago (zortech c++) and in the meantime it evolved into ugly & huge beast...so staying away from C(++) as well as java
<gour> didn't want to bold everything...excuse me
<fasta> I don't even know how to bold anything :)
<fasta> I know I can find out if I would care, but I don't.
* gour wonders if ocaml users use some other build system {waf,scons,cmake..}
* gour uses weechat
ontologiae has quit [Ping timeout: 246 seconds]
<gour> ^cbbold_text^cb
<fasta> I like that in C++ you can replace the memory allocator, etc.
<gour> maybe if i would be younger with more time...now let's be pragmatic
<madroach> hi, BatNum.of_float is badly broken. Here's a better implementation: http://pastebin.com/JtfuLheZ. Can someone commit this? thelema ?
<fasta> madroach: probably better if you just send a patch to their email address.
<madroach> will do.
iZsh has joined #ocaml
<Qrntz> gour, ocamlbuild (with or without OASIS) seems to be the trend now
<gour> Qrntz: thanks
<Qrntz> there is also OCamlMakefile and OMake but I wouldn't recommend the latter
<gour> there are no stable sqlite3-bindings (found only alpha & beta) or cannot find it?
<Qrntz> also OPAM is not a build system, it's a package manager
<gour> that i figured it out
<Qrntz> I successfully used the… let me check
<Qrntz> the latest version is 2.0.4
<Qrntz> I call that stable enough
<Qrntz> (well, the latest in my distro; YMMV)
<gour> Qrntz: thanks. it looks that the library-search i used is not updated showing the old homepage
gnuvince has joined #ocaml
* gour is reading OCaml for the Masses
<gour> in the past i just skipped over it :-)
gour has quit [Disconnected by services]
gour_ has joined #ocaml
eni has quit [Quit: Leaving]
rwmjones has quit [Ping timeout: 250 seconds]
* gour_ is installing ocaml stuff..l.
<Qrntz> gour_, the Hump may have outdated information indeed
gour_ is now known as gour
<gour> indeed...learning about it ;)
tane has joined #ocaml
rwmjones has joined #ocaml
mcclurmc has quit [Quit: Leaving.]
eikke has joined #ocaml
m_m has quit [Ping timeout: 255 seconds]
Catnaroek has quit [Ping timeout: 265 seconds]
tane has quit [Quit: Verlassend]
Yoric has quit [Ping timeout: 252 seconds]
Catnaroek has joined #ocaml
eikke has quit [Ping timeout: 260 seconds]
eikke has joined #ocaml
fusillia has joined #ocaml
fusillia has quit [Client Quit]
fusillia has joined #ocaml
BiDOrD has joined #ocaml
BiDOrD_ has quit [Ping timeout: 245 seconds]
eikke has quit [Ping timeout: 250 seconds]
eikke has joined #ocaml
wagle has quit [Remote host closed the connection]
cdidd has quit [Remote host closed the connection]
wagle has joined #ocaml
wmeyer has joined #ocaml
eikke has quit [Ping timeout: 264 seconds]
gour has quit [Quit: WeeChat 0.3.8]
pango has quit [Remote host closed the connection]
everyonemines has joined #ocaml
lorilan has joined #ocaml
pango has joined #ocaml
everyonemines has quit [Quit: Leaving.]
mye has quit [Quit: mye]
mye has joined #ocaml
Catnaroek has quit [Quit: brb peepls!!1]
mye has quit [Quit: mye]
wagle_ has joined #ocaml
wagle has quit [Read error: Connection reset by peer]
Yoric has joined #ocaml