-
Notifications
You must be signed in to change notification settings - Fork 0
/
Interfaces.t2t
103 lines (84 loc) · 2.62 KB
/
Interfaces.t2t
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
Interfaces
%!includeconf: config.t2t
== Overview ==
Interfaces are a key concept of Pool. Intrfaces allow you to write functions
that work with many representations of data as long as they share the required
set of characteristics. A simple example of this is below.
```
sum { (total: int)( array :Array!int );
total = 0;
array.foreach { (i :int)
total += int;
}
}
```
This adds up all of the intergers in the array and returns the result. But what
if I have a ``List``? or a ``Tree``? The simple solution is interfaces.
```
sum { (total: int)( items :Set!int );
total = 0;
items.foreach { (i :int)
total += int;
}
}
```
Now you can pass in anything that is a set. Anything that has some elements and
can return them in order.
== Using Interfaces ==
Variable declarations in Pool are based on interfaces. They are the ``var``
keyword followed by the variable name then interface specifiers. Examples are
below.
```
var a; // Any type, defaults to Object.
var b :Set!int; // Will take any set of ints.
var c :Map!int :List!int; // Will take any map of ints that is also ordered.
```
== Declaring Interfaces ==
The declaration of interfaces is simple. It is the ``iface`` keyword followed
by braces and the things inside the interface.
```
iface { IntGenerator;
(int) get ();
}
```
Notice that there is no need to mark all of the elements public, everything in
an interface is public by default.
You can then use the interface like so:
```
[[ ( total :int ) sum5 ( gen :IntGenerator );
Array::range(0,4).foreach{
total += gen.get();
}
]]
```
Now anyone can sum the first 5 nubmers from any generator sequence.
== Implementing Interfaces ==
The details are covered in the [[Classes]] section but we will skim over it
here. The syntax is derived from declaring variables. You basicly say that
the class implements the interface with ``:``.
```
class { Fibonacci :IntGenerator;
var prev1 = 0;
var prev2 = 0;
[[ (int) get ();
if ( prev2 = 0 ) // For first few.
{
prev2 = prev1;
prev1 = 1;
}
else
{
prev1, prev2 = prev1+prev2, prev1;
return prev1;
}
]]
}
```
== Summary ==
Pool is completly interface centric and while the examples are very bad examples
of interfaces (or at least the name should be better) interfaces allow you to
write reusable library code and the user doesn't have to worry about the type
being passed in. This also allows you to switch datatypes without having to
refactor your program, making optimization much easier. If you use specialized
types in all of your functions you will run into issues later on. Only use
the types required and your functions will be more useful.