On Wed, 09 Aug 2006, Jacques Garrigue <garrigue@math.nagoya-u.ac.jp> wrote:
> 
> >   'a 'b. (string -> 'b, 'a, 'b) format
> 
> It clearly has the second type!

Thanks for answering -- I got badly confused by the error message !
(shame on me :)

> >   type 'a fmt = { fmt: 'b 'c. ('a,'b,'c) format }
> >   fun  (s: _ fmt) -> Printf.printf s.fmt, Scanf.sscanf "string" s.fm
> 
> With your definition of fmt, you are requiring 'c to be independent
> from 'a. But If you look at the type of "%s", you see that
> 'a = string -> 'c, so that {fmt="%s"} is not well-typed.

Well, yes, of course, that's obvious after you stated it!  :)

> A solution is to define it as
>   type 'a fmt = {fmt: 'b 'c. ('a -> 'b, 'c, 'b) format}
> 
> The drawback is that only allows formats taking one argument.
> One could add definitions for any defined number of arguments, but I
> don't see any generic solution.

Yeah but I really want to allow as many arguments as the user desires.
That's a bit of an annoyance for printf/scanf like schemes: you have
to know in advance in how many contexts you may want to simultaneously
use an argument of type format in order to put enough type parameters...

So I suppose my best luck to do it cleanly is to use camlp4 to make
the parameter duplication for the user.  Another approach I was
thinking about is to define a new type, say

  type ('a,'b,'c,'d) fmt

and have (for the above application)

  external pr_fmt : (_, _, 'a, 'c) fmt -> ('a, out_channel, 'c) format = "%identity"
  external sc_fmt : ('a, 'c, _, _) fmt -> ('a, Scanf.Scanning.scanbuf, 'c) format = "%identity"
  external ( !/ ) : ('a, _, 'b) format -> ('a, 'b, 'a, _) fmt = "%identity"

  let f s =
    Printf.printf (pr_fmt s), Scanf.sscanf "string" (sc_fmt s)

  f !/"%s %u"

Now, of course ( !/ ) is not completely doing what I want.  If
[pr_fmt] and [sc_fmt] are for purely internal use by the library --
thus user only seeing [/!] -- is the above safe? Is there a way using
Camlp4 to reinterpret a string in the new type (possibly prefixing it
with !/ or another chosen symbol to distinguish it) so that,
say, !/"%i %f" becomes (Obj.magic "%i ... %f": (int -> float -> 'a,
'a, int -> float -> 'b, 'b) fmt) ?

Thanks for your help,
ChriS


P.S. Out of curiosity, is there a type system with inference (say,
extending the one of OCaml) that can handle this kind of thing cleanly?