Skip to content

Commit 6efac34

Browse files
author
Kevin Manley
committed
Added more functions
1 parent d99bcaf commit 6efac34

File tree

2 files changed

+106
-35
lines changed

2 files changed

+106
-35
lines changed

‎tuple.go

+42-2
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,13 @@
11
/*
22
Features:
3-
- python-style indexing
3+
- support for python-style negative indexes
44
- python-style comparison
55
- helper functions like popleft, popright, reverse
66
77
TODO:
88
// standardize terminology "items" vs. "elems"
9+
// rename to golang-list? it's more like a python list than python tuple since
10+
// it's mutable
911
// TODO:
1012
// func (this *Tuple) Zip(...*Tuple) Tuple {}
1113
// func (this *Tuple) Map(func) ? or Apply?
@@ -31,6 +33,22 @@ type Tuple struct {
3133
data []interface{}
3234
}
3335

36+
func max(lhs int, rhs int) int {
37+
if lhs > rhs {
38+
return lhs
39+
} else {
40+
return rhs
41+
}
42+
}
43+
44+
func min(lhs int, rhs int) int {
45+
if lhs < rhs {
46+
return lhs
47+
} else {
48+
return rhs
49+
}
50+
}
51+
3452
// Creates a new empty Tuple of length n
3553
func NewTuple(n int) *Tuple {
3654
t := &Tuple{}
@@ -67,10 +85,32 @@ func (this *Tuple) Len() int {
6785
}
6886

6987
// Returns the internal slice
70-
func (this *Tuple) Slice() []interface{} {
88+
func (this *Tuple) Data() []interface{} {
7189
return this.data
7290
}
7391

92+
// Returns a new tuple with copy of n leftmost items
93+
func (this *Tuple) Left(n int) *Tuple {
94+
return this.Slice(0, n)
95+
}
96+
97+
// Returns a new tuple with copy of n rightmost items
98+
func (this *Tuple) Right(n int) *Tuple {
99+
length := this.Len()
100+
n = max(0, length-n)
101+
return this.Slice(n, length)
102+
}
103+
104+
// Returns a new tuple with slice of this tuple's data
105+
func (this *Tuple) Slice(start int, end int) *Tuple {
106+
c := this.Copy()
107+
max := this.Len()
108+
start = min(c.Offset(start), max)
109+
end = min(c.Offset(end), max)
110+
c.data = c.data[start:end]
111+
return c
112+
}
113+
74114
// Convert n to an index into the internal slice.
75115
// Negative numbers are supported, e.g. -1 points to the last item
76116
func (this *Tuple) Offset(n int) int {

‎tuple_test.go

+64-33
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,18 @@ func assertEq(t *testing.T, lhs interface{}, rhs interface{}) {
1212
}
1313
}
1414

15+
func assertEqTuple(t *testing.T, lhs *Tuple, rhs *Tuple) {
16+
if lhs.Ne(rhs) {
17+
t.Error(lhs, ".Ne(", rhs, ")")
18+
}
19+
}
20+
21+
func assertNeTuple(t *testing.T, lhs *Tuple, rhs *Tuple) {
22+
if lhs.Eq(rhs) {
23+
t.Error(lhs, ".Eq(", rhs, ")")
24+
}
25+
}
26+
1527
func TestNewTuple(t *testing.T) {
1628
tup := NewTuple(3)
1729
n := tup.Len()
@@ -39,15 +51,45 @@ func TestNewTupleFromItems(t *testing.T) {
3951
func TestCopy(t *testing.T) {
4052
t1 := NewTupleFromItems(1, 2, 3)
4153
t2 := t1.Copy()
42-
assertEq(t, t1.Eq(t2), true)
54+
assertEqTuple(t, t1, t2)
4355
t1.Set(1, 20)
44-
assertEq(t, t1.Eq(NewTupleFromItems(1, 20, 3)), true)
45-
assertEq(t, t2.Eq(NewTupleFromItems(1, 2, 3)), true)
56+
assertEqTuple(t, t1, NewTupleFromItems(1, 20, 3))
57+
assertEqTuple(t, t2, NewTupleFromItems(1, 2, 3))
4658
}
4759

48-
func TestSlice(t *testing.T) {
60+
func TestData(t *testing.T) {
4961
tup := NewTupleFromItems(3, 2, 1)
50-
assertEq(t, fmt.Sprintf("%x", tup.Slice()), fmt.Sprintf("%x", []int{3, 2, 1}))
62+
assertEq(t, fmt.Sprintf("%x", tup.Data()), fmt.Sprintf("%x", []int{3, 2, 1}))
63+
}
64+
65+
func TestSlice(t *testing.T) {
66+
tup := NewTupleFromItems(100, 200, 300, 400)
67+
assertEqTuple(t, tup.Slice(0, 0), NewTuple(0))
68+
assertEqTuple(t, tup.Slice(0, 1), NewTupleFromItems(100))
69+
assertEqTuple(t, tup.Slice(0, 3), NewTupleFromItems(100, 200, 300))
70+
assertEqTuple(t, tup.Slice(0, 10), NewTupleFromItems(100, 200, 300, 400))
71+
assertEqTuple(t, tup.Slice(1, 2), NewTupleFromItems(200))
72+
assertEqTuple(t, tup.Slice(2, 4), NewTupleFromItems(300, 400))
73+
assertEqTuple(t, tup.Slice(4, 4), NewTuple(0))
74+
assertEqTuple(t, tup.Slice(10, 100), NewTuple(0))
75+
assertEqTuple(t, tup.Slice(-1, 100), NewTupleFromItems(400))
76+
assertEqTuple(t, tup.Slice(-3, -1), NewTupleFromItems(200, 300))
77+
}
78+
79+
func TestLeft(t *testing.T) {
80+
tup := NewTupleFromItems(100, 200, 300, 400)
81+
assertEqTuple(t, tup.Left(0), NewTuple(0))
82+
assertEqTuple(t, tup.Left(1), NewTupleFromItems(100))
83+
assertEqTuple(t, tup.Left(3), NewTupleFromItems(100, 200, 300))
84+
assertEqTuple(t, tup.Left(10), NewTupleFromItems(100, 200, 300, 400))
85+
}
86+
87+
func TestRight(t *testing.T) {
88+
tup := NewTupleFromItems(100, 200, 300, 400)
89+
assertEqTuple(t, tup.Right(0), NewTuple(0))
90+
assertEqTuple(t, tup.Right(1), NewTupleFromItems(400))
91+
assertEqTuple(t, tup.Right(3), NewTupleFromItems(200, 300, 400))
92+
assertEqTuple(t, tup.Right(10), NewTupleFromItems(100, 200, 300, 400))
5193
}
5294

5395
func TestOffset(t *testing.T) {
@@ -87,15 +129,15 @@ func TestPopLeft(t *testing.T) {
87129
x := tup.PopLeft()
88130
assertEq(t, x, 2)
89131
assertEq(t, tup.Len(), 3)
90-
assertEq(t, tup.Eq(NewTupleFromItems(4, 6, 8)), true)
132+
assertEqTuple(t, tup, NewTupleFromItems(4, 6, 8))
91133
}
92134

93135
func TestPopRight(t *testing.T) {
94136
tup := NewTupleFromItems(1, 3, 5, 7)
95137
x := tup.PopRight()
96138
assertEq(t, x, 7)
97139
assertEq(t, tup.Len(), 3)
98-
assertEq(t, tup.Eq(NewTupleFromItems(1, 3, 5)), true)
140+
assertEqTuple(t, tup, NewTupleFromItems(1, 3, 5))
99141
}
100142

101143
func TestEq(t *testing.T) {
@@ -104,22 +146,22 @@ func TestEq(t *testing.T) {
104146
tup2.Set(0, 3)
105147
tup2.Set(1, 6)
106148
tup2.Set(2, 9)
107-
assertEq(t, tup1.Eq(tup2), true)
149+
assertEqTuple(t, tup1, tup2)
108150
assertEq(t, tup1.Ne(tup2), false)
109151

110152
tup5 := NewTupleFromItems(int16(100), int32(200), int64(300))
111153
tup6 := NewTupleFromItems(int8(100), int16(200), int32(300))
112-
assertEq(t, tup5.Eq(tup6), true)
154+
assertEqTuple(t, tup5, tup6)
113155

114156
tup7 := NewTupleFromItems(nil, nil, nil)
115157
tup8 := NewTuple(3)
116-
assertEq(t, tup7.Eq(tup8), true)
158+
assertEqTuple(t, tup7, tup8)
117159

118160
tup9 := NewTupleFromItems(NewTupleFromItems(1, 2), NewTupleFromItems(5, 10), NewTupleFromItems(10, 20))
119161
tup10 := NewTupleFromItems(NewTupleFromItems(1, 2), NewTupleFromItems(5, 10), NewTupleFromItems(10, 20))
120-
assertEq(t, tup9.Eq(tup10), true)
162+
assertEqTuple(t, tup9, tup10)
121163
tup11 := NewTupleFromItems(NewTupleFromItems(1, 2), NewTupleFromItems(3, 10), NewTupleFromItems(10, 20))
122-
assertEq(t, tup10.Eq(tup11), false)
164+
assertNeTuple(t, tup10, tup11)
123165

124166
}
125167

@@ -187,7 +229,7 @@ func TestReverse(t *testing.T) {
187229
tup1 := NewTupleFromItems(1, 3, 5, 7, 9, 11, 13)
188230
tup1.Reverse()
189231
tup2 := NewTupleFromItems(13, 11, 9, 7, 5, 3, 1)
190-
assertEq(t, tup1.Eq(tup2), true)
232+
assertEqTuple(t, tup1, tup2)
191233
}
192234

193235
func TestIndex(t *testing.T) {
@@ -212,7 +254,7 @@ func TestCount(t *testing.T) {
212254
func TestSortInternal(t *testing.T) {
213255
tup1 := NewTupleFromItems(1, 9, 7, 2, 3, 10, 5, 4, 8, 6)
214256
sort.Sort(tup1)
215-
assertEq(t, tup1.Eq(NewTupleFromItems(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)), true)
257+
assertEqTuple(t, tup1, NewTupleFromItems(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
216258
}
217259

218260
func TestSortTuples(t *testing.T) {
@@ -224,42 +266,31 @@ func TestSortTuples(t *testing.T) {
224266
tups[1] = tup1
225267
tups[2] = tup2
226268
sort.Sort(ByElem(tups))
227-
assertEq(t, tups[0].Eq(tup1), true)
228-
assertEq(t, tups[1].Eq(tup2), true)
229-
assertEq(t, tups[2].Eq(tup0), true)
269+
assertEqTuple(t, tups[0], tup1)
270+
assertEqTuple(t, tups[1], tup2)
271+
assertEqTuple(t, tups[2], tup0)
230272
}
231273

232274
func TestAppend(t *testing.T) {
233275
tup0 := NewTupleFromItems(1, 2, 3)
234276
tup1 := NewTupleFromItems("a", "b", "c")
235277
tup0.Append(tup1)
236-
assertEq(t, tup0.Eq(NewTupleFromItems(1, 2, 3, "a", "b", "c")), true)
278+
assertEqTuple(t, tup0, NewTupleFromItems(1, 2, 3, "a", "b", "c"))
237279
tup1.AppendItems("d", "e", "f")
238-
assertEq(t, tup1.Eq(NewTupleFromItems("a", "b", "c", "d", "e", "f")), true)
280+
assertEqTuple(t, tup1, NewTupleFromItems("a", "b", "c", "d", "e", "f"))
239281
// TODO: try with reference elements, show they are not deep copied during the append
240282
}
241283

242284
func TestInsert(t *testing.T) {
243285
tup0 := NewTupleFromItems(1, 2, 3)
244286
tup1 := NewTupleFromItems("a", "b", "c")
245287
tup0.Insert(0, tup1)
246-
assertEq(t, tup0.Eq(NewTupleFromItems("a", "b", "c", 1, 2, 3)), true)
288+
assertEqTuple(t, tup0, NewTupleFromItems("a", "b", "c", 1, 2, 3))
247289

248290
tup2 := NewTupleFromItems(10, 20)
249291
tup1.Insert(1, tup2)
250-
assertEq(t, tup1.Eq(NewTupleFromItems("a", 10, 20, "b", "c")), true)
292+
assertEqTuple(t, tup1, NewTupleFromItems("a", 10, 20, "b", "c"))
251293

252294
tup1.Insert(-1, NewTupleFromItems("x", "y", "z"))
253-
assertEq(t, tup1.Eq(NewTupleFromItems("a", 10, 20, "b", "x", "y", "z", "c")), true)
254-
255-
}
256-
257-
/*
258-
func TestWTF(t *testing.T) {
259-
if nil == nil {
260-
fmt.Println("nil equals nil")
261-
} else {
262-
fmt.Println("nil does not equal nil")
263-
}
295+
assertEqTuple(t, tup1, NewTupleFromItems("a", 10, 20, "b", "x", "y", "z", "c"))
264296
}
265-
*/

0 commit comments

Comments
 (0)