V's none can be mapped to JSON/TOML as an empty map.

[jorgeluismireles]

Mapping V's option none to JSON is not defined currently and is pending. If none is a value of a map, the key/value pair can be omitted from the JSON map. But if none is an element of an array with options, none cannot be omitted since the JSON array length would be affected.

V's optional array [?int(0), none, 2] could be encoded as the valid JSON text [0,null,2].

But alternatively we can define a sum type Elem = int | Empty where Empty is an empty struct struct Empty { } and then have and array converted to [Empty(0), { }, 2 ] and converted to (also) valid JSON [0,{},2].

The sum type method seems more complicated but the text works also for TOML, a format that does not have a null as JSON does.

In the next program valid TOML text elems = [ 0, {}, 2 ] is converted to json text (TOML uses json2). Then the produced json text is encoded correctly by json2 into a V's type of map[string][]Elem.

import toml
import toml.to
import x.json2
//import x.json2.decoder2

struct Empty { 
	
}

type Elem = int | Empty

const toml_text = 'elems = [ 0, {}, 2 ]'
const json_text = '{ "elems": [ 0, { }, 2 ] }'

fn main() {
	doc := toml.parse_text(toml_text)!
	dump(to.json(doc))
	assert to.json(doc) == json_text

	empty := Empty{}

	mut elems := { "elems": [ Elem(0), empty, 2 ]}
	encoded := json2.encode(elems)
	dump(encoded)

	json_decode(encoded)
}

fn json_decode(encoded string) {
	/*e := decoder2.decode[map[string][]Elem](encoded) or {
		dump(err)
		return
	}
	dump(e)*/
}

[250908-d.v:17] toml.to.json(doc): { "elems": [ 0, { }, 2 ] }
[250908-d.v:24] encoded: {"elems":[0,{},2]}

The problem with this idea is that decoder fails and while testing I filled issues #25261, #25262 and #25263 .

If json2 encoding/decoding can include EncodingOptions, then none could be mapped as null or empty map { } as a preference.

[jorgeluismireles]

Making sum type Elem = int | ?int, json currently can encode an array like [ Elem(1), Elem(?int(none)), 3 ] into json [1,{},3] as proposed here (don't know if in purpose or by side effect). In such sum type json2 fails with a V error.

Details in issue #25267 .

[jorgeluismireles]

Golang

Golang has json version 1 and version 2 and detailed instructions on how to migrate .

TLDR;
Some golang tags (equivalent of V attributes) meaning changes from version to version with new rules:

In v1, when marshaling a Go struct, a field marked as omitempty is omitted if the field value is an "empty" Go value, which is defined as false, 0, a nil pointer, a nil interface value, and any empty array, slice, map, or string. In contrast, v2 redefines omitempty to omit a field if it encodes as an "empty" JSON value, which is defined as a JSON null, or an empty JSON string, object, or array.

Similar to this discussion, versions changed the way to represent emptiness with whether JSON's null or {} or even []:

In v1, a nil Go slice or Go map is marshaled as a JSON null. In contrast, v2 marshals a nil Go slice or Go map as an empty JSON array or JSON object, respectively

And also specific objects holds preferences about how to select between null and []:

func FormatNilSliceAsNull(v bool)
FormatNilSliceAsNull specifies that a nil Go slice should marshal as a JSON null instead of the default representation as an empty JSON array (or an empty JSON string in the case of ~[]byte). Slice fields explicitly marked with format:emitempty still marshal as an empty JSON array.

V json2

In reality JSON is more complex than our first thoughts and is convenient to have a way to define and redefine how to convert V from/to JSON objects. I think json2 should define carefully the availability of preferences to the conversions that already started with ideas as EncoderOptions.

Web services importance

The web services written in different languages communicate with JSON messages that should be simple and flexible enough to prevent security issues and prevent wrong results.