$ref, $anchor and $dynamicRef, $dynamicAnchor

[SorinGFS]

Reading the specifications I understand that the only difference between $ref, $anchor and $dynamicRef, $dynamicAnchor consists in the moment in which references are resolved, at schema load for $ref, at runtime for $dynamicRef. I found that this method of doubling the number of words is quite difficult to follow and understand. Instead I would prefer something like this:

{
    "$ref": {
        "anyOf": [
            { "type": "string", "format": "uri-reference" },
            {
                "type": "object",
                "properties": {
                    "uri": { "type": "string", "format": "uri-reference" },
                    "dynamic": { "type": "boolean", "default": false }
                }
            }
        ]
    },
    "$anchor": {
        "anyOf": [
            { "type": "string"},
            {
                "type": "object",
                "properties": {
                    "string": { "type": "string"},
                    "dynamic": { "type": "boolean", "default": false }
                }
            }
        ]
    }
}

This fallback system would allow us to use the shorthand version for most of the cases, and would be self-descriptive for the rest.

{ "foo": { "$ref": "#/$defs/bar" }

would be the same as:

{ "foo": { "$ref": { "uri": "#/$defs/bar" } }

while dynamic ref would be:

{ "foo": { "$ref": { "uri": "#/$defs/bar", "dynamic": true } }

I don't know if this schema compositing method is possible, I just wanted to describe a way of thinking. Personally when in my work I combine two words into a variable name there is a sign for future trouble, and I try to avoid that whenever is possible. In json-schema specs are multiple places where keywords having almost similar functionalities are conceived as separate keywords instead of single keyword with an extra attribute.

[jdesrosiers]

Reading the specifications I understand that the only difference between $ref, $anchor and $dynamicRef, $dynamicAnchor consists in the moment in which references are resolved, at schema load for $ref, at runtime for $dynamicRef.

That's not correct. Dynamic references and normal references are resolved in different ways. It's not just a matter of when references are resolved. Technically, there is some overlap of behavior, but only when you use a dynamic reference wrong. When using a dynamic reference the wrong way, it falls back to behaving like a normal reference. I'm trying to change that so there is less of this kind of misunderstanding. Your example of a dynamic reference is not correct (although technically not allowed). It can't express dynamic behavior because it doesn't reference a dynamic anchor.

This StackOverflow answer may help you better understand this feature, https://stackoverflow.com/questions/69728686/69774520#69774520

[SorinGFS]

Thank you for explanations. I think that any approach that would ultimately lead to the simplification of the reference system is welcome.

Did I understand correctly, $dynamicRef as an analogy is about the same thing as dynamic import? If so, wouldn't it be more appropriate to call it import, or include?

[jdesrosiers]

Did I understand correctly, $dynamicRef as an analogy is about the same thing as dynamic import?

I've never thought of a dynamic reference as a dynamic import. I'm not seeing how you're associating the two. I'm not sure if that means your understanding of dynamic references is wrong, or that I'm failing to understand your analogy. In any case, I don't think the concept of an import makes much sense in JSON Schema. The one place we have a concept that I think is similar to an import is $vocabularies whose values make certain keywords available to the schema.