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
|
discard """
output: '''
100
0
float32
float32
'''
"""
import tables
block tgeneric0:
type
TX = Table[string, int]
proc foo(models: seq[Table[string, float]]): seq[float] =
result = @[]
for model in models.items:
result.add model["foobar"]
# bug #686
type TType[T; A] = array[A, T]
proc foo[T](p: TType[T, range[0..1]]) =
echo "foo"
proc foo[T](p: TType[T, range[0..2]]) =
echo "bar"
#bug #1366
proc reversed(x: auto) =
for i in countdown(x.low, x.high):
echo i
reversed(@[-19, 7, -4, 6])
block tgeneric1:
type
TNode[T] = tuple[priority: int, data: T]
TBinHeap[T] = object
heap: seq[TNode[T]]
last: int
PBinHeap[T] = ref TBinHeap[T]
proc newBinHeap[T](heap: var PBinHeap[T], size: int) =
new(heap)
heap.last = 0
newSeq(heap.heap, size)
#newSeq(heap.seq, size)
proc parent(elem: int): int {.inline.} =
return (elem-1) div 2
proc siftUp[T](heap: PBinHeap[T], elem: int) =
var idx = elem
while idx != 0:
var p = parent(idx)
if heap.heap[idx].priority < heap.heap[p].priority:
swap(heap.heap[idx], heap.heap[p])
idx = p
else:
break
proc add[T](heap: PBinHeap[T], priority: int, data: T) =
var node: TNode[T]
node.priority = priority
node.data = data
heap.heap[heap.last] = node
siftUp(heap, heap.last)
inc(heap.last)
proc print[T](heap: PBinHeap[T]) =
for i in countup(0, heap.last):
stdout.write($heap.heap[i].data, "\n")
var heap: PBinHeap[int]
newBinHeap(heap, 256)
add(heap, 1, 100)
print(heap)
block tgeneric2:
type
TX = Table[string, int]
proc foo(models: seq[TX]): seq[int] =
result = @[]
for model in models.items:
result.add model["foobar"]
type
Obj = object
field: Table[string, string]
var t: Obj
discard initTable[type(t.field), string]()
block tgeneric4:
type
TIDGen[A: Ordinal] = object
next: A
free: seq[A]
proc newIDGen[A]: TIDGen[A] =
newSeq result.free, 0
var x = newIDGen[int]()
block tgeneric5:
# bug #12528
proc foo[T](a: T; b: T) =
echo T
foo(0.0'f32, 0.0)
proc bar[T](a: T; b: T = 0.0) =
echo T
bar(0.0'f32)
|