Managed std.json.Value

[gh22749268]

Hello, i started to use Zig recently to write my personal project and i think it's great!
However i found defaut behaviour of std.json.Value not fitting to me due to large amount of small nested objects. Currently it's managed HashMap for object (arrays are also managed) because of that my memory usage is about 40% larger due to allocation of allocator.

I made simple copy of std.json.Value into my project, changing HashMap and Array into unmanaged variants, added allocator to method calls and as expected my memory usage was smaller, without any immediate issues.

Is there any reason for managed state being default one?
If so maybe there should be also unmanaged variant.

[andrewrk]

Thank you for filing this issue. I agree - at the very least there should be unmanaged variants, and unmanaged variants should be the default. Managed variants might still be nice for the use case when you want to have separate allocators per object, however.

[gh22749268]

I gave some thought about this and my idea is to add managed variants into union directly.

pub const Value = union(enum) {
    null,
    bool: bool,
    integer: i64,
    float: f64,
    number_string: []const u8,
    string: []const u8,
    array: ArrayUnmanaged,
    object: ObjectMapUnmanaged,

    // old variants
    array_managed: ArrayManaged,
    object_managed: ObjectMapManaged,
    // ...
}

I don't see any reason for fn jsonParse to return managed variants, so they would be default - unmanaged.
That way it wouldn't need to maintain 2 implementations, and Value could have both variants at once.
Perhaps there is more clever generic way, but my zig knowledge may lack.

Should i make PR containing these changes?

[andrewrk]

That looks like a nice way to do it. A PR would be welcome - although I can't promise to look at it soon.

[neurocyte]

Doesn't having both negate the space savings of moving to unmanaged containers?

[gh22749268]

Uhh.. you are absolutely right!
I focused too much on having both that i forgot about memory. One way to handle this could be using pointers but I'm not sure about this.