Add a `get_or_set_default` method to Dictionary

[aaronfranke]

Describe the project you are working on

A game with a lot of dynamic code.

Describe the problem or limitation you are having in your project

I often find myself needing this pattern:

var value
if dict.has(name):
	value = dict[name]
else:
	value = default_value
	dict[name] = value

This code could also be written like this, but it involves accessing the Dictionary 3 times instead of 2:

if not dict.has(name):
	dict[name] = default_value
var value = dict[name]

Describe the feature / enhancement and how it helps to overcome the problem or limitation

I propose adding a method to handle this pattern. I'm not certain of what to call it, the best thing I can think of at the moment is get_or_set_default. I think this should be readable and convey what it does well.

Example use case:

func _ready() -> void:
	var dict: Dictionary = {}
	_add_to_array_in_dict(dict, "test1", "hi1")
	_add_to_array_in_dict(dict, "test1", "hi2")
	_add_to_array_in_dict(dict, "test2", "hi3")
	print(dict) # { "test1": ["hi1", "hi2"], "test2": ["hi3"] }


func _add_to_array_in_dict(dict: Dictionary, key: String, value: Variant) -> void:
	var array: Array = dict.get_or_set_default(key, [])
	array.append(value)

Without get_or_set_default, the _add_to_array_in_dict method would need to be 2 to 5 lines longer. The proposed get_or_set_default would also be naturally faster because it would be written in C++ instead of GDScript.

Describe how your proposal will work, with code, pseudo-code, mock-ups, and/or diagrams

godotengine/godot#78095 Add a get_or_set_default method to Dictionary and expose it.

If this enhancement will not be used often, can it be worked around with a few lines of script?

It can be worked around in a few lines of script, but it will be used often. At least, I am using it often. I have no idea how common this pattern is in other people's Godot games.

Is there a reason why this should be core and not an add-on in the asset library?

It's very tiny and heavily related to Dictionary, so it would be most optimal to put it there.

[RandomShaper]

For inspiration: https://docs.python.org/3/library/stdtypes.html#dict.setdefault.

[CarpenterBlue]

I heavily rely on the get_meta() function that provide default argument. This seems very similar. Maybe the function should follow the same pattern, instead of changing the Dictionary, simply return default. Nvm, I reread the proposal, that probably wouldn't solve the use case OP describes.

[SysError99]

This type of problem isn't unique to Godot either. Usually, we have Dictionary.get() that gives default value if the key doesn't exist. I just safely read the spot, then write back the value after done manipulating.

# Assuming we have 'dict: Dictionary' and 'key: String'
var array := dict.get(key, []) as Array
array.resize(4)
array[0] = "This"
array[1] = "is"
array[2] = "a"
array[3] = "test"
dict[key] = array

I'm not opposed to the proposal but I think we could have better name for it. I think set_default might fit better and shorter. Plus it's similar to what Python offers.

[aaronfranke]

I know everyone already loves this method, but here is further justification in the form of a real-world use-case. I have this code in the OMI_physics_joint implementation in Godot:

func _get_or_create_state_constraints_in_state(state: GLTFState) -> Array:
	var state_json: Dictionary = state.get_json()
	var state_extensions: Dictionary
	if state_json.has("extensions"):
		state_extensions = state_json["extensions"]
	else:
		state_extensions = {}
		state_json["extensions"] = state_extensions
	var omi_physics_joint_doc_ext: Dictionary
	if state_extensions.has("OMI_physics_joint"):
		omi_physics_joint_doc_ext = state_extensions["OMI_physics_joint"]
	else:
		omi_physics_joint_doc_ext = {}
		state_extensions["OMI_physics_joint"] = omi_physics_joint_doc_ext
		state.add_used_extension("OMI_physics_joint", false)
	var state_constraints: Array
	if omi_physics_joint_doc_ext.has("constraints"):
		state_constraints = omi_physics_joint_doc_ext["constraints"]
	else:
		state_constraints = []
		omi_physics_joint_doc_ext["constraints"] = state_constraints
	return state_constraints

With get_or_set_default, the code shrinks down to just this:

func _get_or_create_state_constraints_in_state(state: GLTFState) -> Array:
	var state_json: Dictionary = state.get_json()
	var state_extensions: Dictionary = state_json.get_or_set_default("extensions", {})
	var omi_physics_joint_doc_ext: Dictionary = state_extensions.get_or_set_default("OMI_physics_joint", {})
	state.add_used_extension("OMI_physics_joint", false)
	var state_constraints: Array = omi_physics_joint_doc_ext.get_or_set_default("constraints", [])
	return state_constraints

[KoBeWi]

You can use merge() to assign multiple default values:

var state_json = state.get_json()
state_json.merge({"extensions": {}, "OMI_physics_joint": {}, "OMI_physics_joint": false, "constraints": []}

[timothyqiu]

You can use merge() to assign multiple default values

merge() can't be used if you don't know the keys in advance.

# url_patterns is Dict[String, String], user defined
for app_name in url_patterns:
    allowed_patterns.set_default(app_name, []).append(url_patterns[app_name])

[aaronfranke]

@KoBeWi It doesn't make sense to construct an unnecessary Dictionary when instead we can just pass the values. Also, the code you gave is not at all equivalent to what I posted.