As a rookie in D programming I try to understand the power of templated functions with compile time parameters. With DMD 2.074 a compile time format
(auto output = format!("Print this %s")(var);)

was introduced, now we all know that very many of this format strings are immutable, so wouldn't it be cool to automatically detect this and use the compile time version?

Without the need to think about it and to use an other syntax?
Is this theoretically possible?

Regards mt.

On Monday, 31 July 2017 at 15:43:21 UTC, Martin Tschierschke wrote:
> As a rookie in D programming I try to understand the power of templated functions with compile time parameters. With DMD 2.074 a compile time format
> (auto output = format!("Print this %s")(var);)
>
> was introduced, now we all know that very many of this format strings are immutable, so wouldn't it be cool to automatically detect this and use the compile time version?
>
> Without the need to think about it and to use an other syntax?
> Is this theoretically possible?
>
> Regards mt.

That's what writeln() does. The format is detected for each element of the variadic.

On Monday, 31 July 2017 at 15:46:47 UTC, inevzxui wrote:
> On Monday, 31 July 2017 at 15:43:21 UTC, Martin Tschierschke wrote:
>> As a rookie in D programming I try to understand the power of templated functions with compile time parameters. With DMD 2.074 a compile time format
>> (auto output = format!("Print this %s")(var);)
>>
>> was introduced, now we all know that very many of this format strings are immutable, so wouldn't it be cool to automatically detect this and use the compile time version?
>>
>> Without the need to think about it and to use an other syntax?
>> Is this theoretically possible?
>>
>> Regards mt.
>
> That's what writeln() does. The format is detected for each element of the variadic.

But the parameters are not checked at compile-time unless you specifically pass the pattern string as a template parameter. I think its immutability implicitly converting it into a template parameter is what's what he's talking about.

import std.stdio;

void main(string[] args)
{
    writefln!"%s"(); // compile-time assert
    writefln("%s");  // runtime exception, though everything needed for a compile-time assert was inferable during compilation
}

On 07/31/2017 05:43 PM, Martin Tschierschke wrote:
> As a rookie in D programming I try to understand the power of templated functions with compile time parameters. With DMD 2.074 a compile time format
> (auto output = format!("Print this %s")(var);)
> 
> was introduced, now we all know that very many of this format strings are immutable, so wouldn't it be cool to automatically detect this and use the compile time version?
> 
> Without the need to think about it and to use an other syntax?
> Is this theoretically possible?

Kinda-sorta, but not really and you have to use the template syntax:

----
string format(alias fmt, A ...)(A args)
{
    import std.format: sformat = format;
    static if (__traits(compiles, { enum e = fmt; }))
        return sformat!("(CT) " ~ fmt)(args);
    else
        return sformat("(RT) " ~ fmt, args);
}

void main()
{
    import std.stdio: readln, writeln;

    // CT
    writeln(format!"Print this %s"(42));

    // RT
    auto fmt = readln();
    writeln(format!fmt(42));
    // Can't call it like this: format!(readln())(42);

    // also still RT
    auto fmt2 = "Print this %s";
    writeln(format!fmt2(42));

    // (somewhat surprisingly) CT
    immutable fmt3 = "Print this %s";
    writeln(format!fmt3(42));
}
----

On Monday, 31 July 2017 at 15:57:28 UTC, Anonymouse wrote:
> On Monday, 31 July 2017 at 15:46:47 UTC, inevzxui wrote:
>> On Monday, 31 July 2017 at 15:43:21 UTC, Martin Tschierschke wrote:
[...]
> But the parameters are not checked at compile-time unless you specifically pass the pattern string as a template parameter. I think its immutability implicitly converting it into a template parameter is what's what he's talking about.
>
> import std.stdio;
>
> void main(string[] args)
> {
>     writefln!"%s"(); // compile-time assert
>     writefln("%s");  // runtime exception, though everything needed for a compile-time assert was inferable during compilation
> }

This is exactly the "use case", I thought about: How to avoid runtime errors, if at compile time the problem might be detected.

Am Mon, 31 Jul 2017 15:43:21 +0000
schrieb Martin Tschierschke <mt@smartdolphin.de>:

> As a rookie in D programming I try to understand the power of
> templated functions with compile time parameters. With DMD 2.074
> a compile time format
> (auto output = format!("Print this %s")(var);)
> 
> was introduced, now we all know that very many of this format strings are immutable, so wouldn't it be cool to automatically detect this and use the compile time version?
> 
> Without the need to think about it and to use an other syntax? Is this theoretically possible?

I see no way to accomplish this. For the compiler to see the
contents of the format string it needs to be a template
argument and as soon as you want to also allow runtime values
to be accepted there, you need to use an alias, which in turn
precludes the use of function results or concatenation.
Believe me I've spent quite some time on trying something like
this for format strings.

> Regards mt.

As far as using template arguments for code optimizations go, I
know that at least GCC will turn runtime arguments into
template arguments of sorts internally, thereby creating
duplicates of the function with one or more arguments
optimized out.
On the other hand, you don't want to drive this too far. While
it is nice to have compile-time checks, templates are actually
troublesome on some levels. For example, the duplicated code
makes it hard to cache the formatting function in the CPU and
when writing libraries you always have to provide the full
implementation that will get linked into the host application,
which is a concern under certain licensing schemes.
The benefits of shared libraries, like loading the code into
memory once and use it by multiple processes or fixing
security issues in one central place and have all programs use
the new code without recompilation are also void. I.e. without
template arguments, `format()` and all its dependencies
(templates as well as regular functions) are compiled right
into the Phobos shared library for all programs to use. If
there is a security issue, it can be replaced with a patched
version. Now with template arguments, `format!()` is compiled
into each Dlang application multiple times for each format
string and security fixes cannot be applied without
recompiling them all.

-- 
Marco