Improve usage of the "variant" idiom

[Tetralux]

The "variant" idiom used in encoding/json is a neat idiom that makes the code simple, but also quite powerful. It's also used in type information.
However, the usage of it is more confusing and awkward than it really needs to be.

value, err := json.parse(bytes);
assert(err == .None);

obj := value.value.(json.Object);

The extra value in there is a sideproduct of how there's common fields in the json.Value.

Null    :: distinct rawptr;
Integer :: i64;
Float   :: f64;
Boolean :: bool;
String  :: string;
Array   :: distinct [dynamic]Value;
Object  :: distinct map[string]Value;

Value :: struct {
	pos, end: Pos, // these fields would otherwise have to be in each of the union variants below...
	value: union {
		Null,
		Integer,
		Float,
		Boolean,
		String,
		Array,
		Object,
	}
}

This is quite a neat way of structuring the library, and also allows the variants to just be distinct types; it allows a json.String to be easily converted to and from string: json.String("hi") / string(my_json_str)

However, what you really want is a using-like thing: obj := value.(json.Object);.

Maybe with using value: union { in json.Value.

This could perhaps then allow you to obj := value.(json.Value);, while still allowing value.pos and value.end to work.

[gingerBill]

My only concern for this feature is that it would only make sense for unions and maybe anys. I know it's annoying as I do something v.value.(Null) a lot too, when I usually just want v.(Null), but I am not sure if that's the best approach to the problem, since it's just sugar.

[Tetralux]

One could argue though that using a union like this is actually just a natural extension of using, rather than a new feature per se.