Template Types
Type templates with promised functions that multiple real types can use.
This is an advanced feature.
Template types can be used to define common elements that multiple types will use. They can also be used to create type hierarchies.
All objects have one concrete (real) type. An object may have multiple template types.
Template types have a single name input in their member pattern. The type member goes at the root level of the script (with no indent.)
template type %TypeName%:
This name is written in standard,
a-z0-9_ format, without any quotes or brackets.template type Thing:
For clarity, example type names are written in
UpperCamelCase but this is only a style choice to prevent confusion with functions.A template type can hold function members inside it, which need to be indented by an extra unit.
Functions inside the type are considered to belong to that type. These are different from regular functions, but the format for writing them is the same.
template type Thing:
function my_func:
trigger:
print "hello"
template type Thing:
function my_func:
function another_func:
An empty template function cannot be directly run.
These functions may still have return types and parameters.
template type NamedThing:
function set_name (name):
function get_name:
return: String
Template types may use other templates.
template type Shape:
function get_sides:
template type Quadrilateral:
template: Shape
function get_sides:
trigger:
return 4
A template has two core uses.
Template types can form a hierarchy structure.
template type Shape:
function get_sides:
template type Quadrilateral:
template: Shape
function get_sides:
trigger:
return 4
type Square:
template: Quadrilateral
This can be used to provide information about objects of these types.
set {var} to a new Square
assert {var} is a Quadrilateral // Square uses Quadrilateral
assert {var} is a Shape // Quadrilateral uses Shape
assert {var} is an Object // all types are Objects
if {var} is a Shape:
print get_sides() from {var}
When a type uses a template, it inherits all of its functions. This allows multiple different types to use the same code, without needing to copy it.
template type Quadrilateral:
template: Shape
function get_sides:
trigger:
return 4
type Square:
template: Quadrilateral
type Rectangle:
template: Quadrilateral
In this example structure, both
Square and Rectangle will inherit the get_sides() function from their shared template Quadrilateral.set {square} to a new Square
set {rectangle} to a new Rectangle
assert get_sides() from {square} is 4
assert get_sides() from {rectangle} is 4
This default function can be overridden by a type that uses the template, simply by declaring an identical function.
template type Shape:
function get_sides:
trigger:
return 2
type Square:
template: Shape
function get_sides: // overrides Shape's get_sides()
trigger:
return 4
The function must be exactly identical to properly override. This includes specifying the same return-type.
By using template functions with no trigger, more advanced behaviour can be created.
These template functions assure us that a matching function will exist, but provide no behaviour or code for one.
Template functions are 'promised' - they don't exist yet, but promise that the type using this template is going to have that function.
The actual trigger for this template function must be added to the type using this template.
template type Shape:
function get_sides: // promised function
function describe:
trigger:
set {sides} to get_sides() from this object
print "This shape has " + {sides} + " sides!"
type Triangle:
function get_sides: // keeps the promise
trigger:
return 3
With this structure, we can now run the
describe() function from Shape but it will use the get_sides() trigger from Triangle.set {shape} to a new Triangle
run describe() from {shape} // runs Triangle's describe()
Last modified 1yr ago