This code, that a sane language/language implementation refuses at compile-time, runs:


import std.stdio;
void main() {
    writefln("%d", "hello");
}


And it outputs:
['h', 'e', 'l', 'l', 'o']

Is this good/expected/acceptable/buggy?

Bye,
bearophile

That's a sweet trick right there. I get different results but I guess this is due to new std.format changes:

[104, 101, 108, 108, 111]

On 12/10/2011 23:41, bearophile wrote:
> This code, that a sane language/language implementation refuses at compile-time, runs:

It's perfectly legal code, so the best a compiler can correctly do is give a warning. Some C(++) compilers understand printf and will warn if the format string doesn't match the arguments, but even this is rare AIUI.

To enforce well-formed format strings at compile time would require it to be made a language builtin.  Or maybe template metaprogramming can do it.

> import std.stdio;
> void main() {
>      writefln("%d", "hello");
> }
>
>
> And it outputs:
> ['h', 'e', 'l', 'l', 'o']
>
> Is this good/expected/acceptable/buggy?

It certainly should either throw an exception or generate more sane output such as Andrej is getting.  What DMD version are you using?

Stewart.

Stewart Gordon:

>It's perfectly legal code,<

If that code is legal, then in my opinion it's the rules of the language that are wrong and in need to be changed :-)


>Some C(++) compilers understand printf and will warn if the format string doesn't match the arguments, but even this is rare AIUI.<

I don't know what 'AIUI' means. And GCC (and Clang too) do it, so it's not a rare thing.


>To enforce well-formed format strings at compile time would require it to be made a language builtin.<

Or just a built-in rule, as in GCC.


>Or maybe template metaprogramming can do it.<

Of course. It's not hard to create something like this:
writelnt!"%d %f"(53, 1.55);

But I think you need a D compiler able to remove unneeded template instantiations from the binary, to avoid bloat.


>It certainly should either throw an exception or generate more sane output such as Andrej is getting.  What DMD version are you using?<

I am using 2.057GitHead on 32 bit Windows. I don't know if this Phobos bug is in bugzilla.

Bye,
bearophile

On 02/12/2011 03:19, bearophile wrote:
> Stewart Gordon:
>
>> It's perfectly legal code,
>
> If that code is legal, then in my opinion it's the rules of the language that are wrong
> and in need to be changed :-)

You mean all programming languages should support CTFE for argument validation?

What if the format string isn't even known at compile time in the first place?

>> Some C(++) compilers understand printf and will warn if the format string doesn't
>> match the arguments, but even this is rare AIUI.
>
> I don't know what 'AIUI' means.

As I understand it.

http://www.acronymfinder.com/ is your friend.

> And GCC (and Clang too) do it, so it's not a rare thing.

I meant rare among the world's various C compilers.  Are you going by usage statistics?

>> To enforce well-formed format strings at compile time would require it to be made a
>> language builtin.
>
> Or just a built-in rule, as in GCC.

What do you mean by a "built-in rule" exactly?

>> Or maybe template metaprogramming can do it.
>
> Of course. It's not hard to create something like this: writelnt!"%d %f"(53, 1.55);
>
> But I think you need a D compiler able to remove unneeded template instantiations from
> the binary, to avoid bloat.
<snip>

Maybe there's a way that the template instances can be very small, delegating most of the work to non-templated functions.

Stewart.

Stewart Gordon:

> You mean all programming languages should support CTFE for argument validation?

This is not necessary, and it's not sufficient...


> What if the format string isn't even known at compile time in the first place?

In this case the format string validation is done at run-time. It's opportunistic static typing. And it's better than leaving all the tests at run-time. In a dynamically typed language I accept format strings to be verified at run-time. In a compiled language I want some of advantages of static typing, where possible.


> http://www.acronymfinder.com/ is your friend.

Or even better, reduce the usage of uncommon acronyms in normal communications :-)


> I meant rare among the world's various C compilers.  Are you going by usage statistics?

In the end D wants to be better than C and C compilers.


> What do you mean by a "built-in rule" exactly?

In GCC there is a hard-coded routine that tests (or tries to) the correctness of format strings known at compile-time.


> Maybe there's a way that the template instances can be very small, delegating most of the work to non-templated functions.

This is easy to do, just call the same runtime function after the compile-time test done in the template :-) But DMD probably has to learn to better remove unnecessary template instances from the resulting binary. Walter has discussed this topic a bit several times.

Bye,
bearophile