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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
interfaces
----------
alternative 1: place function pointer directly in the object
------------------------------------------------------------
pros:
simple
fast(little indirection)
cons:
wastes space
extending an interface breaks the ABI of all subtypes
namespace File = {
typedef this = (
Reader base,
Writer base,
const int mode,
() *close(File* this),
);
}
alternative 2: use a vtable
---------------------------
pros:
uses only one pointer per instance of each interface
cons:
one extra pointer lookup
namespace File = {
typedef this = (
interface, // generates the required interface pointer
Reader base,
Writer base,
const int mode,
// interface methods are inserted into the vtable.
() interface close(File* this),
// we could also use "virual" as the keyword
() virtual close(File* this),
);
}
namespace File = {
const typeinst VTable vtable = (
() close(File* this) = File.close,
);
typedef this = (
VTable *interface,
Reader base,
Writer base,
const int mode,
);
}
File a = File.open("test.txt");
a.*.close();
alternative 3: use an independent vtable
----------------------------------------
pros:
only one pointer needed per object!
cons:
one extra pointer is needed everywhere an object implementing the
interface is referenced.
alternative 4: don't use interaces directly
-------------------------------------------
pros:
no extra language features
very clear what's going on
the "interface" can check the parameters and then call the real
implementation
cons:
would most likely require more code
should interfaces be "fake is-a" (=has-a) or real "is-a"
--------------------------------------------------------
"is-a" implies "has-a", because if an object doesn't have the data of the
base class, then it can't work in place of the inherited class.
a class can "have" an interface.
Syntax for type 4 interfaces
----------------------------
namespace util {
typedef iterable[T,E] = interface (
iterator[???,E]^ get_iterator(T^ this),
);
typedef iterator[I,E] = interface (
bool next_element(var I^ this, var E^ result),
);
}
namespace range {
implements iterator[range,int];
bool next_element(var range^ this, var int^ result) {
...
}
}
namespace iter_printer[I,E] {
() print(interface[iterator[I,E]] iter);
// translated to
//() print((var I^ value, iterator:interface[I,E]^ if_iterator) iter);
}
|
