1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
|
# Metamethods
This language relies on a small set of "metamethods" which define special
behavior that is required for all types:
- `as_text(obj:&(optional)T, colorize=no, type:&TypeInfo)->Text`: a method to
convert the type to a string. If `colorize` is `yes`, then the method should
include ANSI escape codes for syntax highlighting. If the `obj` pointer is
`NULL`, a string representation of the type will be returned instead.
- `compare(x:&T, y:&T, type:&TypeInfo)->Int32`: Return an integer representing
the result of comparing `x` and `y`, where negative numbers mean `x` is less
than `y`, zero means `x` is equal to `y`, and positive numbers mean `x` is
greater than `y`. For the purpose of floating point numbers, `NaN` is sorted
as greater than any other number value and `NaN` values are compared bitwise
between each other.
- `equals(x:&T, y:&T, type:&TypeInfo)->Bool`: This is the same as comparing two
numbers to check for zero, except for some minor differences: floating point
`NaN` values are _not_ equal to each other (IEEE 754) and the implementation
of `equals` may be faster to compute than `compare` for certain types, such
as tables.
Metamethods are automatically defined for all user-defined structs, DSLs, and
enums. At this time, metamethods may not be overridden.
## Generic Metamethods
Due to the presence of pointers, arrays, tables, and functions, there are
potentially a very large number of metamethods that would be required if
_every_ type had its own set of metamethods. To reduce the amount of generated
code, we use generic metamethods, which are general-purpose functions that take
an automatically compiled format string and variable number of arguments that
describe how to run a metamethod for that type. As a simple example, if `foo`
is an array of `Foo` structs, which has a defined `as_text()` method, then
rather than define a separate `Foo_Array_as_text()` function which would be 99%
identical to a `Baz_Array_as_text()` function, we instead insert a call to
`as_text(&foo, colorize, $ArrayInfo(&Foo))` to convert a `[Foo]` array to a
string, and you call `as_text(&baz, colorize, $ArrayInfo(&Baz))` to convert a
`[Baz]` array to a string. The generic metamethod handles all the reusable
logic like "an array's string form starts with a '[', then iterates over the
items, getting the item's string form (whatever that is) and putting commas
between them".
Similarly, to compare two tables, we would use `compare(&x, &y,
$TableInfo(&KeyType, &ValueType))`. Or to hash an array of arrays of type
`Foo`, we would use `hash(&foo, $ArrayInfo($ArrayInfo(&Foo)))`.
|
