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
142
143
144
|
package main
func main() {
thing := &Thing{"foo"}
println("thing:", thing.String())
thing.Print()
printItf(5)
printItf(byte('x'))
printItf("foo")
printItf(Foo(18))
printItf(*thing)
printItf(thing)
printItf(Stringer(thing))
printItf(Number(3))
array := Array([4]uint32{1, 7, 11, 13})
printItf(array)
printItf(ArrayStruct{3, array})
printItf(SmallPair{3, 5})
s := Stringer(thing)
println("Stringer.String():", s.String())
var itf interface{} = s
println("Stringer.(*Thing).String():", itf.(Stringer).String())
println("nested switch:", nestedSwitch('v', 3))
// Try putting a linked list in an interface:
// https://github.com/tinygo-org/tinygo/issues/309
itf = linkedList{}
}
func printItf(val interface{}) {
switch val := val.(type) {
case Unmatched:
panic("matched the unmatchable")
case Doubler:
println("is Doubler:", val.Double())
case Tuple:
println("is Tuple:", val.Nth(0), val.Nth(1), val.Nth(2), val.Nth(3))
val.Print()
case int:
println("is int:", val)
case byte:
println("is byte:", val)
case string:
println("is string:", val)
case Thing:
println("is Thing:", val.String())
case *Thing:
println("is *Thing:", val.String())
case Foo:
println("is Foo:", val)
default:
println("is ?")
}
}
func nestedSwitch(verb rune, arg interface{}) bool {
switch verb {
case 'v', 's':
switch arg.(type) {
case int:
return true
}
}
return false
}
type Thing struct {
name string
}
func (t Thing) String() string {
return t.name
}
func (t Thing) Print() {
println("Thing.Print:", t.name)
}
type Stringer interface {
String() string
}
type Foo int
type Number int
func (n Number) Double() int {
return int(n) * 2
}
type Doubler interface {
Double() int
}
type Tuple interface {
Nth(int) uint32
Print()
}
type Array [4]uint32
func (a Array) Nth(n int) uint32 {
return a[n]
}
func (a Array) Print() {
println("Array len:", len(a))
}
type ArrayStruct struct {
n int
a Array
}
func (a ArrayStruct) Nth(n int) uint32 {
return a.a[n]
}
func (a ArrayStruct) Print() {
println("ArrayStruct.Print:", len(a.a), a.n)
}
type SmallPair struct {
a byte
b byte
}
func (p SmallPair) Nth(n int) uint32 {
return uint32(int(p.a)*n + int(p.b)*n)
}
func (p SmallPair) Print() {
println("SmallPair.Print:", p.a, p.b)
}
// There is no type that matches this method.
type Unmatched interface {
NeverImplementedMethod()
}
type linkedList struct {
addr *linkedList
}
|
