Re: Better way to append to array than ~= ?

[Jordan Wilson via Digitalmars-d-learn]

On Tuesday, 3 April 2018 at 19:02:25 UTC, Vladimirs Nordholm 
wrote:
Hello people.

I currently have a function which multiple times per second 
takes in arguments, and appends the argument as my special 
type. The following code should explain what I do more properly:

    struct MySpecialType { char c; }

    auto foo(Args...)(Args args)
    {
        MySpecialType[] bar;

        foreach(ref arg; args)
        {
            static if(is(typeof(arg) == MySpecialType))
            {
                bar ~= arg;
            }
            else
            {
                foreach(c; to!string(arg))
                {
                    bar ~= MySpecialType(c);
                }
            }
        }

        // do more stuff
    }

Now, from my trace.log, some of the topmost things on the 
timing list are `std.array.Appender!(immutable(char).<more 
stuff>`. I also remember reading some years ago that ~= isn't 
optimal for speed.

So my question is: Is there a better and/or faster way of doing 
this, or is this the best approach?

I believe you are right to question the ~= in regards to 
performance. So, what I would do is replace this loop:

foreach(c; to!string(arg))
{
    bar ~= MySpecialType(c);
}

with this one liner:
bar ~= arg.map!(a => MySpecialType(a.to!char)).array;

To my mind, you replace multiple appends with just the one append 
(to be fair, I don't know what the .array is doing internally, 
but I'm sure whatever it does is nice and optimised).

Jordan