01:54 <uzdav> anyone have experience with recursive use of OCamlMakefile? I have a project in the "root" directory that builds to a library, and then a few subdirectories, each an application that links the lib from the parent directory. 2 questions: 1) how do I get a dependency on the lib (so the applications get rebuilt if the lib is rebuilt)? 2) How do I get recursive builds to work? (passing the options like native-code, etc)? Thanks!

02:50 <det> Is it possible to acheive overloaded functions in ocaml (in seperately compiled modules) doing something like this:

02:50 <det> module type Showable =

02:50 <det> sig

02:50 <det> type t

02:50 <det> val show: t -> string

02:50 <det> end

02:50 <det> ;;

02:50 <det> module Showable: Showable with type t = int =

02:50 <det> struct

02:50 <det> type t = int

02:50 <det> let show x = string_of_int x

02:50 <det> end

02:51 <det> ;;

02:51 <det> ?

02:51 <det> sorry if I pasted too much but it seems like this channel is fairly idle most of the time :)

02:53 <mrvn_> seems to work. wheres the problem?

02:55 <mrvn_> module type Showable = sig type t val show : t -> string end

02:55 <mrvn_> module Showable : sig type t = int val show : t -> string end

02:55 <mrvn_> module Showable2 : sig type t = float val show : t -> string end

02:55 <mrvn_> Is that what you want?

02:56 <det> I mean, is this a common method of acheiving overloaded functions ?

02:57 <mrvn_> I only know overloading in classes.

02:58 <mellum> Overloading functions would conflict with the type inference, meseems

02:59 <det> oh, argh, you cant define multiple Showable modules with type t being different :/

02:59 <det> I am looking for the equivalent of overloading like haskell's type classes

02:59 <mrvn_> you can only overload with the same type but types can be polymorphic.

02:59 <whee> you might want to look into polymorphic variants

03:00 <whee> although that'd still be different than type classes

03:01 <det> they they provide similar functionality ?

03:02 <whee> http://wwwfun.kurims.kyoto-u.ac.jp/~garrigue/papers/fose2000.html

03:02 <det> how can you overload using classes ?

03:03 <mellum> Hee hee. Only on functional programming language channels, people answer your questions with links to papers.

03:03 <Smerdyakov> Also in #teenchat

03:03 <mellum> Smerdyakov: really, haven't been there for a while

03:06 <det> is iin ocaml, is it possible to define a class Showable and then make two classes Integer and Float which inherit from Eq implementing it's show method ?

03:06 <det> s/is i//

03:08 <det> s/Eq/Showable/

03:21 <mrvn_> det: class virtual showable = object method virtual show : unit end;;

03:22 <mrvn_> class int_showable i = object inherit showable method show = print_int i end;;

03:23 <mrvn_> class float_showable f = object inherit showable method show = print_float f end;;

03:24 <mrvn_> let l = [new int_showable 1; new float_showable 2.];;

03:24 <mrvn_> # List.iter (fun x -> x#show; print_newline ()) l;;

03:24 <mrvn_> 1

03:24 <mrvn_> 2.

03:24 <mrvn_> - : unit = ()

03:24 <det> can int_showable instead be just Integer and inherit from multiple classes (implementing their interfaces) ?

03:24 <mrvn_> det: sure

03:25 <det> ok, that is what I want

03:25 <det> thanks

03:26 <det> mrvn_, so then if I want a function to take anything that implements the Showable interface, how would I do thatr ?

03:26 <mrvn_> det: you just do.

03:27 <mrvn_> det: Sometimes you have to cast the arguments upon useage though.

03:27 <mrvn_> foo (a:>showable)

03:27 <det> how would I define a function that takes two instances of Showable and concatonates their strings ?

03:28 <mrvn_> det: fun x y -> String.concat "" [x#to_string; y#to_string]

03:29 <det> what kind of overhead is there on that dispatch ?

03:29 <mrvn_> a virtual table lookup.

03:30 <det> any idea what that table would look like? :-p

03:30 <det> for a function that only dispatched on to_string

03:30 <mrvn_> its a array of function pointers

03:31 <det> ok

03:31 <mrvn_> so you probably have 2 pointer lookups, first for the table and then for the right function.

03:31 <det> that's acceptable

03:31 <det> but ..

03:31 <Smerdyakov> Same as Haskell type classes, no doubt.

03:32 <mrvn_> Its the minimum you can do for virtual functions.

03:32 <det> how does the function know where in the vtable to_string is located ?

03:32 <mrvn_> except if you store the virtual table in each instance.

03:33 <jemfinch> Smerdyakov: Haskell typeclasses are actually implemented difference.

03:33 <jemfinch> there's a hidden dictionary mapping types to instance methods that's passed to every function taking a typeclass.

03:33 <Smerdyakov> jemfinch, well, I don't think that's part of the definition of Haskell....

03:34 <det> does a paticular function always expect a vtable specific to the functions it requires ?

03:34 <jemfinch> Smerdyakov: no, but that's how it's implemented.

03:34 <mrvn_> What I miss in ocaml is that you can't finalize a function in a class.

03:34 <Smerdyakov> jemfinch, you mean in every Haskell compiler today?

03:35 <mrvn_> With finalized methods or non virtual methods you wouldn't need to lookup the virtual table.

03:35 <jemfinch> Smerdyakov: I mean in GHC. I don't know how it's implemented other than in GHC.

03:35 <jemfinch> but GHC is really I think the only industrial strength Haskell compiler available.

03:36 <Smerdyakov> jemfinch, I don't see what use a dictionary defined on types is unless you keep around runtime type tags...

03:36 <jemfinch> Smerdyakov: I'm just saying, you can ask in #haskell if you don't believe me, but that's how I've heard it was implemented :)

03:37 <Smerdyakov> I'd think you just pass a table of instance methods along with every type classed parameter....

03:38 <det> what do you mean by dictionary ?

03:39 <Smerdyakov> Finite mapping [guess]

03:39 <mrvn_> n8

03:40 <det> how is it different from a table ?

03:40 <Smerdyakov> Possibly implemented in a more efficient way, with respect to some operations

03:40 <Smerdyakov> Such as a balanced search tree

03:41 <det> if you know the offset of the items to be retreived, then a table is as fast as it gets

03:42 <Smerdyakov> Yup, but if the mapping isn't known at compile time, then things get more complicated =)

03:43 <det> but in haskell they are known at compile time

03:43 <det> right ?

03:43 <Smerdyakov> We're talking about an ADT here.

03:43 <Smerdyakov> Not a particular use of it

03:43 <Smerdyakov> Or at least, _I_ am =D

03:44 <det> mrvn_, if you dont even need to specify that you are taking an instance of Showable, what is the purpose of inheriting from it ?

03:45 <mrvn_> det: type inference

03:45 <mrvn_> It detects by itself that the function needs a showable

03:47 <det> can multiple classes define the same method with inheriting from a common class ?

03:48 <mrvn_> det: look at the example.

03:48 <mrvn_> det: or read the manual, I'm falling asleep here. *wave*

03:49 <det> I get type errors with you example

03:49 <det> Is there matbe such thing as a polymorphic class ?

03:50 <mrvn_> works fine here and yes.

03:50 <det>

03:50 <det> This expression has type string but is here used with type unit

03:51 <det> oh, I changed it, I see

03:51 <mrvn_> clclass ['a] foo f = object method bla = (f:'a) end;;

03:51 <mrvn_> class ['a] foo : 'a -> object method bla : 'a end

03:51 <mrvn_> -cl

03:52 <mrvn_> # let i = new foo 1;;

03:52 <mrvn_> val i : int foo = <obj>

03:52 <mrvn_> so, gone for tonight now.

03:52 <det> this isnt as cool as type classes, but still cool :)

05:33 <walters> is there any way i can push a character back onto an input_channel?

05:57 <det> Is it possible to pass around modules as first class objects ?

06:05 <jemfinch> no, it's not.

07:43 <walters> anyone have good examples of using Map?

07:44 <jemfinch> what do you need?

07:44 <jemfinch> you mean the functor, right?

07:44 <jemfinch> let me tarball up my O'Caml directory and you can have access to all my O'Caml code. I'll point you to a good place to see Map, iirc :)

07:45 <walters> yeah

07:45 <walters> cool

07:45 <jemfinch> can you accept DCC SEND?

07:45 <walters> ah...i am not sure

07:45 <walters> try i guess

07:46 <walters> jemfinch: wow, slow :)

07:47 <jemfinch> walters: I'm on a 31k homenet :)

07:47 <walters> ah

07:51 <walters> jemfinch: ok, cool, looks like there's some useful examples in there

07:51 <walters> jemfinch: thanks

07:51 <jemfinch> walters: no problem.

07:51 <jemfinch> let me find you a Map example...

07:51 <jemfinch> go look at ocaml/libsrc/async/async.ml

07:52 <jemfinch> I make a Map there of sockets to handlers.

07:52 <walters> jemfinch: got it

08:07 <walters> holy shit

08:08 <walters> i just wrote about 400 lines of code and i only got about 3 type inference clashes

08:08 <walters> after fixing those it compiled.

08:08 <walters> i love that.

08:11 <jemfinch> yeah, it's pretty cool :)

08:11 <jemfinch> that was one of my favorite things about writing IRC bots in O'Caml.

08:11 <jemfinch> if the code compiled, it'd work, and I wouldn't have many runtime crashes.

08:11 <jemfinch> pychecker alleviates a lot of the crashes I'd get in my Python IRC bot otherwise, and gets me almost the same king of uptime.

08:12 <walters> 755LISP> FOO

08:12 <walters> Unbound variable FOO

08:12 <walters> Your lisp code sucks! (evaluation error)

08:12 <walters> sweet

08:12 <walters> getting closer...

08:14 <walters> ok, 3am, time to sleep

08:14 <walters> thanks again jemfinch