<travisbemann>
how do you declare two modules to be mutually recursive then?
<palomer_>
it does!
<palomer_>
travisbemann, they have to be in different files
<palomer_>
OR, if their signatures aren't mutually recursive, you can fake it with functors
<palomer_>
flux, how do you use an interface?
<travisbemann>
okay, that is of little use... (considering that i tend to often use submodules a lot to essentially closely associate functions with types)
<det>
Yeah, I tend to use submodules in the same way.
<travisbemann>
part of it is that i honestly don't really like the ocaml object system, and prefer to use the module system to provide modularity alone
<bluestorm>
i think that in general it is often a good idea to decouple such dependencies to have a non-cyclic dependency tree
<bluestorm>
by trying to do that you'll often have insights on how to simplify, or generalize, your design
<det>
travisbemann, I think the object system can be useful to express generic interfaces. You can use closures instead, but that means your initialization is linear to the number of record members (or "methods") instead of O(1) with objects.
<bluestorm>
(for example switching the common part in a little submodule can ease the reuse of this part in the future)
<travisbemann>
det: i would be more inclined to use the ocaml object system if it were something more along the lines of CLOS, such that it would be intrinsically centered around multiple method dispatch as opposed to dispatched methods belonging to particular objects
<det>
Same with space.
lety has joined #ocaml
<det>
I'd prefer type classes.
<bluestorm>
i don't think type classes and the ocaml object system are equivalent at all, or even intended to the same purpose
<travisbemann>
for a static language like ocaml, a more haskellish type class system might be more appropriate, but one way or another i strongly favor using methods which do not actually belong to particular objects
<det>
type classes can express the part of the ocaml object system that I think is useful.
dibblego has quit ["Leaving"]
<bluestorm>
travisbemann: i think you can use this type of programming within the ocaml object system
<bluestorm>
# let use_foo_object obj = obj#foo;;
<bluestorm>
val use_foo_object : < foo : 'a; .. > -> 'a = <fun>
<travisbemann>
that's part of why i prefer to just use a module-system based approach rather than actually using the object system
<travisbemann>
even if i have to go and use closures to gain the actual functionality of the object system
<bluestorm>
(i may not understand what you mean, as i'm quite unfamiliar with object systems in general, but that doesn't look like belonging to any object/class)
<travisbemann>
but at an implementation level that really still is using a method belonging to an object
<bluestorm>
hmm
<travisbemann>
as opposed to with true multiple dispatch, where methods really do not belong to objects and where methods can be added by the programmer after the fact rather than being intrinsically declared with classes
<lety>
just wandering does ocaml have bindings to win32 api?
* travisbemann
wonders, though, how you would actually implement multiple dispatch within an ocaml-like model....
<lety>
thats a bit sad
<lety>
haskell has at least 100
<bluestorm>
lety: wich list ?
<lety>
the one you gave me a link to
<det>
I think you are confusing "latest updates" with "complete list of ocaml libraries".
<lety>
oh
<alexyk>
GODI installs things into pkg-lib/ alongside std-lib/ and site-lib/, so if I want to add extlib.cmxa I have to give this funny path to ocamlopt: -I +../pkg-lib/extlib
<alexyk>
anything better?
<bluestorm>
you could use ocamlfind
<alexyk>
yeah, but bare knuckles -- is there an environment variable pointing to the root of std-lib/ or std-lib?
<bluestorm>
ocamlc -where ?
<alexyk>
right-right... so GODI basically assumes you'll use ocamlfind to get pkg-lib stuff I see, no nice manual way to add it as with -I +blah
<det>
-I `ocamlfind query extlib` isn't that bad, is it?
<alexyk>
looks good, especially after aliasing "ocamlfind query" to oq or something
<bluestorm>
then oq ocamlc -package extlib -linkpkg foo.ml should not be that bad either
znutar has left #ocaml []
fremo has quit [Read error: 104 (Connection reset by peer)]
<alexyk>
Array version is cookin' right as we speak
<alexyk>
it reads triplets (movie,customer,rating) where customers are not in order
<bluestorm>
hm btw
<alexyk>
maps them onto consecutive 1..N range and reprints triplets
<bluestorm>
i just noticed that you can tweak GC parameter with OCAMLRUNPARAM, this will be useful in the future
<bluestorm>
indirect thanks to alexyk :]
<alexyk>
bluestorm: beginner's luck :)
<flux>
palomer_, whenever I would need to use an actual object, I can accept an argument with the interface type
<bluestorm>
hm
<bluestorm>
alexyk: it might come from List.map
<bluestorm>
the standard List.map is not tail-recursive
<bluestorm>
try to use Extlib's List.map instead
<bluestorm>
or, if your problem allows it, List.rev_map
<bluestorm>
hmm
<alexyk>
my lines are all triplets very short
<bluestorm>
actually it seems your List.map use is very specific to short lines
<bluestorm>
yes
<alexyk>
so that List.map just breaks a line into 3 numbers
<bluestorm>
this part is not very elegant btw
<bluestorm>
maybe you could do with
<flux>
alexyk, does it produce a core dump?
<bluestorm>
Scanf.sscanf " %d %d %d" ?
<flux>
you could use gdb to find out where it crashes
<flux>
(if that was the problem)
<alexyk>
bluestorm -- yes, cool
<bluestorm>
(wich is waiting for a (int -> int -> int -> 'a) function
<bluestorm>
)
<bluestorm>
hm
<alexyk>
flux: no core dump! zsh says segfault or bus error
<bluestorm>
and why don't you use a dichotomy/bisection instead of your linear search ?
<flux>
alexyk, ulimit -c unlimited
<alexyk>
after I tweaked the script
<alexyk>
bluestorm: hacked after midnight for a quick result!
<bluestorm>
:D
<bluestorm>
(let infinity = max_int might suit your needs)
<alexyk>
btw -- why can't I define two functions with let prescan = ... and renumber = ... ?
<alexyk>
I can `and' two values but not two functions?
<bluestorm>
yes you can
<bluestorm>
but not "and rec"
<bluestorm>
"rec" is a global property to the whole "... and ... and .." declaration
<bluestorm>
so you only put one after the let
<alexyk>
so my prescan and renumber are rec each but not mutually
<bluestorm>
hm
<alexyk>
will it know what to do?
<bluestorm>
you should not use "and" if your functions are not mutually recursive
<bluestorm>
it will works, but confuse the reader and may induce strange behavior if you're not careful
naufraghi has left #ocaml []
<alexyk>
but then I have to do let f1 = ... in let f2 = ... while f2 i not uding f1
<bluestorm>
(eg. if you use a previously-defined variable named "renumber" in the prescan declaration)
<alexyk>
using
<bluestorm>
yes, what's the problem with that ?
<alexyk>
syntax hints we define some vars for subsequent use in the rest; so I'd rather define mutually independent things with and
<bluestorm>
another trick (this time not applicable to functions) is let a, b = ... , ..... Can be nice for example in let xlen, ylen = 800, 600 in (even more readable than "and" imho)
<alexyk>
ah nice
<bluestorm>
alexyk: ocaml programmers are used to a list of "let .. in" , that won't disturb them
<bluestorm>
while using "and" will have them looking for mutual recursion
<alexyk>
...that's why I so much prefer #light syntax of F#! :)
<alexyk>
no meaningless "in"s
<bluestorm>
hm
<bluestorm>
if you want light syntax, you could begin with taking the ";;" away
<alexyk>
flux: ah! will cook some dumps tmrw, thx!
<alexyk>
btw -- how do I debug ocamlopt binaries, compiling with -g and gdb as usual C?
<tsuyoshi>
ocamldebug
<alexyk>
ah
<tsuyoshi>
you can debug the c parts of a program with gdb but not the ocaml parts
<alexyk>
okok nighty-night US Pacific shores...
alexyk has quit []
Linktim has joined #ocaml
OChameau has joined #ocaml
Yoric[DT] has joined #ocaml
jonafan_ has joined #ocaml
LordMetroid has joined #ocaml
magthe has joined #ocaml
jonafan has quit [Read error: 110 (Connection timed out)]
jonafan has joined #ocaml
jonafan_ has quit [Read error: 110 (Connection timed out)]
jknick has quit ["Lost terminal"]
Demitar has quit [Read error: 110 (Connection timed out)]
LordMetroid has quit [Read error: 110 (Connection timed out)]
Yoric[DT] has quit ["Ex-Chat"]
jonafan_ has joined #ocaml
jonafan has quit [Read error: 110 (Connection timed out)]
jonafan has joined #ocaml
jonafan_ has quit [Read error: 110 (Connection timed out)]
m3ga has joined #ocaml
Linktim_ has joined #ocaml
jonafan_ has joined #ocaml
Linktim has quit [Read error: 110 (Connection timed out)]
coucou747 has joined #ocaml
schme has quit [Connection timed out]
jonafan has quit [Read error: 110 (Connection timed out)]
Linktim_ has quit [Read error: 110 (Connection timed out)]
hkBst has joined #ocaml
hsuh has left #ocaml []
det has quit [Remote closed the connection]
r0bby has quit [Client Quit]
rwmjones has quit [Success]
Linktim has joined #ocaml
filp has joined #ocaml
<flux>
cool, this works: class type a = object method a : int end class type b = object method b : int end let a ((a:#a):#b) = () - dunno what use it is, though :)
<bluestorm>
you mean, specifying several contraints ?
<flux>
it's not actually a constraint, it folds open to type <a : int; b: int; ..>
<flux>
(well I suppose it is? but it doesn't really look like multiple constraints)
<bluestorm>
that's a constraint somehow, "must contain ..."
<bluestorm>
in case of multiple inheritance maybe ?
LordMetroid has joined #ocaml
magthe has quit ["Ex-Chat"]
<flux>
I sort of like ocaml's object system, although I must admit it is complicated and often requires explicit annotation of types
<flux>
but I have that explicit annotation problem anyway as I have functions like with_db : (db_handle -> 'a) -> 'a which I need to pass as a parameter
<travisbemann>
/exit
travisbemann has quit ["leaving"]
det has joined #ocaml
jonafan has joined #ocaml
pango_ has quit [Remote closed the connection]
pango_ has joined #ocaml
Linktim_ has joined #ocaml
Linktim has quit [Read error: 110 (Connection timed out)]
jonafan_ has quit [Read error: 110 (Connection timed out)]
rwmjones has joined #ocaml
magthe has joined #ocaml
LordMetroid has quit [Read error: 110 (Connection timed out)]
<bluestorm>
( those are yoric's lazylists, but there are other impl. out there )
<delamarche>
that's quite the subdomain
Linktim has joined #ocaml
<delamarche>
thanks again :D
<bluestorm>
:]
<bluestorm>
last time i asked him to publish lazy lists as a library separated from his comprehension bundle, he said that was in progress, i guess he'll eventually do that for extlib integration
psnively has quit []
Kopophex has quit [Read error: 110 (Connection timed out)]
szell has quit [Read error: 110 (Connection timed out)]
magthe has quit ["Ex-Chat"]
filp has joined #ocaml
yziquel has quit [SendQ exceeded]
yziquel has joined #ocaml
yziquel has quit [Client Quit]
yziquel has joined #ocaml
OChameau has quit ["Leaving"]
rwmjones_ has joined #ocaml
kotarak has joined #ocaml
fremo has quit [Read error: 104 (Connection reset by peer)]
munga has quit ["Leaving"]
Linktim_ has joined #ocaml
evn_ has quit []
delamarche has quit []
jonafan_ has joined #ocaml
postalchris has quit ["Leaving."]
Linktim has quit [Read error: 110 (Connection timed out)]
<yziquel>
Hello. Is there a command equivalent to objdump -x blahblah.o that can be executed on .cmo files?
<hcarty>
yziquel: I don't know if it works with .cmo files, but ocamlbrowser provides a GUI for browsing OCaml interfaces. It may do what you want.
fremo_ has joined #ocaml
<yziquel>
What I want is to check if my .cma (sorry, not .cmo) file has been compiled with the correct binding to some .o object file. That's why I'd like to check it with something similar to objdump or nm.
<flux>
yziquel, there is objinfo, but I don't know if it does what objdump -x does
<yziquel>
flux: Well, that seems nice. I'll have a look. Thanks.
yziquel has quit ["TinyIRC 1.1"]
yziquel has joined #ocaml
fremo_ has quit ["leaving"]
psnively has joined #ocaml
rodge has quit ["Leaving"]
jonafan has quit [Connection timed out]
jonafan_ is now known as jonafan
ygrek has joined #ocaml
<palomer_>
is there a function like haskell's repeat?
<palomer_>
of type int -> 'a -> 'a list
<flux>
well.. no.. but let repeat n v = Array.to_list (Array.create n v) is an non-performant-but-simple way to do it
<hcarty>
palomer_: Array.make perhaps?
<flux>
I must confess after seeing the trick I've used that a lot, instead of writing/referring to another function written to do that. (although Array.init is much more useful)
yziquel has quit ["TinyIRC 1.1"]
<hcarty>
I always have to look up which of those is deprecated...
<hcarty>
make and create seem to both be used throughout the stdlib
szell has joined #ocaml
<palomer_>
oomph
<bluestorm>
h
<palomer_>
I haven't used arrays in ages
<palomer_>
how do I transform an int to a string ? (Int32 only works with int32s)
<bluestorm>
let rec repeat x = let rec xs = x::xs in xs
<palomer_>
bluestorm, yeah, that's what I implemented
<bluestorm>
a bit dangerous, however
<hcarty>
string_of_int
<bluestorm>
hmm
<bluestorm>
the first "rec" was unnecessary, of course
yziquel has joined #ocaml
yziquel has quit [SendQ exceeded]
yziquel has joined #ocaml
Linktim- has joined #ocaml
<palomer_>
err, that's an infinite list
<palomer_>
is that even useful?
<palomer_>
I have to say, exceptions make my life easier
<flux>
could be, in a rare case :)
<flux>
(I don't think I've ever used them)
<palomer_>
infinite lists?
ygrek has quit [Remote closed the connection]
<bluestorm>
aaah, i thought you wanted an infinite list
<bluestorm>
as the original haskell function
<bluestorm>
flux: i've seen one use case for infinite lists
<bluestorm>
for some implementation of the eratosthene seed, you can use a "wheel" that gives you the index to skip (for example if you want to ignore the multiples of, say, 2, 3, 5 and 7), wich can be neatly represented as an infinite list
<bluestorm>
the problem becomes "how can i create a cycle : 'a list -> 'a list, turning a list into an infinite list ?"
<bluestorm>
and is a bit more tricky
Linktim_ has quit [Read error: 110 (Connection timed out)]
<jlouis>
tie the knot!
postalchris has joined #ocaml
alexyk has joined #ocaml
psnively has quit []
alexyk has quit []
r0bby has joined #ocaml
gene9 has joined #ocaml
gene9 has left #ocaml []
alexyk has joined #ocaml
rwmjones_ has quit [Read error: 104 (Connection reset by peer)]
rwmjones_ has joined #ocaml
alexyk has quit []
schme has joined #ocaml
robozni has joined #ocaml
sporkmonger has joined #ocaml
schme has quit [Remote closed the connection]
schme has joined #ocaml
mbishop_ is now known as mbishop
schme has quit [Remote closed the connection]
schme has joined #ocaml
sporkmonger_ has joined #ocaml
sporkmonger has quit [Read error: 104 (Connection reset by peer)]
bluestorm has quit [Read error: 113 (No route to host)]
LordMetroid has quit [Connection timed out]
kotarak_ has joined #ocaml
sporkmonger_ has quit [Read error: 110 (Connection timed out)]
kotarak_ has quit ["Xaide, leka nosht."]
Demitar has joined #ocaml
kotarak has quit [Read error: 110 (Connection timed out)]
ygrek has joined #ocaml
ikaros_ has quit ["segfault"]
alexyk has joined #ocaml
Demitar_ has joined #ocaml
delamarche has joined #ocaml
<alexyk>
what's the idiom for Array.iter/iteri on a subrange of indices from m to n?
<alexyk>
apart from writing a let rec iter_range :)
filp has quit ["Bye"]
Linktim- has quit [Remote closed the connection]
rwmjones_ has quit ["Closed connection"]
schme has quit [Connection timed out]
<delamarche>
uh, if you don't mind copying you could do the iter on an Array.sub
<delamarche>
or just check the bounds in the lambda you pass to iteri
<delamarche>
i'd imagine if you're doing an iter you're trying to mutate the array, so the latter solution is probably what you want
alexyk has quit []
sporkmonger has joined #ocaml
sporkmonger has quit [Client Quit]
ygrek has quit [Remote closed the connection]
<jonafan>
man, i wrote a parallelized mergesort in C# because we have an 8 core computer
hkBst has quit ["Konversation terminated!"]
<jonafan>
The built in sort is faster (presumably because it calls C) but only works one core
<jonafan>
rip off!
authentic has quit ["Reconnecting"]
authentic has joined #ocaml
<jonafan>
8 threads on my sort run about twice as fast as 1 thread
<jonafan>
and worst of all, ocaml is much slower than all cases
<mbishop>
try F#? :)
RobertFischer has joined #ocaml
<jonafan>
nah
<jonafan>
i'm really surprised that ocaml generated machine code is slower than .net
<RobertFischer>
Mutable data much?
<jonafan>
i'm using arrays in both cases
<RobertFischer>
If you have a more purely functional approach (less mutable data), Ocaml is much faster.
<jonafan>
you mean in both languages
<jonafan>
meaning, functional style C# would be slow
<jonafan>
(and incredibly ugly)
<pango_>
ocaml GC is protected by a global mutex, so threaded ocaml programs don't benefit from multiple cores
<jonafan>
yeah i know
<RobertFischer>
Yeah. Mutable data solutions and some threaded solutions are faster in F# than in Ocaml. Immutable data, list manipulation, and tail recursion solutions are faster in Ocaml.
<mbishop>
I wonder, how come there are a number of SML compilers, but only one for OCaml? has no one bothered to make their own?
<jlouis>
mbishop, lack of specification hampers it
<jlouis>
besides, it takes serious balls to write a compiler in production quality class
<RobertFischer>
It's the difference in GC between the CLR and Ocaml.
<jonafan>
so basically, forget about fast sorting algorithms in ocaml
<RobertFischer>
And it's the big problem with porting Ocaml to the JVM.
<RobertFischer>
You can sort fast in Ocaml. You just do it in a functional, not imperative way.
<jonafan>
Array.sort is a lot faster than List.sort ...
<RobertFischer>
Or, you do what you probably should be doing from the start and store things into a sorted data structure.
<RobertFischer>
Do you have numbers for that? I'll buy it.
<RobertFischer>
But I'm just curious how true that assertion is.
<jonafan>
i can make some up pretty fast!
<jonafan>
okay i have two programs
<jonafan>
one generates 4125000 random ints in a list, the other in an array, and both then sort the array
<jonafan>
i compiled them both to machine code and bytecode and i'm timing them
<jonafan>
List took 13.2 s as machine code and 44.1 s as bytecode
<qwr>
RobertFischer: one problem is also, that ocaml OO doesn't map very well into jvm classes
* qwr
suspects that's also reason why F# has only C# style OO implemented
<jonafan>
wow, array's bytecode is taking forever
<RobertFischer>
qwr: Yeah. Abandon the approach of mapping Ocalm OO onto JVM classes in any kind of direct means...have an "Ocaml Class" concept, like Groovy has their "Groovy class".
<jonafan>
Array: 10.8s and 1m15.1s
<jonafan>
sooooo
<RobertFischer>
jonafan: That's weird. Something went south with your benchmarking.
<jlouis>
less than 3 seconds in difference from the list
<jlouis>
pretty good
<jonafan>
yeah i'm surprised at the results in several ways
<RobertFischer>
And this is just a handwave assertion, but I bet if you pass around and match and work with lists instead of arrays, you'll recoup the sort cost pretty fast.
<jlouis>
In ML, you don't win by brute force. You win by being clever
<jlouis>
In C you often win by brute-force because clever takes forever in implementation time
<kig>
i hear that all the time in ruby performance discussions
<jonafan>
waaaait i messed something up
<kig>
"ruby isn't slow, you just need to use it smartly. and btw performance doesn't matter!"
<jonafan>
gotta rerun the array test
<qwr>
ml is still quite good at brute-force, when compared to other high-level languages ;)
<jonafan>
Array: 7.7s and 58.1s
<yziquel>
Hi. After running ocamlc -c -cc "gcc -fPIC -o stub.o" stub.c and running nm famstubs.o
<jonafan>
List took 13.2 s as machine code and 44.1 s as bytecode
<yziquel>
I get U caml_alloc_custom
<yziquel>
Is it supposed to be so?
<jlouis>
kig, the difference is that in Ruby, everything is slow no matter how clever you are.
<kig>
yes, with the final copout of "implement the bottlenecks as C extensions"
<jlouis>
You do want to be able to call C through a FFI when someone has invested years on some code in C.
Kopophex has joined #ocaml
* qwr
looked at shootout ocaml vs mlton... and their about equal
* qwr
would have hoped more from mltons full-program analysis... ;)
<jlouis>
qwr, yes for that kind of small problems.
<RobertFischer>
Okay, my drugs are getting to me (in the hospital for post-deviated septum surgery). See you later.
<qwr>
jlouis: meaning that ocaml also inlines there enough?
<jlouis>
qwr, ocaml can't inline or monomorphise across 2 different compilation units
<jlouis>
mlton can
<jlouis>
in fact, mlton monomorphises *any* polymorphic function
<pango_>
ocaml does inline across compulation units
<pango_>
s/compulation/compilation/
<jlouis>
oh!
postalchris has quit [Read error: 110 (Connection timed out)]
<mbishop>
so a new ubuntu came out today, ocaml 3.10 should finally be in apt :)
<pango_>
I think for short functions it keeps some intermediate code version in the module, but I'm not sure
<jlouis>
3.10.0-8 mbishop ;)
<mbishop>
jlouis: :P
<mbishop>
My update is still going, the mirrors are getting hammered heh
<RobertFischer>
jlouis: How does the "monomorphizing" work?
<qwr>
mbishop: has been some time in debian testing ;)
<jlouis>
mbishop, I cheat. I always update a day or 3 before the release
<RobertFischer>
If I take a value from stdin, and if that value is 1, then it uses class A, but if the value is 2, then it uses class B (which inherits from A), how does it know downstream which to use?
<jlouis>
RobertFischer, given a polymorphic function, track it's call-sites and make a version with monomorphic types where needed
<jlouis>
since the compiler is whole-program you know all call-sites so it is a dead easy pass
<jlouis>
"dead easy" I may add
<RobertFischer>
So, in my scenario, every downstream call will be replaced with something like "if A, then call A#foo; if B, then call B#foo"?
<jlouis>
RobertFischer, SML has no objects
<jlouis>
or classes
<RobertFischer>
Oh. So it just dumps the concept of inheritance.
<jlouis>
yes, there is no subtyping in SML
<RobertFischer>
I'll take Ocaml's solution. Sometimes inheritance is nice. :)
<jlouis>
I should probably take up compiler hacking again and hack an SSA-PRE pass for mlton :)
<RobertFischer>
Anyway, I'm crashing hard. See you all later.