[Caml-list] Printf and format

[Caml-list] Printf and format

[Sylvain LE GALL]

Hello,

I am sorry to ask a so silly question, but i need it for my personnal
work, and i could not find it in the archive.

Is there a way to transform string to ( 'a, out_channel, unit, unit)
format. I need this function to use it with something like :

Printf.printf (my_fun "X, Y") "coucou";;

I look at the code and see a function scan_format, but it seems to be
forbid to use it. 

Any idea ?

Thanks
Sylvain LE GALL

-------------------
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

Re: [Caml-list] Printf and format

[Pierre Weis]

> Hello,
> 
> I am sorry to ask a so silly question, but i need it for my personnal
> work, and i could not find it in the archive.
> 
> Is there a way to transform string to ( 'a, out_channel, unit, unit)
> format. I need this function to use it with something like :
> 
> Printf.printf (my_fun "X, Y") "coucou";;
> 
> I look at the code and see a function scan_format, but it seems to be
> forbid to use it. 
> 
> Any idea ?
> 
> Thanks
> Sylvain LE GALL

As once announced on this list, the new release of Objective Caml will
introduce a lot of novelty on the format type.

Besides new convertion specifiers that you could find in the Printf
and Scanf documentation (C, S, B, F, !, ...), there are now several
different new functionalities provided by the new compiler which are
relevant to your question:

0) converting arbitrary format string to a regular strings

1) converting CONSTANT strings to the corresponding constant format string

2) concatenating format strings (very often feature 0 and 1 are used
in conjonction just to implement format strings concatenation).

Those primitives are provided with respective names string_of_format,
format_of_string, and binary infix operator ( ^^ ). I think they are
useful and powerful: those new features should leverage the need for
using Obj.magic and type constraints inside programs that directly
manipulate format strings.

However, this introduction of new format strings primitives has
necessitated the addition of a new type variable to the format type
that now get 4 variables instead of 3: this extra variable is
mandatory to adequately type-check the kprintf function and to give an
appropriate type to the new format concatenation operator (appropriate
here just meaning correct, i.e. safe).

This is normally completely transparent to programs that just use
printf-like functions: the printf functions get a type using the new
format type constructor, its format string get also the extra type
variable in its typing, the type-checker hapilly handles the
application and you will not even notice the modification.

However, this new type variable indeed introduces a backward
incompatibility, if you ever used the format type constructor into
your programs, as part of the type constraints appearing either in the
interface files or directly into your programs (to force an expression
to get a format type).

In this case, the modification of your program is easy and as follows:

 Just duplicate the last variable of the format type constructor argument.

This systematic way to correct programs that mentioned the format type
constructor is a minor inconvenience for the sake of the useful
additions described above.

If the users on this list feel it too complex and way too boring to
modify their programs like that, we may try to implement various hacks
to leverage the burden. I should mention that, even if I'm not
enthusiastic at all to have been obliged to introduce such a backward
incompatibility into the compiler, I would be ashame to add such (not
so clean) hacks into it as well. In particular, because in this case,
the modification of programs is almost trivial.

Back to your problem: the features described here may your for some
``my_fun'' functions, but the general case is not properly covered by
them. What we need is a general function that reads a format from
within a string that is NOT a constant. This is a kind of dynamic
convertion reminiscent of int_of_string or float_of_string, that
checks that the string can be indeed considered as an integer of
floatting point number.

I propose (and have implemented for my own programming of a general
translation function) a new function [read_format], such that

[read_format pat s] returns the string [s] as a format string that has
the same type (hence the same ``printf meaning'') as [pat], the first
format string argument.

For instance,

read_format "The number %d is odd" "Le nombre %d est impair"

returns "Le nombre %d est impair" as a format string with the same
type as "The number %d is odd".

This function is more general that the one above since now in
[read_format pat s] the string [s] is not mandatorily an immediate
string constant: it can be obtained from an arbitrary computation, as
read from a file.

The Typechecking of read_format would be:

read_format :
 ('a, 'b, 'c, 'd) format -> string -> ('a, 'b, 'c, 'd) format

If considered useful, this function could be added, for instance as
part of a new internationalization module.

Hope this helps,

Pierre Weis

INRIA, Projet Cristal, Pierre.Weis@inria.fr, http://pauillac.inria.fr/~weis/


-------------------
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

Re: [Caml-list] Printf and format

[Sylvain LE GALL]

On Sat, Jul 05, 2003 at 12:26:49PM +0200, Pierre Weis wrote:
> > Hello,
> > 
> > I am sorry to ask a so silly question, but i need it for my personnal
> > work, and i could not find it in the archive.
> > 
> > Is there a way to transform string to ( 'a, out_channel, unit, unit)
> > format. I need this function to use it with something like :
> > 
> > Printf.printf (my_fun "X, Y") "coucou";;
> > 
> > I look at the code and see a function scan_format, but it seems to be
> > forbid to use it. 
> > 
> > Any idea ?
> > 
> > Thanks
> > Sylvain LE GALL
> 
> As once announced on this list, the new release of Objective Caml will
> introduce a lot of novelty on the format type.
> 
> Besides new convertion specifiers that you could find in the Printf
> and Scanf documentation (C, S, B, F, !, ...), there are now several
> different new functionalities provided by the new compiler which are
> relevant to your question:
> 
> 0) converting arbitrary format string to a regular strings
> 
> 1) converting CONSTANT strings to the corresponding constant format string
> 
> 2) concatenating format strings (very often feature 0 and 1 are used
> in conjonction just to implement format strings concatenation).
> 
> Back to your problem: the features described here may your for some
> ``my_fun'' functions, but the general case is not properly covered by
> them. What we need is a general function that reads a format from
> within a string that is NOT a constant. This is a kind of dynamic
> convertion reminiscent of int_of_string or float_of_string, that
> checks that the string can be indeed considered as an integer of
> floatting point number.
> 
> I propose (and have implemented for my own programming of a general
> translation function) a new function [read_format], such that
> 
> [read_format pat s] returns the string [s] as a format string that has
> the same type (hence the same ``printf meaning'') as [pat], the first
> format string argument.
> 
> For instance,
> 
> read_format "The number %d is odd" "Le nombre %d est impair"
> 
> returns "Le nombre %d est impair" as a format string with the same
> type as "The number %d is odd".
> 
> This function is more general that the one above since now in
> [read_format pat s] the string [s] is not mandatorily an immediate
> string constant: it can be obtained from an arbitrary computation, as
> read from a file.
> 
> The Typechecking of read_format would be:
> 
> read_format :
>  ('a, 'b, 'c, 'd) format -> string -> ('a, 'b, 'c, 'd) format
> 
> If considered useful, this function could be added, for instance as
> part of a new internationalization module.

Hello,

you read my mind. Indeed, the question concern an internationalization
module ( let's call libgettext-ocaml ). It is basically a binding of
gettext. 

But, for handling certain apsect of gettext it needs printf like
capability. But the printf like capibility, as printf, use a non constant
string ( returned by a function dngettext... or so ). That's the reason
why i am looking after something which correpsond to this things.

If people at INRIA could include some kind of read_format, it could be
very useful.

Thanks a lot
Sylvain LE GALL

-------------------
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

Re: [Caml-list] Printf and format

[Xavier Leroy]

> Is there a way to transform string to ( 'a, out_channel, unit, unit)
> format. I need this function to use it with something like :
> 
> Printf.printf (my_fun "X, Y") "coucou";;

No, not in a type-safe manner.  The type of a format string depends on
the "%" specifiers found in the string itself, and OCaml can't infer
or check types at run-time.

However, for the purpose of internationalization, the following
operation suffices: given a (compile-time constant) format and a
(dynamically computed) string, check that the string can be viewed as
a format with the same format type as the constant format, and return
the string as a format.  

In OCaml 3.06, this can be done as follows:

  let re_fmt =
    Str.regexp "%[#0-9.*+ -]*[lnL]?[sScCdioxXunfeEgGFbBatn[]"

  let string_of_format (s : ('a, 'b, 'c) format) = (Obj.magic s : string)

  let extract_formats s =
    List.fold_right
      (fun part accu ->
        match part with Str.Text _ -> accu | Str.Delim d -> d :: accu)
      (Str.full_split re_fmt s) []

  let conv_format (src: ('a, 'b, 'c) format) (dst: string) =
    if extract_formats (string_of_format src) = extract_formats dst
    then (Obj.magic dst : ('a, 'b, 'c) format)
    else failwith "conv_format"

Remark 1: yes, there's a lot of "Obj.magic" in this code, and yes,
this is a deadly sin, but in this particular instance it is all
type-safe nonetheless.

Remark 2: the matching of the two formats can be relaxed, e.g.
the code above will not allow the conversion of "%6d" into "%8x",
although both formats have the same type.  This is left as an exercise
for the reader.  But for internationalization purposes, I doubt
you need that additional flexibility.

Then, assuming you have a function "gettext : string -> string" to translate
strings according to the user-selected language, you can extend it to
formats as follows:

  let getformat f = conv_format f (gettext (string_of_format f))

and use it with printf functions like this:

  printf (getformat "My name is %s and I'm %d years old") "Bob" 12

> you read my mind. Indeed, the question concern an internationalization
> module ( let's call libgettext-ocaml ). It is basically a binding of
> gettext. 

I hope the above is enough to get you off the ground.

- Xavier Leroy

-------------------
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