On Friday, 30 December 2022 at 22:02:41 UTC, Ali Çehreli wrote:

I have one more little question! Is it possible to infer the string without the type the programmer specifies explicitly in the template below?

template Fun(dstring str)/*
template Fun(T)(T str)/* like this */
{
  import std.traits : Unconst;
  alias T = Unconst!(typeof(str[0]));

  auto Fun()
  {
    import std.conv : to;

    auto result = Result();
    result.data = str.to!(T[]);

    return result;
  }
  
  struct Result
  {
    union
    {
      T[str.length] data;
      ubyte[T.sizeof * str.length] bytes;
    }
    string toString()
    {
      import std.format;
      return format("%s: %(%02X-%)", data, bytes);
    }
  }
}

void main()
{
  import std.stdio : writeln;
  Fun!"β€Ş"w.writeln; // type1: wstring
  Fun!"β€Ş"d.writeln; // type2: dstring
}

That is, the compiler can/must infer between type 1-2 or type 3(string) that it knows at compile time, right?

SDB@79

On Saturday, 31 December 2022 at 00:42:50 UTC, Salih Dincer wrote:

Let me save you the torment of code duplication 😀

Thanks everyone. Yes, I guess there is no other way but to overload. This is both the safest and the fastest. It's also short enough like this:

  // D 2.0.83 or higher

  import std.stdio : writeln;
  import std.conv  : to;

auto Fun(string str)() {
  auto result = Values!(char, str.length)();
  result.data = str.to!(char[]);
  return result;
}

auto Fun(wstring str)() {
  auto result = Values!(wchar, str.length)();
  result.data = str.to!(wchar[]);
  return result;
}

auto Fun(dstring str)() {
  auto result = Values!(dchar, str.length)();
  result.data = str.to!(dchar[]);
  return result;
}

struct Values(T, size_t len) {
  union {
    T[len] data;
    ubyte[T.sizeof * len] bytes;
  }
  string toString() {
    import std.format;
    return format("%s: %(%02X-%)", data, bytes);
  }
}

void main()
{
  Fun!"β€Ş".writeln;  // β€Ş: CE-B2-E2-82-AC-C5-9E
  Fun!"β€Ş"w.writeln; // β€Ş: B2-03-AC-20-5E-01
  Fun!"β€Ş"d.writeln; // B2-03-00-00-AC-20-00-00-5E-01-00-00
}

SDB@79

On Saturday, 31 December 2022 at 02:15:56 UTC, Ali Çehreli wrote:

You took the trouble, thanks, but there is a special reason why I use union. If we want, we can write dynamic version without using std.traits:

struct Values(T, size_t len = 1)
{
  union
  {
    T[len] data;
    ubyte[T.sizeof * len] bytes;
  }

  string toString()
  {
    import std.format;
    return format("%s: %(%02X-%)", data, bytes);
  }
}

  alias Char = Values!char;
  alias Wchar = Values!wchar;
  alias Dchar = Values!dchar;

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

  Char[] str1;
  str1 ~= Char('B');
  str1 ~= Char('E');
  str1 ~= Char('$');
  str1.writeln;

  Wchar[] str2;
  str2 ~= Wchar('β');
  str2 ~= Wchar('€');
  str2 ~= Wchar('Ş');
  str2.writeln;

  Dchar[] str3;
  str3 ~= Dchar('β');
  str3 ~= Dchar('€');
  str3 ~= Dchar('$');
  str3.writeln("\n");

  Fun!"β€$".writeln;
}
/*
  [B: 42, E: 45, $: 24]
  [β: B2-03, €: AC-20, Ş: 5E-01]
  [β: B2-03-00-00, €: AC-20-00-00, $: 24-00-00-00]

  β€$: CE-B2-E2-82-AC-24
*/

However, I would like to draw your attention to the last line. Yeah, I won't be able to do that because it's New Year's Eve. But the line is like mixed mode because of the non-char data it contains, right?

Happy New Year...