<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>
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>
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.
<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