Propagation of CultureInfo to a nested interpolated string

[ufcpp]

TL;DR

I'd like a mechanism to propagate CultureInfo to a nested interpolated string with the following code.

Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;

string.Create(
    CultureInfo.GetCultureInfo("fr-fr"), 
    $"direct: {1.5}, {$"nested: {1.5}"}"));

Background

I am writing a utility library for string interpolation. One of the features provided by this library is the ability to do the following

static string format(bool condition, params int[] days) => $$"""
{
  "a": {{If(condition,
    b => b.Append($"{123}"),
    b => b.Append($"{1.5}")
    )}},
  "b": [{{ForEach(days, (v, b) => b.Append($"""

    "{new DateOnly(2000, 12, v)}",
"""))}}
  ]
}

""";

However, this code has the following issue.

IFormatProvider propagation

Unfortunately, string manipulation in .NET mostly depends on CurrentCulture. There are many situations where this is not desirable, and the culture is required to be explicitly specified.

For string interpolation, you would use string.Create(culture, $"") instead of $"". However, the culture explicitly passed here is not propagated to the nested interpolated string.

For example, execute the following code:

using System.Globalization;

Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;

Console.WriteLine(
    string.Create(
        CultureInfo.GetCultureInfo("fr-fr"), 
        $"""
        direct: {1.5}
        {$"nested: {1.5}"}
        """));

The following results are obtained:

direct: 1,5
nested: 1.5

It would be a solution if string.Create(culture) were made explicit again in the nested part, but human error inevitably occurs.

Returning to my library, If and ForEach in this library propagate culture over the argument of the lambda expression b. As a result, the boilerplate code b => b.Append($"") is required. This is cumbersome, and I would prefer to write it without b.Append, as shown below.

static string format(bool condition, params int[] days) => $$"""
{
  "a": {{If(condition, $"{123}", $"{1.5}")}},
  "b": [{{ForEach(days, v => $"""

    "{new DateOnly(2000, 12, v)}",
""")}}
  ]
}

""";

However, in the current version of C#, I can't think of a way to propagate culture in this style.

A close implementation, as far as it can be written in C# 11, would be as follows.

• Gist
• sharplab

Here is an excerpt:

Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;

static string m(bool condition) => string.Create(
    CultureInfo.GetCultureInfo("fr-fr"), 
    $"direct: {1.5} or {1:C}, nested: {If(condition, $"{1.5}", $"{1:C}")}");

Console.WriteLine(m(true));
Console.WriteLine(m(false));

The current implementation produces the following output. (Different for direct and nested.)

direct: 1,5 or 1,00 €, nested: 1.5
direct: 1,5 or 1,00 €, nested: ¤1.00

The expected output is rather like this
(Same with direct and nested.)

direct: 1,5 or 1,00 €, nested: 1,5
direct: 1,5 or 1,00 €, nested: 1,00 €

I am having trouble finding a way to do that in the current C#.

The problem is that there is no way to propagate the CultureInfo passed to string.Create to the handler of the argument of the If.

Discussion

Now, the aforementioned string.Create code lowers to the following code

IFormatProvider cultureInfo = CultureInfo.GetCultureInfo("fr-fr");
IFormatProvider provider = cultureInfo;
DefaultInterpolatedStringHandler handler = new(22, 3, cultureInfo);
// ...
IfTrueInterpolatedStringHandler thenHandler = new(0, 1, condition, out var shouldAppend);
if (shouldAppend)
{
    thenHandler.AppendFormatted(1.5);
}
IfFalseInterpolatedStringHandler elseHandler = new(0, 1, condition, out shouldAppend);
if (shouldAppend)
{
    elseHandler.AppendFormatted(1, "C");
}
handler.AppendFormatted(If(condition, thenHandler, elseHandler));
return string.Create(provider, ref handler);

Can we somehow propagate cultureInfo to the nested handlers as follows?

IFormatProvider cultureInfo = CultureInfo.GetCultureInfo("fr-fr");
IFormatProvider provider = cultureInfo;
DefaultInterpolatedStringHandler handler = new(22, 3, cultureInfo);
// ...
IfTrueInterpolatedStringHandler thenHandler = new(0, 1, condition, out var shouldAppend,
    cultureInfo // !!!
    );
if (shouldAppend)
{
    thenHandler.AppendFormatted(1.5);
}
IfFalseInterpolatedStringHandler elseHandler = new(0, 1, condition, out shouldAppend,
    cultureInfo // !!!
    );
if (shouldAppend)
{
    elseHandler.AppendFormatted(1, "C");
}
handler.AppendFormatted(If(condition, thenHandler, elseHandler));
return string.Create(provider, ref handler);

To achieve this, could we use a mechanism such as Implicit parameters?

[InterpolatedStringHandler]
public ref struct IfTrueInterpolatedStringHandler
{
    public IfTrueInterpolatedStringHandler(int literalLength, int formattedCount, bool condition, out bool shouldAppend,
        implicit IFormatProvider? provider) // or some attributes like InterpolatedStringHandlerArgument
    {
        shouldAppend = condition;
        if (!condition) return;
        _inner = new DefaultInterpolatedStringHandler(literalLength, formattedCount, provider);
    }

"implicit hell" is scary, but IMHO, implicit parameters are somewhat better than relying on static properties (like CurrentCulture or SynchronizationContext.Current)

I would like to hear your opinions.

[333fred]

This is kinda already possible, by defining a AppendFormatted method that takes the containing handler type and copying over any relevant data from the original handler. Here's an example: https://sharplab.io/#v2:C4LgTgrgdgPgAgJgAwFgBQiCM65IARyYB0A4gDYD2ARgIZkCWAXjcPRVANw76FEBK0VgFsApkQDCFIQAd6ZEWADKCgG70AxiIDOXDD2IAVEQA9gunJgCcACnEQtwKQAkaUACbywEsCJYjbEGTAED4AklAAZhSkIsB2QSEi4VHWAEQRYAC0GakAlAA0eOh4JXgAJKlu9D7qoHgA3sQArAC+hfUVUNrAIm4gDc0tqUO5ueZoANrhPWDSFGR+borAYPRQAOYu7p4AuugOkLV4dg7Orh4K6PXFpXAAzASYAGyP+OI+fgEJYZEUeGtRQpTKAzOYLHpLFZrTbnTwAQTA6wgohB1igNFEFAi1gBFFGO2O9kcQi2FzAeHURLO2wUuRuJWuaFKzIIAHYKVSSbCFEQqBA5G4eQYKMtVhtrLkAIS6ZktelFJmlaSrFR+PAfNzsMgATzwouhACF+WRBeS+QKFHgALx4LoAdwlMqVKrVGq1uviwR+UQ53xETpK8vuhNOXJpYBxILwDBmdAAMiINsAABaFNbAPBRMBCFgQySCQqexLJP6Uv0lumKhny5llr0ia2++slgN4OVVhXM4MnYmkzyRjMxhTxxPrFNpqNZnPAPMUAsh3vc8nJpe5PD9FP0LTWIdgEdJ1OZijZ3O9fMgwor8NEOuJSvMxmy+XPjvBuAAFjwcOk0kTbjj9CxmQ1iEPgWj3qUj4siU5omjy36/u41jga27bMkGDwfl+P5/gAYse04QtYwKgvMiz6hsfYKAiSIosAaR5ASPbUmSeBXmSEHVh2zJZr46jJng1iquS/HQAA1v8UBsUuvLGqaMRxMm4nbqMNaQWp0GwfJCF/tYolQGJYwaW28poaUGEEJ+OnuPhJ4zr01iahAVDyHgbicQ0xlafBOFIW4RDChR6x6YE9ajKh6AtEAA=.

Unfortunately, I don't think that's immediately useful for your library, as the nested strings aren't direct arguments of containing string, but are instead arguments of a nested function of the string. If you were willing to incur some boxing and allocations, you could take advantage of this trick by having a NestedBuilder type that stores the original values, and then calls AppendFormatted for each value when appended to the containing handler. Somewhat complicated and expensive, to be sure, but it would work for the scenario.

[ufcpp]

It may take some time to organize the ideas, so please allow me to answer in several parts.

If you were willing to incur some boxing and allocations

No. One of the goals of my library is to avoid allocations.

I have an implementation that Append directly to destination in TryFormat via ISpanFormattable once, e.g. Join.

[ufcpp]

Wouldn't that the AppendFormatted that takes the handler be insufficient for an If or ForEach method?

CustomHandler.Create(
    CultureInfo.GetCultureInfo("fr-fr"),
    $"direct: {1.5} or {1:C}, nested: {
        If(condition, // cannot invoke AppendFormatted(CustomHandler handler) directy
        $"{1.5}",
        $"{1:C}")
        }");

[ufcpp]

If the string interpolation were target-typed, the problem might be alleviated a bit.

CustomHandler.Create(
    CultureInfo.GetCultureInfo("fr-fr"),
    $"direct: {1.5} or {1:C}, nested: {(condition
        ? $"{1.5}" // Since this is not target-typed, so $"{1.5}" is string instead of CustomHandler.
        : $"{1:C}")
        }");

[333fred]

Wouldn't that the AppendFormatted that takes the handler be insufficient for an If or ForEach method?

That's what I said about it requiring allocations.

If the string interpolation were target-typed, the problem might be alleviated a bit.

It is. What you're seeing is that ternaries with a natural type (string) are not.