Hello

I'm trying to acheive the following effect in Ocaml that I should be
able to do but am getting very confused with modules and functors...

I have a set of classes all with the structure:-

class Foo {
	Foo* create(std::string x);
	std::string toXml(Foo*);
	... /* Other methods */

	int m_x;
	std::string m_y;
	}
and I have a template function

template<typename T>
void serialisetoxml(T* x) { printf("%s\n",x->toXml().c_str());}

int main()
{
	Foo* f = new Foo(1,"hello");
	serialisetoxml(f);
}

The effect I want to acheive is to have a function that takes any module
that has a toXml function defined and invokes it somewhere.

The closest I got was

(*serialise.mli*)
type t (* this doesn't work...*)
module type Serialise
sig
	val create : Xml.xml -> t (*Using XML-Light here *)
	val to_xml : t -> Xml.xml
end
	

(*foo.mli*)
type t = { x : int ; y:int }
module Make
sig
	val create : Xml.xml -> t (*Using XML-Light here *)
	val to_xml : t -> Xml.xml
end

(*foo.ml*)
type t = { x : int ; y:int }
module Make : Serialiser =
struct
	let create (f: Xml.xml) = Xml.Element("Foo",[("x",string_of_int f.x);("y",f.y))])
	let to_xml (foo : t) = ...
	(* It thinks f is of type Serialiser.t and not Foo.t *)
end

(* main.ml *)
module Sender (C : Serialiser) =
	struct
		let serialisetoxml msg = print_string (Xml.to_string (C.as_xml msg))
	end

(* was hoping for something like this *)
let _ = let m = module Sender(Foo.Make) in
	m.serialisetoxml (Foo.Make (Xml.parse_from "..."));

but I cannot figure out how to declare Foo having a signature of
Serialiser and then use it in main somehow. Assume also that I have
lots of other modules which have same basic interface but additional
methods specific to the modules.

Any help appreciated.

Thanks,


Ronnie

-- 

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners