OCaml Printf.sprintf

Question

Why does this behavior occur?

# Printf.sprintf ("Foo %d %s") 2 "bar";;
- : string = "Foo 2 bar"

# Printf.sprintf ("Foo %d" ^ " %s") 2 "bar";;
  Printf.sprintf ("Foo %d" ^ " %s") 2 "bar";;
Error: This expression has type string but an expression was expected of type
         ('a -> 'b -> 'c, unit, string) format =
           ('a -> 'b -> 'c, unit, string, string, string, string) format6

I would expect that the string concatenation would be evaluated first, so everything will proceed as normal. Does this have to do with the type system trickery that Printf employs?

Jeffrey Scofield · Accepted Answer · 2012-05-02T01:24:52.120

20

Yes, it has to do with type system trickery. If you want to create a format string you need to use the (^^) operator:

# Printf.sprintf ("Foo %d" ^^ " %s") 2 "bar";;
- : string = "Foo 2 bar"

I'm not deeply schooled in this trickery, but I believe that the compiler is willing to promote a string constant to a printf format if the typing context calls for it. However, the result of ("Foo %d" ^ " %s") is not a string constant, so it doesn't get promoted. The (^^) operator creates a typing context where both operands can be promoted if they are string constants.

You can see why it would have to be a string constant: otherwise the associated types (of the values to be printed) can't be determined.

edited May 02 '12 at 01:24

answered May 02 '12 at 01:19

Jeffrey Scofield

65,646
2
72
108

1

A fine explanation, thank you. A minor point, I find your formulation "the (^^) operator creates a typing context .." unclear; this operator has no magic inside, it is just typed `... format -> ... format -> ... format`, and type inference does the work of checking that its parameters are of this type, constant strings. – gasche May 02 '12 at 07:34
1

gasche is right. What needs to be understood is that when you give a string to `Print.*printf` you don't give it a value of type `Pervasives.string` you give it a value of type `Pervasives.format6` (which is not equal to `Pervasives.string`). – Daniel Bünzli May 02 '12 at 07:56
Right, I should just have said that (^^) has the type gasche gives. There's definitely no magic in that part. The only magic (as I understand it) is in the promotion of string constants to the appropriate `format` type. – Jeffrey Scofield May 02 '12 at 15:02
3

@gasche: Basically, you can think of a string literal in OCaml as "overloaded"; it can be either a string value or format string value. The type checker determines which one at compile time. Giving a string literal to `printf` directly causes it to be inferred as a format string. Giving it to `^` causes it to be inferred as a string. `^` also returns a string, which is the wrong type for `printf` which is why you get the error. – newacct May 02 '12 at 18:24

score 10 · Answer 2 · edited May 03 '12 at 08:35

The problem occurs much more widely than just with the ^ operator. Basically, the OCaml compiler needs to know that your format string is a literal string, and the literal string needs to be known at compile time. Or else, OCaml cannot cast your string at compile time to this BLAHBLAH format6 type. The Printf module works correctly only with format strings that are completely known at compile time, or with format strings that are already cast to the BLAHBLAH format type.

Generally you can solve this problem by using the ^^ operator and by explicitly casting all literal strings to the BLAHBLAH format type before using those strings in your code.

Here is another example:

  # Printf.sprintf (if true then "%d" else "%d ") 2;;
  Error: This expression has type string but an expression was expected of type
     ('a -> 'b, unit, string) format =
       ('a -> 'b, unit, string, string, string, string) format6
  (* define a type abbreviation for brevity *)
  # type ('a,'b) fformat = ('a ->'b, unit, string) format;;
  type ('a, 'b) fformat = ('a -> 'b, unit, string) format
  # Printf.sprintf (if true then ("%d":('a,'b)fformat) else ("%d ":('a,'b)fformat)) 2;;
  - : string = "2"

The OCaml system cannot recognize that if ... then "a" else "b" can be cast to BLAHBLAH format. If you cast each literal string yourself to BLAHBLAH format, then everything works. (Note: it does not work if you try to cast the entire if/then/else to BLAHBLAH format, since OCaml cannot verify that your string is a literal.)

The origin of the problem is the requirement of type safety: OCaml requires that there is an argument of the correct type for every %d and %s etc., and guarantees this at compile time. You cannot guarantee type safety with Printf unless the entire format string is known at compile time. Therefore, it is impossible to use Printf with a format string computed via a complicated algorithm, e.g., by selecting %s and %d at random.

When we use if/then/else to compute the format string, then OCaml things, oh gee, this is a complicated algorithm, and it is hopeless to verify type safety at compile time. The ^^ operator knows about BLAHBLAH format types and produces the correct result when concatenating format strings. But if/then/else does not know about BLAHBLAH format, and there is no built-in alternative to if/then/else (but I guess you could define such a thing youself).

OCaml Printf.sprintf

2 Answers2

Linked