<hcarty>
thelema: Something like that would allows for code like F10.(make 5.0 + make 6.0) evaluating to nan and N10.(make 5 + make 6) evaluating to None
lggr has quit [Ping timeout: 260 seconds]
lggr has joined #ocaml
<thelema>
hcarty: nice
<thelema>
hmm, the make functions...
lggr has quit [Ping timeout: 246 seconds]
<thelema>
hcarty: not much real connection between this and BatBounded
<thelema>
at least in the code
lggr has joined #ocaml
hcarty2 has joined #ocaml
<hcarty2>
thelema: Not code-wise, just conceptually
<hcarty2>
I'll take a look and bringing the two together over the next day or few
<thelema>
is there much use for math over a small range
<thelema>
i.e. not 0..n
<hcarty2>
If you have some physical or other constraint
<thelema>
I can see bounded +,-,* unbounded
<thelema>
but not as much bounded +,-,* bounded
lggr has quit [Ping timeout: 246 seconds]
<hcarty2>
I'm off for the evening, but I'll think on this some more. Leave a note/email if you have any more thoughts or suggestions.
avsm has quit [Quit: Leaving.]
lggr has joined #ocaml
hcarty2 has quit [Quit: Yaaic - Yet another Android IRC client - http://www.yaaic.org]
lggr has quit [Ping timeout: 244 seconds]
lggr has joined #ocaml
lggr has quit [Ping timeout: 240 seconds]
lggr has joined #ocaml
lggr has quit [Ping timeout: 260 seconds]
<hiredman>
.win 31
lggr has joined #ocaml
lggr has quit [Ping timeout: 264 seconds]
lggr has joined #ocaml
lggr has quit [Ping timeout: 260 seconds]
lggr has joined #ocaml
lggr has quit [Ping timeout: 246 seconds]
lggr has joined #ocaml
lggr has quit [Ping timeout: 248 seconds]
BiDOrD has joined #ocaml
BiDOrD_ has quit [Read error: Connection reset by peer]
kmicinski has joined #ocaml
lggr has joined #ocaml
lggr has quit [Ping timeout: 246 seconds]
lggr has joined #ocaml
lggr has quit [Ping timeout: 260 seconds]
lggr has joined #ocaml
Playground has joined #ocaml
ankit9 has joined #ocaml
Playground has quit [Read error: Connection reset by peer]
lggr has quit [Ping timeout: 246 seconds]
lggr has joined #ocaml
Playground has joined #ocaml
lggr has quit [Ping timeout: 248 seconds]
Yoric has joined #ocaml
lggr has joined #ocaml
lggr has quit [Ping timeout: 245 seconds]
lggr has joined #ocaml
lggr has quit [Ping timeout: 246 seconds]
lggr has joined #ocaml
lggr has quit [Ping timeout: 246 seconds]
emmanuelux has quit [Quit: emmanuelux]
lggr has joined #ocaml
lggr has quit [Ping timeout: 240 seconds]
lggr has joined #ocaml
lggr has quit [Ping timeout: 248 seconds]
Cyanure has joined #ocaml
lggr has joined #ocaml
lggr has quit [Ping timeout: 244 seconds]
pango is now known as pangoafk
lggr has joined #ocaml
lggr has quit [Ping timeout: 260 seconds]
lggr has joined #ocaml
kmicinski has quit [Quit: leaving]
viric has quit [Remote host closed the connection]
lggr has quit [Ping timeout: 248 seconds]
hkBst has joined #ocaml
hkBst has quit [Changing host]
hkBst has joined #ocaml
tufisi has joined #ocaml
lggr has joined #ocaml
sepp2k has joined #ocaml
lggr has quit [Ping timeout: 256 seconds]
Cyanure has quit [Remote host closed the connection]
tufisi has quit [Ping timeout: 256 seconds]
lggr has joined #ocaml
lggr has quit [Ping timeout: 256 seconds]
lggr has joined #ocaml
ankit9 has quit [Quit: Leaving]
lggr has quit [Ping timeout: 244 seconds]
ftrvxmtrx has joined #ocaml
Cyanure has joined #ocaml
lggr has joined #ocaml
djcoin has joined #ocaml
chambart has joined #ocaml
tufisi has joined #ocaml
lggr has quit [Ping timeout: 244 seconds]
lggr has joined #ocaml
chambart has quit [Ping timeout: 260 seconds]
lggr has quit [Ping timeout: 264 seconds]
ftrvxmtrx has quit [Read error: Connection reset by peer]
ftrvxmtrx has joined #ocaml
lggr has joined #ocaml
chambart has joined #ocaml
ftrvxmtrx has quit [Quit: Leaving]
lggr has quit [Ping timeout: 246 seconds]
lggr has joined #ocaml
ankit9 has joined #ocaml
sepp2k has quit [Remote host closed the connection]
cdidd has joined #ocaml
lggr has quit [Ping timeout: 264 seconds]
cdidd has quit [Read error: Connection reset by peer]
ankit9 has quit [Ping timeout: 246 seconds]
lggr has joined #ocaml
lggr has quit [Ping timeout: 246 seconds]
Playground has quit [Read error: Connection reset by peer]
lggr has joined #ocaml
ankit9 has joined #ocaml
lggr has quit [Ping timeout: 246 seconds]
lggr has joined #ocaml
eikke has joined #ocaml
cdidd has joined #ocaml
lggr has quit [Ping timeout: 256 seconds]
mika1 has joined #ocaml
filp has joined #ocaml
lggr has joined #ocaml
filp has left #ocaml []
lggr has quit [Ping timeout: 246 seconds]
lggr has joined #ocaml
lggr has quit [Ping timeout: 256 seconds]
Playground has joined #ocaml
lggr has joined #ocaml
lggr has quit [Ping timeout: 246 seconds]
lggr has joined #ocaml
lggr has quit [Ping timeout: 245 seconds]
rwmjones has quit [Ping timeout: 255 seconds]
testcocoon has quit [Quit: Coyote finally caught me]
<nickyc>
In this case O(n^2) algorithms being used.
<adrien>
tbh, if Jacques Garrigue says he can't do much more, doing more is probably not very easy
<nickyc>
How can Error: Reference to undefined global `Unix' be fixed?
<adrien>
depends on you call ocaml* binaries
Kakadu has joined #ocaml
<nickyc>
I see zero relevance to how difficult someone deems a task with closing that task.
<nickyc>
It hasn't been solved, so it should stay open.
<thizanne>
Or maybe it can't be solved, so it's pointless to leave it open
lggr has quit [Ping timeout: 256 seconds]
lggr has joined #ocaml
<nickyc>
thizanne: of course it can be solved. There is an easy way to solve it in in O(n lg n).
<f[x]>
so post your patch
lggr has quit [Ping timeout: 245 seconds]
<thizanne>
just do it nickyc :)
<nickyc>
My actions are irrelevant too.
<nickyc>
It's a simple principle; do not close issues, because you might be incompetent or because the whole system has been designed in the wrong way.
<nickyc>
That would be like saying "we have the AIDS issue". Oh, well, that looks too hard. Let's go shopping!
<thizanne>
your proposition ould be like saying "I have AIDS. Oh, I can't be cured, so I'll stay at the hospital until I die"
lggr has joined #ocaml
testcocoon has quit [Quit: Coyote finally caught me]
lggr has quit [Ping timeout: 268 seconds]
testcocoon has joined #ocaml
lggr has joined #ocaml
Yoric has joined #ocaml
lggr has quit [Ping timeout: 248 seconds]
lggr has joined #ocaml
<Yoric>
nickyc: « The paste you are looking for does not exist »
<Yoric>
Terrible indeed :)
lggr has quit [Ping timeout: 264 seconds]
<Kakadu>
I think title of conference is a little bit outdated.............. (OCaml 3.12.1)
lggr has joined #ocaml
rwmjones has quit [Ping timeout: 268 seconds]
lggr has quit [Ping timeout: 245 seconds]
lggr has joined #ocaml
rwmjones has joined #ocaml
lggr has quit [Ping timeout: 260 seconds]
<hcarty>
nickyc: Suspended <> Closed - Lots of reports have been suspended but not resolved. It means something along the lines of "it's an issue, but it's minor enough that we aren't likely to work on a fix until a better idea/patch comes along"
_andre has joined #ocaml
lggr has joined #ocaml
<hcarty>
nickyc: Undefined global 'Unix' generally means that you are trying to use the Unix module but haven't linked against it.
lggr has quit [Ping timeout: 240 seconds]
Znudzon has joined #ocaml
lggr has joined #ocaml
<hcarty>
nickyc: Or perhaps more likely s/linked/compiled/
sithisbitch has quit [Quit: Leaving]
lggr has quit [Ping timeout: 244 seconds]
cdidd has quit [Remote host closed the connection]
cixaxa has joined #ocaml
lggr has joined #ocaml
tufisi has quit [Ping timeout: 260 seconds]
lggr has quit [Ping timeout: 246 seconds]
lggr has joined #ocaml
djcoin has quit [Quit: WeeChat 0.3.7]
<thizanne>
nnn
<thizanne>
sorry
lggr has quit [Ping timeout: 264 seconds]
cixaxa has quit [Ping timeout: 240 seconds]
lggr has joined #ocaml
lggr has quit [Ping timeout: 248 seconds]
lggr has joined #ocaml
djcoin has joined #ocaml
eikke has quit [Ping timeout: 268 seconds]
lggr has quit [Ping timeout: 264 seconds]
lggr has joined #ocaml
cdidd has joined #ocaml
lggr has quit [Ping timeout: 248 seconds]
lggr has joined #ocaml
fraggle_laptop has joined #ocaml
lggr has quit [Ping timeout: 244 seconds]
lggr has joined #ocaml
lggr has quit [Ping timeout: 268 seconds]
lggr has joined #ocaml
lggr has quit [Ping timeout: 260 seconds]
Playground has quit [Quit: brb]
lggr has joined #ocaml
lggr has quit [Ping timeout: 268 seconds]
lggr has joined #ocaml
lggr has quit [Ping timeout: 264 seconds]
lggr has joined #ocaml
ghostbuster2 has joined #ocaml
Submarine has joined #ocaml
Submarine has quit [Changing host]
Submarine has joined #ocaml
Znudzon has quit [Quit: Leaving]
ankit9 has quit [Remote host closed the connection]
<thelema>
so that saturate doesn't need an extra wrap/unwrap
hongboz has quit [Ping timeout: 246 seconds]
<hcarty>
thelema: Agreed
<thelema>
I wonder if the new Int type pattern deserves to be factored out somehow...
<thelema>
But the common case of that is just a simple module type
lggr has joined #ocaml
<thelema>
do you know what I mean by "new Int" pattern?
<hcarty>
thelema: The ready-to-use implementation of infix operators?
<hcarty>
I do think that some convenience functors for integers and floating point values would be worth providing
<thelema>
on an abstract type that's just an integer/float under the covers
<flux>
private types are made for this?
<hcarty>
flux: private int, private float, etc.
<thelema>
example: module MyInt : sig type t val of_int : int -> t val to_int : t -> int end = BatInt
rwmjones has quit [Ping timeout: 268 seconds]
<thelema>
this makes an abstract type that can be converted to and from ints, but is distinct from them on a type level
<thelema>
That's the old solution before private types; private int is better
<thelema>
so you just cast to int
<thelema>
although with neither do you get nice literals.
<hcarty>
thelema: No, sadly not without -ppx or camlp4
<hcarty>
Maybe not so sadly... it could make the code hard to follow
<thelema>
in any case, this is off track for the discussion of what to do with bounded
lggr has quit [Ping timeout: 260 seconds]
<thelema>
if we end up implementing that, bounded should be refactored to use it.
<hcarty>
Agreed
<thelema>
the base_u and u types remind me of this
<thelema>
utop $ SatI10.(make 2 + 2 +: make ~-1);;
<thelema>
- : SatI10.t = 4
<hcarty>
thelema: make ~-1 = 0 : SatI10.t
<thelema>
+: bounds the argument while + doesn't?
<hcarty>
thelema: Yes
<hcarty>
thelema: Just as an example
lggr has joined #ocaml
<thelema>
actually, it doesn't bound the argument, it assumes an already bounded argument...
<hcarty>
True - assumes at the type level
<thelema>
ah, which is why the 'make 2' at the beginning of the arithmetic
<hcarty>
Right
<thelema>
looks good to me. there's some more things to do to make bounded usable. I'm thinking that it should be in Batteries.Incubator (as the interface isn't fixed)
<thelema>
and BatBounded needs to be added to the documentation index.
<hcarty>
thelema: Yes, definitely on both.
<hcarty>
I'll add some more documentation and look into more convenience modules/module types before submitting another pull request.
<thelema>
but I approve of the changes; if github still let me pull easily from your branch, I'd do so.
<thelema>
I look forward to the next pull request
<hcarty>
So do I :-)
<thelema>
oh yeah, and this needs some big warnings that it's not safe with respect to int overflow
<thelema>
meaning that it's not a substitute for Int.Safe_int
<thelema>
although if it's easy to combine the two... :)
<hcarty>
thelema: We'll have to make sure it is!
<thelema>
so that you can have default int operations saturate instead of overflowing or raising exception
lggr has quit [Ping timeout: 268 seconds]
rwmjones has joined #ocaml
lggr has joined #ocaml
lggr has quit [Ping timeout: 256 seconds]
lggr has joined #ocaml
Cyanure has quit [Remote host closed the connection]
lggr has quit [Ping timeout: 246 seconds]
lggr has joined #ocaml
sithisbitch has joined #ocaml
hkBst has quit [Ping timeout: 246 seconds]
lggr has quit [Ping timeout: 256 seconds]
lggr has joined #ocaml
cdidd has quit [Read error: Connection reset by peer]
lggr has quit [Ping timeout: 245 seconds]
lggr has joined #ocaml
lggr has quit [Ping timeout: 246 seconds]
ghostbuster2 has joined #ocaml
lggr has joined #ocaml
lggr has quit [Ping timeout: 244 seconds]
Kakadu has quit [Quit: Page closed]
mika1 has quit [Quit: Leaving.]
nickyc has quit [Quit: Page closed]
lggr has joined #ocaml
Submarine has quit [Quit: Leaving]
lggr has quit [Ping timeout: 268 seconds]
smondet has joined #ocaml
lggr has joined #ocaml
lggr has quit [Ping timeout: 248 seconds]
lggr has joined #ocaml
sepp2k has joined #ocaml
lggr has quit [Ping timeout: 256 seconds]
Yoric1 has quit [Ping timeout: 248 seconds]
lggr has joined #ocaml
ghostbuster2 has quit [Ping timeout: 240 seconds]
lggr has quit [Ping timeout: 248 seconds]
lggr has joined #ocaml
ghostbuster2 has joined #ocaml
fraggle_laptop has quit [Ping timeout: 268 seconds]
lggr has quit [Ping timeout: 246 seconds]
lggr has joined #ocaml
fraggle_laptop has joined #ocaml
lggr has quit [Ping timeout: 246 seconds]
lggr has joined #ocaml
Yoric has joined #ocaml
lggr has quit [Ping timeout: 240 seconds]
lggr has joined #ocaml
ghostbuster2 has quit [Ping timeout: 246 seconds]
lggr has quit [Ping timeout: 264 seconds]
ontologiae has joined #ocaml
lggr has joined #ocaml
eni has joined #ocaml
djcoin has quit [Quit: WeeChat 0.3.7]
lggr has quit [Ping timeout: 244 seconds]
Kakadu has joined #ocaml
ghostbuster2 has joined #ocaml
cdidd has joined #ocaml
chambart has quit [Ping timeout: 260 seconds]
lggr has joined #ocaml
lggr has quit [Ping timeout: 240 seconds]
lggr has joined #ocaml
pangoafk is now known as pango
ontologiae has quit [Read error: Operation timed out]
lggr has quit [Ping timeout: 246 seconds]
eikke has quit [Ping timeout: 268 seconds]
sithisbitch has quit [Quit: Leaving]
lggr has joined #ocaml
tufisi has joined #ocaml
dsheets has quit [Read error: Operation timed out]
lggr has quit [Ping timeout: 248 seconds]
lggr has joined #ocaml
tufisi has quit [Ping timeout: 240 seconds]
dsheets has joined #ocaml
lggr has quit [Ping timeout: 264 seconds]
lggr has joined #ocaml
ghostbuster2 has quit [Ping timeout: 248 seconds]
dsheets has quit [Ping timeout: 250 seconds]
mk270_ is now known as mk270
mfp has quit [Read error: Connection reset by peer]
lggr has quit [Ping timeout: 264 seconds]
sepp2k1 has joined #ocaml
sepp2k has quit [Ping timeout: 246 seconds]
Cyanure has joined #ocaml
lggr has joined #ocaml
osa1 has joined #ocaml
emmanuelux has joined #ocaml
<pippijn>
how can I tell ocamlbuild to not traverse a certain directory?
lggr has quit [Ping timeout: 246 seconds]
<pippijn>
I have a huge testsuite directory I don't want it to look at
tufisi has joined #ocaml
<thelema>
dirname : ignore
<pippijn>
because it takes 8 seconds
<thelema>
err...
<pippijn>
"testsuite": ignore
<thelema>
"testsuite": -traverse
<thelema>
".git": -traverse
<pippijn>
ah
<thelema>
this is what I have in batteries
<pippijn>
thelema: good
<pippijn>
thanks
<thelema>
n/p. if you're feeling generous, improve the docs
lggr has joined #ocaml
mfp has joined #ocaml
<fasta>
It appears that the ocaml mailinglist is rather quiet. Is that because 'nobody' is using it? Or because it's just a stable platform which generally works and thus doesn't require questions?
lggr has quit [Ping timeout: 246 seconds]
<thizanne>
it depends on what you call "quiet"
<thizanne>
I find it rather active :)
<pippijn>
is there a menhir versioned source repository?
<thizanne>
yes
<thizanne>
but I don't remember if it's public :>
<pippijn>
:\
<thelema>
fasta: the discussion on future features is a separate list; I imagine there's more active discussion there
<fasta>
thelema: I have never heard of that one.
<fasta>
thelema: not is it visible on the Forums about Caml page.
<fasta>
nor*
lggr has joined #ocaml
<thelema>
correct, it's not public
<pippijn>
is there a reason for that?
<fasta>
thelema: consortium only?
<thelema>
too much noise if it were public
<pippijn>
noise? oh, you're talking about the ML
<fasta>
I somehow doubt that many people would care to join.
<fasta>
It's not like you are discussing <insert celebrity>.
dsheets has joined #ocaml
Submarine has joined #ocaml
Submarine has quit [Changing host]
Submarine has joined #ocaml
<pippijn>
well
<pippijn>
I want to develop menhir
lggr has quit [Ping timeout: 240 seconds]
<pippijn>
if there is no upstream source repository I can track, I need to fork it
<thizanne>
send a mail to Francois Pottier
<thizanne>
he will be happy
_andre has quit [Ping timeout: 256 seconds]
emmanuelux has quit [Quit: emmanuelux]
<pippijn>
ok
lggr has joined #ocaml
<Kakadu>
pippijn: btw, I have read a diploma about parsing and there are some pros and contros about menhir and other tools and some features which the best analyzer-generator should have
<pippijn>
diploma?
<Kakadu>
hm...
<pippijn>
Kakadu: well, menhir has sucky error reporting
<pippijn>
I improved it
emmanuelux has joined #ocaml
<Kakadu>
maybe `graduation paper` will be more `English`
<pippijn>
the first part is generated from the state machine
<pippijn>
all tokens that allow a shift are listed for each state
<pippijn>
I found it impractical to also show the tokens that allow for reduce
<hcarty>
thelema: Did gasche as well? I remember trying one of them and thinking that the results were very nice
<pippijn>
you often end up showing every possible token in the grammar
<pippijn>
hcarty: that sounds bad
<thelema>
I only know the one I did.
<pippijn>
I don't like that about ocaml
<pippijn>
development seems opaque
<hcarty>
pippijn: Don't like what?
<pippijn>
some people at inria are hacking on the compiler
<hcarty>
pippijn: Or, rather, what sounds bad?
<pippijn>
and then some people (thelema, gasche) do some cool things
<pippijn>
but they never get merged into the compiler
<hcarty>
Ah, I understand.
<pippijn>
and menhir..
<pippijn>
no source repository?
<pippijn>
it's opaque
<thizanne>
pippijn: gasche is amongst these people at inria
<pippijn>
at some point, there is a release
<pippijn>
thizanne: ah
<pippijn>
that's good then
<wmeyer>
pippijn: I don't agree on this point, it's a compiler. Look at gcc, and then look at llvm. Where would you place OCaml? :-) Not starting a moot discussion.
<pippijn>
I don't understand your point
<thelema>
pippijn: xavier leroy is very picky about what makes it into the compiler because his team at inria is going to be responsible for the added code forever.
<wmeyer>
pippijn: so if you look at slides that Xavier L presented on the Workshop, it's known issue; the workforce is small
<pippijn>
thelema: okay, I see
Yoric has quit [Ping timeout: 246 seconds]
<pippijn>
we'll see where my menhir efforts go
<wmeyer>
pippijn: compilers, especially single implementation needs certain care :-)
<pippijn>
the code is public, anyway
<pippijn>
mine, that is
<wmeyer>
pippijn: clang is different - there is C++ standard
<thelema>
I think he might have made a mistake with allowing ocamlbuild into the base, as it's not particularly good code, and the author isn't maintaining it anymore
<pippijn>
(github)
<wmeyer>
pippijn: so only needs a bunch of C++ people to implement
lggr has quit [Ping timeout: 260 seconds]
<pippijn>
thelema: do you think ocamlbuild is going to die again?
<wmeyer>
thelema: I defend ocamlbuild!
<thelema>
wmeyer: then send patches to mantis to fix its problems
<wmeyer>
it's not massively bad, actually it's a good piece of code, just not enough time spent.
<pippijn>
maybe I need to put more effort into my (now stale) build system, again
<thelema>
wmeyer: agreed; I use it in my code.
<wmeyer>
thelema: I understand your point, please send patches :-)
<thelema>
pippijn: not really; ocp is working on ocp-build to fix the ocaml build process
<wmeyer>
thelema: to be serious, ocamlbuild is not bad - eally
<wmeyer>
some of the build systems are much worse
<thelema>
the code inside it is resistant to improvement
<wmeyer>
thelema: the only problem i see is lack of real maintainers
<wmeyer>
with fully hearted will to refactor, break things, implement test suite etc.
<wmeyer>
it's a good base
<fasta>
A compiler should just be a compiler and shouldn't invent its own build system.
<wmeyer>
one of the discussions we had, was my proposal (i talked about Nicolas P about it), to expose the ocamlbuild API
lggr has joined #ocaml
<thelema>
wmeyer: that would be a great thing to have
<wmeyer>
that would allow Oasis instead of generating files
<wmeyer>
just call the API
<fasta>
Some people have created good build systems. Anything which is language specific is going to be the sux.
pr_ has joined #ocaml
<fasta>
In the end, all you have are dependencies and ways in which dependencies can create other dependencies.
<wmeyer>
fasta: In short: it depends.
<thelema>
fasta: granted; if we had cross-package dependency detection built in, we could use other build systems
<fasta>
Some people have solved that problem to perfection, imho.
<fasta>
Is there anything which would stop me from using such systems myself to compile ocaml executables?
<wmeyer>
fasta: it smells like you want Omake
<fasta>
wmeyer: no, that's also a bad system.
<pippijn>
fasta: which system, for example?
<fasta>
pippijn: Tup for example.
<pippijn>
ah, there we go
<pippijn>
a tup fanatic
<fasta>
pippijn: I haven't found anyone who could convince me that tup is not a good system.
<pippijn>
fasta: how does tup know which ml file to compile first?
<fasta>
pippijn: you have to tell it that, and I suppose omake already does that part.
<fasta>
pippijn: the proper solution would be to extract that logic out of omake.
<wmeyer>
nice one
<pippijn>
then you can use it
<fasta>
pippijn: and then call tup.
<pippijn>
you can use any build system
<wmeyer>
thx for sharing, that was enlighetning
<pippijn>
make, tup, ant
<fasta>
pippijn: with omake?
<pippijn>
if you tell it about the dependencies beforehand
<fasta>
pippijn: I am confused.
<pippijn>
tup doesn't know about ocaml dependencies
<pippijn>
so you need to generate that information, first
<fasta>
pippijn: yes, but tup is better than make.
<pippijn>
I'm not going into that discussion
<fasta>
pippijn: yes, you need to generate that information. Can that information be generated via omake? Or is your point that omake already does that and as such any tool which doesn't is a mistake?
<pippijn>
you can use any proper build system to make ocaml programs
jlouis_ has joined #ocaml
lggr has quit [Ping timeout: 240 seconds]
<pippijn>
I don't know omake
<pippijn>
I know that ocamlbuild does the dependency stuff for me
<pippijn>
and is therefore a lot easier to use for ocaml than other build systems (at least for regular ocaml programs)
<wmeyer>
fasta: does tup discover dependendies on the fly. Ocamblubuild does it.
<fasta>
wmeyer: it can be programmed to do that without modifying tup internals, AFAIK.
<wmeyer>
fasta: here you go
<adrien>
reminds me of ocamlbuild
<adrien>
</troll>
<wmeyer>
Makefiles can be called recursively *at least* to be clear
<pippijn>
actually I like the way ocamlbuild is configured/extended
<pippijn>
the same way xmonad is
<pippijn>
(I use both)
<jonafan>
xmonad in the house
<wmeyer>
jsut ocamlbuild is not purely functional
<wmeyer>
;p
<jonafan>
i've been using it since probably january
<wmeyer>
btw: i don't use xmonad here on a destkopt
<wmeyer>
but i do use on a netbook
<wmeyer>
(and I am happier with xmonad than StumpWM)
<jonafan>
i use it on two 21" monitors
<pippijn>
ah I was thinking about something related to purely functional
<wmeyer>
pippijn: shake
sivoais_ has joined #ocaml
<pippijn>
I used to (and will at some point) work on a C frontend
<wmeyer>
I do believe that destructive plugins in ocamlbuild and camlp4 are mistake
<pippijn>
and the AST is an immutable data structure
lggr has joined #ocaml
<fasta>
pippijn: if you have a project with n files and you change one file, how many stat calls do you get minimally?
pr has quit [Ping timeout: 245 seconds]
ghostbuster2 has quit [Ping timeout: 245 seconds]
beckerb has quit [Remote host closed the connection]
sivoais has quit [*.net *.split]
noj has quit [*.net *.split]
rixed has quit [*.net *.split]
bitbckt has quit [*.net *.split]
jlouis has quit [*.net *.split]
<pippijn>
fasta: I'm not going into that discussion
pr_ is now known as pr
pr has quit [Changing host]
pr has joined #ocaml
<fasta>
pippijn: so, the answer is a lot.
<wmeyer>
pippijn: it works, but you might be hit by the performance; nevertheless i believe it's a right choice, then mutability.
<fasta>
That's fine, and I understand the trade-off.
<wmeyer>
then=than
<pippijn>
wmeyer: the thing is, when I do a pass over the AST, the whole thing is copied
beckerb has joined #ocaml
rixed has joined #ocaml
bitbckt has joined #ocaml
<adrien>
of course you need to stat everything
<pippijn>
the entire AST is copied over and over
<adrien>
how do you know the files have changed if you don't stat them?
<fasta>
adrien: not so in tup.
<pippijn>
adrien: inotify
<adrien>
there is _no_ way to do it fully
<adrien>
inotify doesn't work when you want something complete and portable
<wmeyer>
pippijn: not everything
<wmeyer>
pippijn: actually just linkes you have updated
<pippijn>
wmeyer: except for strings
<fasta>
adrien: you can have multiple build systems.
<fasta>
adrien: one portable one and one non-portable one.
<pippijn>
no.. because I don't know what will be updated
<adrien>
throw in different kernels, NFS or different boots and you lose everything
<adrien>
fasta: what's the point? more maintenance?
<adrien>
for what?
<adrien>
stat() calls?
<adrien>
they're inexpensive
<wmeyer>
pippijn: and then we go towards Haskell, with memoization, which is cool
<pippijn>
yeah, I don't know
<wmeyer>
pippijn: but i have no doubts that is right step over cil
<fasta>
adrien: no, ideally you have one specification out of which you generate the others at release time.
<pippijn>
cil?
<adrien>
ideally, but not in practice
<pippijn>
my parser is better than cil ;)
<adrien>
and you'd need all backend to be equal in features
<wmeyer>
pippijn: yes i know :)
<adrien>
which they never are
<wmeyer>
no doubts
<wmeyer>
but the AST is mutable
<wmeyer>
in CIL
<pippijn>
oh
<adrien>
pippijn: forget about CIL, make it better than yacfe!
<pippijn>
yacfe is weird
<pippijn>
I don't like yacfe
<pippijn>
it's full of assumptions
noj has joined #ocaml
<adrien>
errr
<adrien>
yes
<adrien>
of course
<adrien>
that's the whole point of yacfe
<pippijn>
yes
<pippijn>
I'm not mking a yacfe
<pippijn>
my goal is different
<adrien>
yacfe makes one bug assumption: macros look like C
<adrien>
pffft, parsing C is easy
<pippijn>
parsing it is easy
<pippijn>
type-checking correctly is not that easy
Ptival has quit [Ping timeout: 256 seconds]
<pippijn>
yay, a new nvidia driver
<pippijn>
maybe my chromium problems will finally be gone
lggr has quit [Ping timeout: 268 seconds]
<adrien>
use nouveau, it'll solve many more issues
<pippijn>
actually
<pippijn>
that's not a bad idea
<pippijn>
I'll try that after I tried this new nvidia one
hongboz has joined #ocaml
lggr has joined #ocaml
beckerb has quit [Quit: Konversation terminated!]
<wmeyer>
ok, time for code
sgnb has quit [Ping timeout: 246 seconds]
Cyanure has quit [Ping timeout: 246 seconds]
mfp has quit [Ping timeout: 246 seconds]
mfp has joined #ocaml
fraggle_ has quit [Ping timeout: 246 seconds]
hyperboreean has quit [Read error: Connection reset by peer]
Cyanure has joined #ocaml
sepp2k1 has quit [Ping timeout: 246 seconds]
hyperboreean has joined #ocaml
fraggle_ has joined #ocaml
sepp2k has joined #ocaml
<pippijn>
seems to be better
Anarchos has joined #ocaml
Ptival has joined #ocaml
sepp2k has quit [Remote host closed the connection]
Yoric has joined #ocaml
thizanne has quit [Ping timeout: 244 seconds]
ghostbuster2 has joined #ocaml
thizanne has joined #ocaml
<pippijn>
Kakadu: you're the lablqt guy, righ?
<pippijn>
right*
lggr has quit [Ping timeout: 244 seconds]
lggr has joined #ocaml
pr_ has joined #ocaml
<pippijn>
Kakadu: how is that going?
dopamean has joined #ocaml
<Kakadu>
aaagh
<Kakadu>
I decided that is not a good idea to connect QtGui with OCaml because some features it seems to be impossible to implemnt but without them bindings will be very poor
wagle_ has joined #ocaml
<Kakadu>
Also I have attempted to have fun wiith QML and OCaml
dopamean has left #ocaml []
<Kakadu>
I almost write very simple bindings generator for API connection
<pippijn>
which feature is impossible to implement?
lggr has quit [Ping timeout: 240 seconds]
<Kakadu>
for example very often constructes are called buy sending an QObject by reference
foo303_ has joined #ocaml
<Kakadu>
when in OCaml I have everywhere pointer
nimred_ has joined #ocaml
<Kakadu>
I'm really confused
<pippijn>
I've never seen that
<pippijn>
anyway, in function calls, reference == pointer
pr has quit [Ping timeout: 274 seconds]
wagle has quit [Ping timeout: 274 seconds]
nimred has quit [Ping timeout: 274 seconds]
foo303 has quit [Ping timeout: 274 seconds]
snarkyboojum has quit [Write error: Connection reset by peer]
maufred has quit [Remote host closed the connection]
<pippijn>
Kakadu: to wrap that one, you need to copy the returned QModelIndex to the heap and store a pointer in ocaml, which you dereference when you pass it to C++
<pippijn>
I think binding Qt to ocaml could be very interesting
<pippijn>
maybe I'll try it myself
<Kakadu>
pippijn: What do you think about QML?
<pippijn>
I like it
<Kakadu>
so you are experienced in it?
* adrien
throws Edje at pippijn
<pippijn>
I made a music player/grooveshark client with it
<pippijn>
but I want to integrate QtGui with ocaml
<pippijn>
and QtNetwork
<Kakadu>
Maybe we should make GUI with QML and write performace code with OCaml?
<pippijn>
QML is drawing yourself
<Kakadu>
and...?
<pippijn>
you draw all your widgets yourself
<pippijn>
it doesn't look native
<pippijn>
I know everybody is going into the app world now
<adrien>
QML is not widgets then
lggr has quit [Ping timeout: 246 seconds]
<pippijn>
but I like normal applications
<pippijn>
adrien: QML widgets are only logic, you need to draw them yourself
<pippijn>
it's very easy to do so
<pippijn>
but it will look the same on every platform
<pippijn>
which is not what I usually want
<pippijn>
I made some cool qt apps with qtgui, but I would like to do more in ocaml
<Kakadu>
pippijn: I remembered WORA. maybe there same abbr. for GUI
<pippijn>
and lablgtk is not the way I want to go
<Kakadu>
GTK is ugly
<adrien>
whyN
<adrien>
why?
<adrien>
GTK isn't ugly; your theme is
<pippijn>
I lik eqt :)
lggr has joined #ocaml
* Kakadu
applauses to pippijn
<pippijn>
oh, I'm looking at qt-jambi
<Kakadu>
I had too
<pippijn>
they just re-implemented the whole QModelIndex class in java
<pippijn>
(it's not big)
<pippijn>
but that's uncool
<Kakadu>
maybe I should reincarnate qtcaml and remember how it works
<pippijn>
qtcaml?
<Kakadu>
lablqt
<pippijn>
oh
<pippijn>
same thing?
* Kakadu
already forget how it is called
<pippijn>
there is a qtcaml on sf.net
<pippijn>
anyway
<pippijn>
I would like to work on that, too
<Kakadu>
pippijn: forget qtcaml on DF
<Kakadu>
SF*
<pippijn>
but I don't know enough about Qt, yet
<pippijn>
about the internals
<pippijn>
and I don't know enough about ocaml C bindings, yet
<adrien>
I really dislike Qt's automatic size management
<pippijn>
oh
<adrien>
which means I haven't been able to understand it _AT_ _ALL_
<pippijn>
it doesn't do that unless you tell it to
<pippijn>
I dislike GTK's automatic size management
<pippijn>
like
<adrien>
well, I haven't managed to get anything good in weeks
<jonafan>
you change font sizes or themes and the layout stays perfect
<pippijn>
that's the only thing I've done with lablgtk
<pippijn>
jonafan: C is fragile
lggr has joined #ocaml
<jonafan>
oh
<adrien>
pippijn: and you had issue with that?
<pippijn>
I had issues with gtk being fragile in C
<adrien>
bbs, need to listen to Tool on the hifi :P
<pippijn>
qt is very robust
<pippijn>
very very very robust
<pippijn>
and I've had rendering issues with gtk, not with qt
<adrien>
that's because of your crappy video drivers =)
<pippijn>
yes
<pippijn>
but qt handles it well
<adrien>
I wouldn't say that
<pippijn>
gtk apps were unusable, qt apps were fine
<adrien>
it might just avoid the path by luck
<adrien>
but you're complaining about the wrong thing
<pippijn>
yes
<adrien>
(quite probably)
<pippijn>
anyway I think it is interesting to make ocaml bindings for a large C++ library
<pippijn>
and Qt has its own resource management concept
<pippijn>
object graphs
<pippijn>
trees, actualy
sgnb has joined #ocaml
<pippijn>
when you create an object, you pass the creator object (the "parent") to that object's constructor
<pippijn>
then, when the parent is deleted, the children are all dead, to
<pippijn>
o
<pippijn>
Kakadu: what are your thoughts on that?
<pippijn>
I wonder how qt-jambi or other bindings handle that
<pippijn>
if Qt used refcounted resource management, that would be easy
<Kakadu>
You are confused to catch the moment of object's deletion?
<pippijn>
ocaml would hold 1 or more references and when the ocaml object is GC'd, the C++ reference counter is decremented
<pippijn>
Kakadu: yes
lggr has quit [Ping timeout: 256 seconds]
<pippijn>
the problem is
<pippijn>
you create an object in ocaml, then another object as child of that object
<pippijn>
you keep the child in your ocaml code, somewhere, in a list or something
<pippijn>
the parent object goes out of scope and the ocaml GC decides to delete it
<pippijn>
then the C++ side of the child object will be dead, too
<pippijn>
but ocaml still holds a reference to it
<Kakadu>
Qt delete children before parent?
<pippijn>
yes
<pippijn>
in ~QObject, all children are deleted
<Anarchos>
pippijn you must use finalized custom objects
<Kakadu>
pippijn: I can't understand logical jump from `the parent object goes out of scope and the ocaml GC decides to delete it` to `then the C++ side of the child object will be dead, too`
<Kakadu>
s/jump/transition/
lggr_ has joined #ocaml
eikke has joined #ocaml
<Kakadu>
In my implementaion (I think) if OCaml values are GCded Qt values can still alive
<pippijn>
Kakadu: ah
<pippijn>
yeah.. so you need to manually manage the C++ objects
<pippijn>
that's not so nice
lggr_ has quit [Ping timeout: 244 seconds]
<pippijn>
Anarchos: and what should I do in the finaliser?
<Kakadu>
pippijn: what kind of manually managin?
<pippijn>
new and delete
lggr has joined #ocaml
<Kakadu>
I still don't understand
<pippijn>
okay
<Anarchos>
pippijn you can keep track of deletion between c++ and ocaml code in teh finalizer
<pippijn>
QObject *parent = new QObject(NULL);
<pippijn>
QObject *child = new QObject(parent);
<pippijn>
delete parent;
<pippijn>
now, child will also be deleted
<Kakadu>
yes
<pippijn>
in ocaml, I don't want to do "delete parent"
<pippijn>
Anarchos: yes, but what should it do?
<pippijn>
because it can't just delete the C++ object in the finaliser
<pippijn>
let ob = let parent = new qobject in let child = new qobject ~parent in child in ... something using ob ...
<pippijn>
parent is out of scope
<Kakadu>
Yes
<pippijn>
so it can be collected while child is still around
<Kakadu>
and ocaml's parent will be collected, but C++ won't
<pippijn>
right, so you have a memory leak
wieczyk has joined #ocaml
<pippijn>
because nobody holds a pointer to parent, anymore
<Kakadu>
C++ parent?
<pippijn>
right
<Kakadu>
Why it will not be collected by QT?
<Anarchos>
pippijn first, did you read the chapter in the manual about ocaml and C interfacing ?
<pippijn>
Anarchos: yes
<pippijn>
Kakadu: because Qt doesn't have a garbage collector
<wieczyk>
Hi, is it possible to use file-system hierarchy to make some structure for project. For example I would like to have parsers for two languages in project, and I would like to have Lang/X/Parser.mly and Lang/Y/Parser.mly, is it possible to achieve? I did not find any information that directory structure is mapped into mudule hierarchy.
<Anarchos>
pippijn i had to wrap the C++ object in my own version, calling ocaml back in the destructor to trace this destruction
<pippijn>
Anarchos: ah, that's wonderful
<pippijn>
except I can't modify QObject's implementation
<Kakadu>
wieczyk: Have you tried oasis?
<pippijn>
I'm wrapping an existing C++ library
<Kakadu>
pippijn: Actually you can
<Anarchos>
pippijn just overload the destructor
lggr has quit [Ping timeout: 246 seconds]
<wieczyk>
Kakadu: no
<Kakadu>
wieczyk: Try it!
<pippijn>
hmm
<pippijn>
okay, I need to think about it
<wieczyk>
Kakadu: but this is only a build system? Does it impact on directory-structure-to-module-hierarchy-mapping?
<pippijn>
it would mean that every object that goes into ocaml is in fact of a subclass of a C++ class
<pippijn>
and since almost all Qt objects are non-copyable..
<Anarchos>
pippijn yes, a C++ class whose goal is to call ocaml finalizer in destructor and so on
lggr has joined #ocaml
<Kakadu>
wieczyk: It is most used build system. I don't know if it does what you want because your request is a little bit strange. If oasis willl fail try omake
<pippijn>
so the ocaml finaliser would then set the internal pointer to null or something so further attempts to access it from ocaml would raise an ocaml exception?
<pippijn>
because there may be references to the C++ object in ocaml code
<Anarchos>
pippijn no idea but ocal finalizer can call c++ code and c++ overloaded destructor can callback to ocaml
<Anarchos>
pippijn so you can do go back and forth between the two worlds
<pippijn>
qt objects have signals
<pippijn>
"destroyed" signal
<pippijn>
I could use that
<pippijn>
ok, 4AM, good night
<Kakadu>
pippijn: see you later
jpdeplaix has quit [Ping timeout: 268 seconds]
<wieczyk>
Kakadu: I dont know what is a strange in mapping directories into hierarchy, almost every language does it - Coq, Haskell, Perl, etc
jpdeplaix has joined #ocaml
lggr has quit [Ping timeout: 246 seconds]
<Kakadu>
wieczyk: maybe I dont clearly understand what you want. Maybe somebody else can help or you can write to maillist
<wmeyer>
wieczyk: If you use bare ocamlbuild; without oasis, you can try *.mlpack
<wieczyk>
Currently I have simple and ugly Makefile :-)
<wmeyer>
wieczyk: at the moment we don't have a decent namespace manager or compilation manager
<wmeyer>
wieczyk: consider ocamlbuild
<wmeyer>
wieczyk: there is an option in ocaml compiler called -for-pack
<wieczyk>
wmeyer: Thanks, I am going to check in documentation what it means.
<wmeyer>
and -pack which does want you want
<wmeyer>
(almost)
<wieczyk>
Kakadu: maybe ,,namespace'' is a better word, sorry for weird synopsis.
<wmeyer>
wieczyk: Prosze
<wieczyk>
hehe
<wieczyk>
Are you Polish or just know some polish phrases?
<thelema>
wieczyk: ocaml should shortly gain namespaces (possibly by 4.00.1)
<wmeyer>
wieczyk: I'm Polish
<wmeyer>
thelema: Let's pray OK? :-)
<wmeyer>
thelema: is it uncorfimend information from Gabriel
* adrien
buys wmeyer new fingers :P
<wmeyer>
I would love to have SML Compilation Manager style thing
lggr has joined #ocaml
<thelema>
wmeyer: this is based on discussions with both gabriel and fabrice at OUD
<wieczyk>
wmeyer: What is it?
<wmeyer>
wieczyk: So the modules scale well, but up to some point
<wmeyer>
wieczyk: on the level of the libraries you want some transparent way of abstracting things
<wieczyk>
btw: any plans to add LLVM backend for ocaml or some support for SMP? It seems that any SMP-project is dead, I have written email to o4mp project but no one responded me.
<wmeyer>
that's what would be a namespace
<thizanne>
thelema: what is the difference between a namespace and a module ?
<wmeyer>
wieczyk: but compilation manager is more than that
<thizanne>
more exactly, what would namespaces allow which is not possible with modules ?
<thelema>
wieczyk: OCaml's support for SMP is likely far off. LLVM backends have been written, but none have been high enough quality to make it into the base distribution
<thelema>
thizanne: linking two foo.cmi files that do different things into one executable
<wieczyk>
I hope that no-SMP and no-LLVM will not be a foot-shot for Ocaml liveness.
<wmeyer>
thizanne: I would think that namespace could be for instance extended. Namespace goes beyond ocaml language and start to overlap with build system.
ghostbuster2 has quit [Ping timeout: 248 seconds]
<thelema>
thizanne: right now, ocaml's filename -> module wrapping space is flat
<wmeyer>
(there are subtle differences; quite many)
<thelema>
namespace support makes using other peoples' code easier, because you don't have to worry about global module name collisions
<wmeyer>
yes
<adrien>
well, and possibly less build tool work
maufred_ has joined #ocaml
<thizanne>
ok
<wmeyer>
adrien: exactly. We really want this to be robust
<thelema>
I'm hoping that compiler support for namespaces can lead to automatic cross-package dependency discovery
<wmeyer>
I think ocaml repository can't afford mistake with tooling anymore
<adrien>
also, with 4.00, something like type-conv could be implemented "offline", right? (offline meaning not as a preprocessor but as two steps: dump the required info, generate a source file)
maufred has quit [Ping timeout: 241 seconds]
<thelema>
although ocp has plans to do this without namespaces
<thelema>
adrien: huh? why couldn't type-conv be done offline before?
<thelema>
adrien: all camlp4 can spit out source files
BiDOrD_ has joined #ocaml
<adrien>
sorry: offline without camlp4 :P
lggr has quit [Ping timeout: 245 seconds]
<adrien>
in other words
<adrien>
offline without something too complex
sivoais_ has quit [Quit: leaving]
<wieczyk>
I think that camlp4 has one bad thinks. First, camlp4 vs camlp5 and revisited syntax vs original one. I think those splits should not exist in not much popular tool/language.
<thelema>
adrien: ah, yes. with compiler-libs, the compiler can produce a typedtree that can be processed to do the modification
<wieczyk>
two bad things*
<thelema>
I dunno if there's a nice printer for that typedtree
sivoais has joined #ocaml
<adrien>
thelema: ok, thanks
<adrien>
I think I'll do with this until there is RTTI support
<wmeyer>
wieczyk: yup, take into account that revised syntax was invented with quotations in mind
lggr has joined #ocaml
BiDOrD has quit [Ping timeout: 248 seconds]
<wmeyer>
wieczyk: some of the code generators can be written using quotations using the original
<wmeyer>
so no, it's not just tide up, it's to make life easier. That's said I've never used revised syntax, even though I generate some code
<wmeyer>
can=can't
<wmeyer>
(and to be honest don't like revised syntax)
<wieczyk>
But as I understanded examples for camlp4, It is possible to do syntax-extension to revisited syntax with is not working with original syntax.
<wieczyk>
It can lead to many complications in some big project or in world where Ocaml is very popular :-)
<jonafan>
i wonder what that world is like
<wmeyer>
wieczyk: of course, it's different concrete syntax and different grammar rules
<adrien>
I like half of the revised syntax
<adrien>
which is why I'm in favor of the revised-revised syntax
<adrien>
s/the/a/
<wmeyer>
adrien: maybe 2D syntax, that would make code generators similar to WhiteSpace language :-)
<wmeyer>
that's actually interesting point, how the template haskell uses quotes with it's offside rules
lggr has quit [Ping timeout: 248 seconds]
chambart has joined #ocaml
<wmeyer>
I think the biggest pain with Camlp4 syntax is that none of the Emacs modes can handle it
<wmeyer>
(TypeRex chokes as well)
<adrien>
heh, that's true
<wmeyer>
adrien: but the problem is actually with Emacs not with OCaml here
<wmeyer>
(I think)
_andre has quit [Quit: leaving]
lggr has joined #ocaml
<adrien>
too many things to do in order to get the revised syntax
<adrien>
doesn't it require camlp4?
<adrien>
and in that case, it sounds pretty bad considering camlp4 can now be disabled
<wieczyk>
wmeyer: Does -pack solve a module name conflicts?
lggr has quit [Ping timeout: 264 seconds]
Yoric has quit [Ping timeout: 264 seconds]
lggr has joined #ocaml
<wmeyer>
wieczyk: nope
<wmeyer>
is there anyway to do:
<wmeyer>
include Type with t := prim_t
<wmeyer>
hm I want to include a module with renaming one of the types
<wmeyer>
to avoid clashes with a new type name
<wmeyer>
it seems like I want to do
<wmeyer>
include (Type : module type of Type with t := prim_t)
<wmeyer>
<wmeyer>
but it's not working
<wmeyer>
adrien: yes, because the Revised syntax was designed for Camlp4
<adrien>
and it also means it's going to take _much_ longer to compile
<wmeyer>
in fact OCaml syntax is so nice, but in many ways ambigous for parsers and code generation purposes
lggr has quit [Ping timeout: 268 seconds]
<wmeyer>
adrien: yes, but nobody uses it right? Only with Camlp4 plugins?
chambart has quit [Read error: Operation timed out]
<adrien>
some people do
<adrien>
not many, that's for sure
<wmeyer>
some, yes
<wmeyer>
in some ways Revised syntax might be appealing, like everything nicely delimited and in some ways consistent
<adrien>
and some people have seen unicorns :P
lggr has joined #ocaml
<wmeyer>
but I really like original
<wmeyer>
adrien: lol
<adrien>
I like some of the revised syntax changes but I find it too heavy sometimes
<adrien>
(makes me think that I really could never do Ada)
<wmeyer>
but some people don't ;-)
<wmeyer>
yay
<wmeyer>
this almost works
<wmeyer>
;)
<wmeyer>
type 'a prim_t = 'a Type.t
<wmeyer>
include (Type : module type of Type with type 'a t = 'a prim_t)
<wmeyer>
<wmeyer>
but looks ugly
lggr has quit [Ping timeout: 240 seconds]
<wmeyer>
actualy i can just nest module
<wmeyer>
now I can't
<wmeyer>
the problem remains
<wmeyer>
I want to include the module
clog has joined #ocaml
<wieczyk>
Can I do something like functor type ?
<wieczyk>
module type A (M : B) = sig
<wieczyk>
...
<wieczyk>
end
<wieczyk>
where B is module type
<wieczyk>
?
CoverSli1e is now known as CoverSlide
lggr has quit [Ping timeout: 256 seconds]
lggr has joined #ocaml
sgnb has quit [Ping timeout: 246 seconds]
ontologi1e has quit [Ping timeout: 265 seconds]
lggr has quit [Ping timeout: 256 seconds]
hongboz has quit [Ping timeout: 256 seconds]
lggr has joined #ocaml
beginner42 has quit [Ping timeout: 265 seconds]
lggr has quit [Ping timeout: 246 seconds]
pngl has quit [Ping timeout: 246 seconds]
lggr has joined #ocaml
Yoric has joined #ocaml
osa1__ has quit [Ping timeout: 248 seconds]
hongboz has joined #ocaml
ghostbuster2 has joined #ocaml
osa1__ has joined #ocaml
lggr has quit [Ping timeout: 265 seconds]
<wmeyer`>
wieczyk: of course: module type A = functor (M : B) -> sig ... end;;