Customize sum type JSON encoding and decoding

[nicolashery]

Is there a way to customize the JSON encoding/decoding of sum types?

Here is a simplified example of what I'm working with:

module main

import json

struct Item {
	id   string
	name string
}

struct AddItem {
	item Item
}

struct UpdateItem {
	item Item
}

struct DeleteAllItems {}

type Action = AddItem | UpdateItem | DeleteAllItems

fn example_actions() []Action {
	return [
		AddItem{
			item: Item{
				id:   '1'
				name: 'item1'
			}
		},
		UpdateItem{
			item: Item{
				id:   '1'
				name: 'item1-updated'
			}
		},
		DeleteAllItems{},
	]
}

fn main() {
	println(json.encode_pretty(example_actions()))
}

This outputs:

[
  {
    "_type": "AddItem",
    "item": {
      "id": "1",
      "name": "item1"
    }
  },
  {
    "_type": "UpdateItem",
    "item": {
      "id": "1",
      "name": "item1-updated"
    }
  },
  {
    "_type": "DeleteAllItems"
  }
]

What if I'd like the "tag" property to be "type" instead of "_type", and the tag values to be snake case (ex: "add_item" instead of "AddItem")? To my knowledge that is not possible at the moment in V.

In Rust, using Serde's different enum representations, I can specify the attribute arguments tag and rename_all as follows:

#[derive(Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
enum Action {
    AddItem(AddItem),
    UpdateItem(UpdateItem),
    DeleteAllItems,
}

Which would produce the desired JSON format:

[
  {
    "type": "add_item",
    "item": {
      "id": "1",
      "name": "item1"
    }
  },
  {
    "type": "update_item",
    "item": {
      "id": "1",
      "name": "item1-updated"
    }
  },
  {
    "type": "delete_all_items"
  }
]

Another use-case would be wanting to use the "adjacently tagged" format instead of the "internally tagged" format that is currently produced by V.

Again using Rust as an example, I can add the Serde attribute argument content:

#[derive(Serialize, Deserialize)]
#[serde(tag = "type", content = "value", rename_all = "snake_case")]
enum Action {
    AddItem(AddItem),
    UpdateItem(UpdateItem),
    DeleteAllItems,
}

Which would produce:

[
  {
    "type": "add_item",
    "value": {
      "item": {
        "id": "1",
        "name": "item1"
      }
    }
  },
  {
    "type": "update_item",
    "value": {
      "item": {
        "id": "1",
        "name": "item1-updated"
      }
    }
  },
  {
    "type": "delete_all_items"
  }
]

One of the reason I'm asking is it would make working with existing APIs that use these formats to represent sum types (or discriminated unions) easier?

[jorgeluismireles]

Just an idea https://play.vlang.io/p/8ce5492e7b :

import json

struct Item {
	id   string   @[omitempty]
	name string   @[omitempty]
	action Action
}

enum Action {
	add
	update
	delete_all
}

fn main() {
	println(json.encode_pretty([
		Item{ id:'1', name:'item', action:.add },
		Item{ id:'1', name:'item1-updated', action:.update },
		Item{ action:.delete_all }
	]))
}

[{
		"id":	"1",
		"name":	"item",
		"action":	"add"
	}, {
		"id":	"1",
		"name":	"item1-updated",
		"action":	"update"
	}, {
		"action":	"delete_all"
	}]

[JalonSolov]

The type -> _type thing should be fixed. Probably leftovers from before V allowed using keywords as field names.

[jorgeluismireles]

To conform with your last json you could do this:

import json

struct Elem {
	typ   Type @[json:"type"]
	value Value @[omitempty]
}

struct Value {
	item Item
}

struct Item {
	id   string
	name string
}

enum Type {
	add_item
	update_item
	delete_all_items
}

println(json.encode_pretty([
	Elem{ typ:.add_item, value:Value{ item:Item{id:'1', name:'item1'}} },
	Elem{ typ:.update_item, value:Value{ item:Item{id:'1', name:'item1-updated'}} },
	Elem{ typ:.delete_all_items }
]))

[{
		"type":	"add_item",
		"value":	{
			"item":	{
				"id":	"1",
				"name":	"item1"
			}
		}
	}, {
		"type":	"update_item",
		"value":	{
			"item":	{
				"id":	"1",
				"name":	"item1-updated"
			}
		}
	}, {
		"type":	"delete_all_items"
	}]

[nicolashery]

Thank you for your replies @jorgeluismireles. I see you suggest using an enum instead of a sum type. Let me expand on my example a bit to better illustrate why I prefer to use a sum type:

• I will add a DeleteItem action that doesn't have the same shape as the CreateItem and UpdateItem actions, and is not an empty struct
• I will add a fn transform_action function that uses match which I think is one of the powerful feature of sum types (and granted, match also works with enums but we'll see why that doesn't provide the type safety I'd like in this particular case)

struct Item {
	id   string
	name string
}

struct AddItem {
	item Item
}

struct UpdateItem {
	item Item
}

struct DeleteItem {
	id string
}

struct DeleteAllItems {}

type Action = AddItem | UpdateItem | DeleteItem | DeleteAllItems

fn transform_action(action Action) string {
	return match action {
		AddItem {
			'add_item ${action.item.id} ${action.item.name}'
		}
		UpdateItem {
			'update_item ${action.item.id} ${action.item.name}'
		}
		DeleteItem {
			// type error: `DeleteItem` has no field named `item`
			'delete_item ${action.item.id}'
		}
		DeleteAllItems {
			'delete_all_items'
		}
	}
}

You can see that matching on the Action sum type, the compiler helps us avoid the mistake of calling action.item.id on a DeleteItem.

If I were to write this example using the enum pattern, I imagine it would look something like this:

module main2

enum ActionType {
	add
	update
	delete
	delete_all
}

struct Action {
	type ActionType
	item Item   @[omitempty]
	id   string @[omitempty]
}

struct Item {
	id   string
	name string
}

fn transform_action(action Action) string {
	return match action.type {
		.add {
			'add_item ${action.item.id} ${action.item.name}'
		}
		.update {
			'update_item ${action.item.id} ${action.item.name}'
		}
		.delete {
			// no type error!
			'delete_item ${action.item.id}'
		}
		.delete_all {
			'delete_all_items'
		}
	}
}

And in this case since Action is a struct that is a "bag" of possibly uninitialized values, the compiler can't help us avoid the mistake of calling action.item.id (instead of action.id) on a "delete item" action.

Thus my choice of using sum types as runtime representation, and my original question of being able to customize its JSON encoding/decoding.