Instance behaviors

[Anaminus]

Each non-property field on an instance can be thought of as a "behavior". These behaviors can be configured. When an instance is indexed, the the combination of the instance's class and the given index can be used to look up a behavior.

For example, when an instance of class "DataModel" is indexed with the string "GetService", this is checked against a behavior descriptor. If the descriptor has a behavior for that combination, that behavior is used. A descriptor might define instances of class DataModel with field GetService to have a behavior "ServerProvider.GetService". This behavior causes the GetService method to be returned, which then behaves as the GetService method does currently.

This feature extends descriptors with the $rbxmkBehavior field. This is separate from descriptor extensions (#65) because the content of of the field has its own distinct structure:

// Fields with "Foo" are stand-ins for some defined value.
{
	"$rbxmkBehavior": {
		"Classes": { // Set of classes that define behaviors.
			"FooInstance": { // Name of a class to which behaviors will be applied.
				// If false, prevent behaviors being applied to subclasses of
				// FooInstance. Defaults to true.
				"Inheritable": false,
				// Map of fields to behaviors. Each key is the name of a field that
				// indexes an instance of FooInstance. The field need not exist, or
				// have a corresponding descriptor. The "sym." prefix causes a
				// symbol to be used. Each value is the name of a predefined
				// behavior. While it may not always be the case, behaviors are
				// usually derived from some instance property or method, in which
				// case their name will have the form "<class>.<member>".
				// Regardless, this is only a name.
				"Behaviors": {
					// Properties can be mapped to property behaviors.
					"FooProperty": "Instance.Property",
					// Methods can be mapped to method behaviors.
					"FooMethod": "Instance.Method",
					// A field name can be a symbol.
					"sym.FooSymbol": "Instance.Symbol",
				},
			}
		}
	}
}

Most of the features planned to use descriptor extensions are more suited to use behaviors instead. The following list gives an overview of possible behaviors that could be implemented from current and planned features:

• Basic
  • Instance.Name: Property used by methods that query the name of an instance.
  • Instance.Parent: Property used to get or set parent instance.
  • Instance.ClearAllChildren: Behaves as ClearAllChildren method.
  • Instance.Clone: Behaves as Clone method.
  • Instance.Destroy: Behaves as Destroy method.
  • Instance.FindFirstAncestor: Behaves as FindFirstAncestor method.
  • Instance.FindFirstAncestorOfClass: Behaves as FindFirstAncestorOfClass method.
  • Instance.FindFirstAncestorWhichIsA: Behaves as FindFirstAncestorWhichIsA method.
  • Instance.FindFirstChild: Behaves as FindFirstChild method.
  • Instance.FindFirstChildOfClass: Behaves as FindFirstChildOfClass method.
  • Instance.FindFirstChildWhichIsA: Behaves as FindFirstChildWhichIsA method.
  • Instance.GetChildren: Behaves as GetChildren method.
  • Instance.GetDescendants: Behaves as GetDescendants method.
  • Instance.GetFullName: Behaves as GetFullName method.
  • Instance.IsA: Behaves as IsA method.
  • Instance.IsAncestorOf: Behaves as IsAncestorOf method.
  • Instance.IsDescendantOf: Behaves as IsDescendantOf method.
• Symbolic
  • Desc
  • IsService
  • Properties
  • RawDesc
  • Reference
• Descend
  • Descend: Behaves as Descend method.
• DataModel
  • ServiceProvider.GetService: Behaves as GetService method.
  • DataModel.Metadata: Get/set root metadata.
• Attributes
  • Instance.AttributesSerialize: Property used to serialize attributes.
  • Instance.GetAttribute: Behaves as GetAttribute method.
  • Instance.GetAttributes Behaves as GetAttributes method.
  • Instance.SetAttribute Behaves as SetAttribute method.
  • Instance.SetAttributes Behaves as SetAttributes method.
• Tags
  • Instance.Tags: Property used to serialize tags.
  • CollectionService.AddTag: Behaves as AddTag method.
  • CollectionService.GetAllTags: Behaves as GetAllTags method.
  • CollectionService.GetTagged: Behaves as GetTagged method.
  • CollectionService.GetTags: Behaves as GetTags method.
  • CollectionService.HasTag: Behaves as HasTag method.
  • CollectionService.RemoveTag: Behaves as RemoveTag method.
• Pivots
  • PVInstance.GetPivot: Behaves as GetPivot method.
  • PVInstance.PivotTo: Behaves as PivotTo method.
  • Model.WorldPivotData
  • Model.WorldPivot
  • Model.PrimaryPart
  • Model.GetPrimaryPartCFrame
  • Model.SetPrimaryPartCFrame
  • Model.GetBoundingBox
  • BasePart.CFrame
  • BasePart.Orientation
  • BasePart.Position
  • BasePart.Rotation
  • BasePart.Size
  • Attachment.CFrame: The primary property from which other Attachment properties are derived.
  • Attachment.Axis
  • Attachment.Orientation
  • Attachment.Position
  • Attachment.SecondaryAxis
  • Attachment.WorldAxis
  • Attachment.WorldCFrame
  • Attachment.WorldOrientation
  • Attachment.WorldPosition
  • Attachment.WorldSecondaryAxis
  • Bone.Transform
  • Bone.TransformedCFrame
  • Bone.TransformedWorldCFrame

Notably, Instance.ClassName cannot be a behavior, because the class is needed to resolve which behavior to select. It could be defined under $rbxmkConfig instead, though.

The default global descriptor would define the expected class/fields to map to their expected behaviors. This would make all behaviors available by default, while giving the user the option to fully customize instance behavior.

Symbols

If symbols can be mapped, then should the implementation of the sym library be revised? Instead of having a defined set of symbols, the sym library would generate a symbol for the indexed name on the fly, allowing any symbol name to be used. Then behaviors can be mapped to any arbitrary symbol instead of from a limited baked-in set.

On the other hand, behaviors could eliminate the need for symbols entirely. The purpose of symbols is to have fields that are forward-compatible with any additions Roblox might make to instances. If all behaviors are user-definable, then they can just be redefined to make way for any additions from Roblox.