Character concatenation/formatting

[Entrivax]

From the documentation, you can get a character from a string with str[i], and it gives you an int.
But I didn't see how you can put this character back in a string, since the only formatting options I saw are for hexa/decimal and floats.
Is there currently a way to do it but not documented? Or it's not supported and maybe planned?

int character = 'a';
string() s = $"Current character: {character:c}"; // Maybe something like this?

[pfusik]

Excellent question!

str[i] is read-only because in most target languages strings are immutable. Also, it returns a code unit rather than a code point. In C and C++ strings are expected to be UTF-8-encoded and the unit is a byte. In most other languages it's UTF-16 and the unit is a 16-bit number.

Currently there's no format string for Unicode characters (or code units). I was about to add "C" as in your example. One problem is that in .NET the "C" format means "currency" which could be confusing. Another problem is that C (and probably C++ too, I'm not sure) have no standard library support for encoding UTF-8.

As a workaround, you can encode your character in UTF-8, then use Encoding.UTF8.GetString(byteArray, 0, byteCount). On targets such as C and C++ this won't validate if your encoding is correct, but simply use the bytes as they are.

[Entrivax]

So, for now, I would need to do something like this:

class StringWriter {
    byte[]# Buffer;
    int CurrentLength;
    int CurrentIndex;

    public StringWriter() {
        this.CurrentIndex = 0;
        this.CurrentLength = 8;
        this.Buffer = new byte[this.CurrentLength];
    }

    public void WriteString(string str) {
        for (int i = 0; i < str.Length; i++) {
            this.WriteChar(str[i]);
        }
    }

    public void WriteChar(int charCode) {
        // Write the char as utf8
        if (charCode <= 0x7F) {
            this.AddByte(charCode);
        } else if (charCode <= 0x7FF) {
            this.AddByte(0xC0 | (charCode >> 6));
            this.AddByte(0x80 | (charCode & 0x3F));
        } else if (charCode <= 0xFFFF) {
            this.AddByte(0xE0 | (charCode >> 12));
            this.AddByte(0x80 | ((charCode >> 6) & 0x3F));
            this.AddByte(0x80 | (charCode & 0x3F));
        } else {
            this.AddByte(0xF0 | (charCode >> 18));
            this.AddByte(0x80 | ((charCode >> 12) & 0x3F));
            this.AddByte(0x80 | ((charCode >> 6) & 0x3F));
            this.AddByte(0x80 | (charCode & 0x3F));
        }
    }

    void AddByte(byte b) {
        if (this.CurrentLength <= this.CurrentIndex + 1) {
            this.ResizeBuffer();
        }
        this.Buffer[this.CurrentIndex++] = b;
    }

    void ResizeBuffer() {
        byte[]# newBuffer = new byte[this.CurrentLength * 2];
        this.Buffer.CopyTo(0, newBuffer, 0, this.CurrentLength);
        this.CurrentLength = this.CurrentLength * 2;
        this.Buffer = newBuffer;
    }

    public int Length() => this.CurrentIndex;

    public string GetString() {
        return Encoding.UTF8.GetString(this.Buffer, 0, this.CurrentIndex);
    }
}

public static class Debug
{
    public static string GetMessage(string str)
    {
        StringWriter() writer;
        writer.WriteString("First character: ");
        writer.WriteChar(str[0]);
        return writer.GetString();
    }

    public static void Run() {
        Console.WriteLine(GetMessage("Hi"));
    }
}

Right?

[pfusik]

public static class Debug
{
    static string() CharToString(int c)
    {
        byte[4] bytes;
        if (c <= 0x7f) {
            bytes[0] = c;
            return Encoding.UTF8.GetString(bytes, 0, 1);
        }
        if (c <= 0x7ff) {
            bytes[0] = 0xc0 | c >> 6;
            bytes[1] = 0x80 | (c & 0x3f);
            return Encoding.UTF8.GetString(bytes, 0, 2);
        }
        if (c <= 0xffff) {
            bytes[0] = 0xe0 | c >> 12;
            bytes[1] = 0x80 | (c >> 6 & 0x3f);
            bytes[2] = 0x80 | (c & 0x3f);
            return Encoding.UTF8.GetString(bytes, 0, 3);
        }
        bytes[0] = 0xf0 | c >> 18;
        bytes[1] = 0x80 | (c >> 12 & 0x3f);
        bytes[2] = 0x80 | (c >> 6 & 0x3f);
        bytes[3] = 0x80 | (c & 0x3f);
        return Encoding.UTF8.GetString(bytes, 0, 4);
    }

    public static string() GetMessage(string str) => $"First character: {CharToString(str[0])}";

    public static void Run() {
        Console.WriteLine(GetMessage("Hi"));
    }
}

or:

public static class Debug
{
    public static string() GetMessage(string str)
    {
        StringWriter() writer;
        writer.Write("First character: ");
        writer.WriteChar(str[0]);
        return writer.ToString();
    }

    public static void Run() {
        Console.WriteLine(GetMessage("Hi"));
    }
}

but the built-in StringWriter is currently not supported for C and Swift.

It's better to use this:

public static class Debug
{
    public static string() GetMessage(string str) => $"First character: {str.Substring(0, 1)}";

    public static void Run() {
        Console.WriteLine(GetMessage("Hi"));
    }
}

[Entrivax]

Okay!
(I didn't even know there was a built-in StringWriter)
So, to concatenate a char coming from another string, I should do something like:

public static class Debug
{
    public static string GetMessage(string str)
    {
        string out = "First character: ";
        // Here goes some parsing steps...
        out = $"{out}{str.Substring(0, 1)}";
        // Other steps...
        out = $"{out}\nSecond character: {str.Substring(1, 1)}";
        return out;
    }

    public static void Run() {
        Console.WriteLine(GetMessage("Hi"));
    }
}

And if I need to convert a char from its code unit to a string, I would need your CharToString method, or the built-in StringWriter but only if I don't need to target C or Swift

[pfusik]

That's correct, except it should be:

    public static string() GetMessage(string str)
    {
        string() out = "First character: ";
        // Here goes some parsing steps...
        out = $"{out}{str.Substring(0, 1)}";
        // Other steps...
        out = $"{out}\nSecond character: {str.Substring(1, 1)}";
        return out;
    }

Note the use of string() for string storage. This is crucial if you target C or C++. I'll try to add errors that prevent the incorrect usage of string references.

Alternatively:

        out += str.Substring(0, 1);

etc.

Also, the above is only fine if you work on ASCII characters. For Unicode, the concept of "character" is more complex and please make sure you understand the UTF-8 and UTF-16 encodings.

[Entrivax]

Okay! Thank you!
It looks to be working quite well!
At least, from what I can see from the JavaScript output. My current test was targeting JS and Java in the first place, both of which seems to have the StringWriter too.
I tried both versions (StringWriter and concat with Substring), and both seem to give me the same output.

[pfusik]

Note the use of string() for string storage. This is crucial if you target C or C++. I'll try to add errors that prevent the incorrect usage of string references.

Errors added in 4a7a5a4