How to force object key name in array - yaml

Question

I am using YAML to mark up some formulas and using JSON schema to provide a reference schema.
An example of the YAML might be:
formula: # equates to '5 + (3 - 2)'
add:
- 5
- subtract: [3, 2]
While I have figured out how to make the immediate child object of the formula ("add" in this example) have the right key name and type (using a "oneOf"array of "required"s). I am not sure how to ensure that object of an array ("subtract") likewise use specific key names.
So far, I can ensure the type using the following. But with this method, as long as the object used matches the subtract type, it is allowed any key name, it is not restricted to subtract:
"definitions: {
"add": {
"type": "array",
"minItems": 2,
"items": {
"anyOf": [
{ "$ref": "#/definitions/value"}, # value type is an integer which allows for the shown scalar array elements
{ "$ref": "#/definitions/subtract" }
// other operation types
]
}
},
"subtract": {
"type": "array",
"minItems": 2,
"maxItems": 2,
"items": {
"anyOf": [
{ "$ref": "#/definitions/value"},
{ "$ref": "#/definitions/add" }
// other operation types
]
}
}
// other operation types
}
How can I introduce a restriction such that the keys of objects in the array match specific names, while still also allowing scalar elements?

Answer 1

It sounds like what you want is recursive references.
By creating a new definition which is oneOf the operations and value, which then allow items which then reference back to the new definition, you have recursive references.
"definitions: {
"add": {
"type": "array",
"minItems": 2,
"items": { "$ref": "#/definitions/operations_or_values"},
},
"subtract": {
"type": "array",
"minItems": 2,
"maxItems": 2,
"items": { "$ref": "#/definitions/operations_or_values"},
}
// other operation types
"operations_or_values": {
"anyOf": [
{ "$ref": "#definitions/add" },
{ "$ref": "#definitions/subtract" },
{ "$ref": "#definitions/value" }, # value type is an integer which allows for the shown scalar array elements
{ "$ref": "#definitions/[OTHERS]" },
]
}
}
I haven't had time to test this, but I believe it will be, or be close to, what you need. Let me know if it doesn't work. I may not have full understood the question.

Answer 2

What a fascinating problem! This remarkably concise schema can express any expression.
{
"type": ["object", "number"],
"propertyNames": { "enum": ["add", "subtract", "multiply", "divide"] },
"patternProperties": {
".*": {
"type": "array",
"minItems": 2,
"items": { "$ref": "#" }
}
}
}

Answer 3

So what I ended up doing was extending the idea of I already used with the '"oneOf"array of "required", adding an "anyOf".
Thus, an operator schema is now:
"definitions": {
"add": {
"type": "array",
"minItems": 2,
"items": {
"anyOf": [
{ "$ref": "#/definitions/literal" }, // equates to a simple YAML scalar
{ "$ref": "#/definitions/constant" },
{ "$ref": "#/definitions/variable" },
{
"type": "object",
"oneOf": [
{ "required": ["add"] },
{ "required": ["subtract"] }
// more operator names
],
"properties": {
"add": { "$ref": "#/definitions/add" },
"subtract": { "$ref": "#/definitions/subtract" }
// more operator type references
}
}
]
}
},
// more definitions
}
This can be refactored to something that applies more easily across different operators like so:
"definitions": {
"operands": {
"literal": { "type": "number" }, // equates to a simple YAML scalar
"constant": {
"type": "object",
"properties": {
"value": { "type": "number" }
},
"required": [ "value" ]
},
"variable": {
"type": "object",
"properties": {
"name": { type": "string" },
"type": { "type": "string" }
},
"required": [ "name", "type" ]
}
}
"operators": {
"add": {
"type": "array",
"minItems": 2,
"items": { "$ref": "#/definitions/anyOperandsOrOperators" }
},
"subtract": {
"type": "array",
"minItems": 2,
"maxItems": 2,
"items": { "$ref": "#/definitions/anyOperandsOrOperators" }
}
// more operator types
},
"anyOperator": {
"type": "object",
"oneOf": [
{ "required": ["add"] },
{ "required": ["subtract"] }
// more operator names
],
"properties": {
"add": { "$ref": "#/definitions/operators/add" },
"subtract": { "$ref": "#/definitions/operators/subtract" }
// more operator type references
}
},
"anyOperandsOrOperators":
{
"anyOf": [
{ "$ref": "#/definitions/operands/literal" },
{ "$ref": "#/definitions/operands/constant" },
{ "$ref": "#/definitions/operands/variable" },
{ "$ref": "#/definitions/anyOperator"}
]
}
}
And this means the YAML for an operator can look as follows
\/mapping \/mapping
add:[ 5, subtract:[ *constantA, *variableB ] ]
scalar^ ^mapping with specific name