🚀 go-pugleaf

Suppose I have a signature

	signature S =
	sig
		eqtype i

		(* various declarations involving type i *)
	end

and wish to implement a functor

	functor F (s : S) =
	struct
		type j = (* representation for j *)

		(* various appearances of the things in s *)
	end

where I know that type s.i = type j ?

I can think of only one way, which I hate:

	signature RequiredArgToF =
	sig
		datatype j = USELESS_TAG of (* representation for j *)
	end

	functor F (structure s : S and t : RequiredArgToF
		   sharing type s.i = t.j) =
	struct
		local open t in
		type j = j

		(* various appearances of the things in s and *)
		(* lots of USELESS_TAGs *)
		end
	end

This solution requires me to move the type declarations needed in F outside
of F to be sent in as a required argument, and makes me stick tags all over
the place which I don't really need.  If it were possible
to pass F an argument of functor type ((sig eqtype i end) -> S), the result
would be beautiful.  But alas, that might complicate the modules system
type discipline too much.

Suggestions?

-- 
------------------------+-------------------------------------------------
caplan@cs.uiuc.edu	|	Joshua Caplan
			|	Department of Computer Science
			|	University of Illinois at Urbana-Champaign