]> From: Nick Name <nick.name@inwind.it> > Here it is: > > module type ARROW = > sig > type ('a,'b) t > > val arr : ('a -> 'b) -> ('a,'b) t > val (>>>) : ('a,'b) t -> ('b,'c) t -> ('a,'c) t > val (&&&) : ('a,'b) t -> ('a,'c) t -> ('a,('b * 'c)) t > end [...] > (* now in the toplevel > > # let t = time >>> time;; > val t : ('_a, float) Var.Time.t = <abstr> *) > > Well, that '_a is exactly what I wish to avoid; I see. > I had this suggestion privately (with simplified type declarations): > > # type ('a,'b) sf = Arr of ('a * float -> 'b);; > type ('a, 'b) sf = Arr of ('a * float -> 'b) > # let (>>>) f1 f2 = match f1(),f2() with (Arr f1),(Arr f2) -> Arr (fun > (a,s) -> f2 (f1(a,s),s));; > val ( >>> ) : (unit -> ('a, 'b) sf) -> (unit -> ('b, 'c) sf) -> ('a, 'c) > sf = > <fun> > # let time () = Arr (fun (_,t) -> t);; > val time : unit -> ('a, float) sf = <fun> > # let t () = time >>> time;; > val t : unit -> ('a, float) sf = <fun> > > and yet I don't know if it's satisfactory. What would be the problem? This is just about delaying the arrow construction, to make sure that no side-effect may occur. > however I realize that this > is a general problem with caml view of polymorphism, probably driven by > type-inference decidability issues; in fact I can't write a polymorphic > compose operator in general, because I will get exactly the same > problems. This has nothing to do with decidability at all! Again, this is the value restriction, which solves a problem with soundness in presence of side-effects, and this is a FAQ. And you can perfectly define a polymorphic compose operator. # let compose f g x = f (g x);; val compose : ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b = <fun> The only difficulty is that to create polymorphic functions with this operator you must apply eta-expansion. # let swap (x,y) = (y,x);; val swap : 'a * 'b -> 'b * 'a = <fun> # fun p -> compose swap swap p;; - : 'a * 'b -> 'a * 'b = <fun> By the way, if you are ready to break abstraction (which in your case doesn't seem essential), you can build a t with the right polymorphic type: # let t = T(fun s -> let T a = time >>> time in a s);; val t : ('a, float) Var.Time.t = ... Not very clean, but you can replace time >>> time by any polymorphic expression. It can be made a bit simpler by using a record instead of a sum: # let t = {f=fun s -> (time >>> time).f s};; Jacques Garrigue ------------------- 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