Use union for DreamValue

Using a union would allow you to avoid all boxing operations with DreamValue. Layout would look something like this:

[StructLayout(LayoutKind.Explicit)]
struct DreamValue
{
    [Flags]
    public enum DreamValueType : byte {
        String = 1,
        Integer = 2,
        Float = 4,
        Number = Integer | Float,
        DreamResource = 8,
        DreamObject = 16,
        DreamPath = 32,
        DreamProc = 64
    }

    [FieldOffset(0)]
    public DreamValueType Type { get; private set; }
    [FieldOffset(4)]
    public float FloatValue { get; private set; }
    [FieldOffset(4)]
    public int IntValue { get; private set; }
    [FieldOffset(8)] 
    public object RefValue { get; private set; }

    public DreamValue(String value)
    {
        Unsafe.SkipInit(out this);
        RefValue = value;
        IntValue = default;
        Type = DreamValueType.String;
    }

    public DreamValue(int value)
    {
        Unsafe.SkipInit(out this);
        RefValue = default;
        IntValue = value;
        Type = DreamValueType.Integer;
    }

    public DreamValue(int value)
    {
        Unsafe.SkipInit(out this);
        RefValue = default;
        FloatValue = value;
        Type = DreamValueType.Float;
    }

    public DreamValue(UInt32 value) : this((int) value)
    {
    }
}

It does beg the question though: why do you allow storing an int in DreamValue? It’s not a real data type in DM and it sounds like it would only complicate the code. This wouldn’t be necessary if DreamValue stores only floats.

[ike709]

@ZeWaka since you were looking into boxing memes

[wixoaGit]

The idea of making DreamValue into a union is no longer relevant since these are now the only two fields on it, and boxing is not as much of a concern anymore.

private object? _refValue;
private readonly float _floatValue;