Re: internal compiler error with immutable

[Ali Çehreli via Digitalmars-d-learn]

On 02/07/2015 06:35 AM, Danny wrote:

> What I'm trying to do is save space by putting often-used Attrs into an
> array and just compressing references to those into 1 Byte in the other
> data structures where it's used (these other data structures are not
> thread-local).

The following is based on my understanding of that description:

import std.conv;
import std.concurrency;
import std.stdio;

class C
{
    int value;

    // Constructor for immutable(C) objects
    this (int value) immutable
    {
        this.value = value;
    }
}

// Stores commonly used C objects and allows access to them by
// ubyte indexes
class CommonlyUsedCs
{
    immutable(C)[] cs;

    // This add() works on 'shared' CommonlyUsedCs objects
    ubyte add(immutable(C) c) shared
    {
        ubyte index;

        synchronized {
            index = cs.length.to!ubyte;
            cs ~= c;
        }

        return index;
    }

    immutable(C) get(ubyte index) const shared
    {
        return cs[index];
    }
}

void main()
{
    auto cucs = new shared(CommonlyUsedCs)();

    // Populate the Cs
    foreach (ubyte i; 0 .. 10) {
        if (i % 2) {
            cucs.add(new immutable(C)(i));
        }
    }

    // Start a thread and tell it what index its C is at
    spawn(&user, cucs, ubyte(3));
}

void user(shared(CommonlyUsedCs) cucs, ubyte index)
{
    writefln("My C has value %s", cucs.get(index).value);
}

Ali