jyapayne/Nim
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge pull request #2326 from oderwat/fix-totable

Browse source 
Making tuples anonymous (so far... not finished).
This commit is contained in:
Andreas Rumpf 2015-03-17 10:29:32 +01:00
commit 8e651fa0d4
2 changed files with 29 additions and 25 deletions
Download patch file Download diff file Expand all files Collapse all files

45
lib/pure/collections/tables.nim
View file

@ -95,12 +95,12 @@ proc len*[A, B](t: Table[A, B]): int =
## returns the number of keys in `t`. ## returns the number of keys in `t`.
result = t.counter result = t.counter
iterator pairs*[A, B](t: Table[A, B]): tuple[key: A, val: B] = iterator pairs*[A, B](t: Table[A, B]): (A, B) =
## iterates over any (key, value) pair in the table `t`. ## iterates over any (key, value) pair in the table `t`.
for h in 0..high(t.data): for h in 0..high(t.data):
if isFilled(t.data[h].hcode): yield (t.data[h].key, t.data[h].val) if isFilled(t.data[h].hcode): yield (t.data[h].key, t.data[h].val)
iterator mpairs*[A, B](t: var Table[A, B]): tuple[key: A, val: var B] = iterator mpairs*[A, B](t: var Table[A, B]): (A, var B) =
## iterates over any (key, value) pair in the table `t`. The values ## iterates over any (key, value) pair in the table `t`. The values
## can be modified. ## can be modified.
for h in 0..high(t.data): for h in 0..high(t.data):
@ -314,8 +314,8 @@ proc initTable*[A, B](initialSize=64): Table[A, B] =
result.counter = 0 result.counter = 0
newSeq(result.data, initialSize) newSeq(result.data, initialSize)
proc toTable*[A, B](pairs: openArray[tuple[key: A, proc toTable*[A, B](pairs: openArray[(A,
val: B]]): Table[A, B] = B)]): Table[A, B] =
## creates a new hash table that contains the given `pairs`. ## creates a new hash table that contains the given `pairs`.
result = initTable[A, B](rightSize(pairs.len)) result = initTable[A, B](rightSize(pairs.len))
for key, val in items(pairs): result[key] = val for key, val in items(pairs): result[key] = val
@ -360,12 +360,12 @@ proc len*[A, B](t: TableRef[A, B]): int =
## returns the number of keys in `t`. ## returns the number of keys in `t`.
result = t.counter result = t.counter
iterator pairs*[A, B](t: TableRef[A, B]): tuple[key: A, val: B] = iterator pairs*[A, B](t: TableRef[A, B]): (A, B) =
## iterates over any (key, value) pair in the table `t`. ## iterates over any (key, value) pair in the table `t`.
for h in 0..high(t.data): for h in 0..high(t.data):
if isFilled(t.data[h].hcode): yield (t.data[h].key, t.data[h].val) if isFilled(t.data[h].hcode): yield (t.data[h].key, t.data[h].val)
iterator mpairs*[A, B](t: TableRef[A, B]): tuple[key: A, val: var B] = iterator mpairs*[A, B](t: TableRef[A, B]): (A, var B) =
## iterates over any (key, value) pair in the table `t`. The values ## iterates over any (key, value) pair in the table `t`. The values
## can be modified. ## can be modified.
for h in 0..high(t.data): for h in 0..high(t.data):
@ -427,7 +427,7 @@ proc newTable*[A, B](initialSize=64): TableRef[A, B] =
new(result) new(result)
result[] = initTable[A, B](initialSize) result[] = initTable[A, B](initialSize)
proc newTable*[A, B](pairs: openArray[tuple[key: A, val: B]]): TableRef[A, B] = proc newTable*[A, B](pairs: openArray[(A, B)]): TableRef[A, B] =
## creates a new hash table that contains the given `pairs`. ## creates a new hash table that contains the given `pairs`.
new(result) new(result)
result[] = toTable[A, B](pairs) result[] = toTable[A, B](pairs)
@ -473,13 +473,13 @@ template forAllOrderedPairs(yieldStmt: stmt) {.dirty, immediate.} =
if isFilled(t.data[h].hcode): yieldStmt if isFilled(t.data[h].hcode): yieldStmt
h = nxt h = nxt
iterator pairs*[A, B](t: OrderedTable[A, B]): tuple[key: A, val: B] = iterator pairs*[A, B](t: OrderedTable[A, B]): (A, B) =
## iterates over any (key, value) pair in the table `t` in insertion ## iterates over any (key, value) pair in the table `t` in insertion
## order. ## order.
forAllOrderedPairs: forAllOrderedPairs:
yield (t.data[h].key, t.data[h].val) yield (t.data[h].key, t.data[h].val)
iterator mpairs*[A, B](t: var OrderedTable[A, B]): tuple[key: A, val: var B] = iterator mpairs*[A, B](t: var OrderedTable[A, B]): (A, var B) =
## iterates over any (key, value) pair in the table `t` in insertion ## iterates over any (key, value) pair in the table `t` in insertion
## order. The values can be modified. ## order. The values can be modified.
forAllOrderedPairs: forAllOrderedPairs:
@ -584,8 +584,8 @@ proc initOrderedTable*[A, B](initialSize=64): OrderedTable[A, B] =
result.last = -1 result.last = -1
newSeq(result.data, initialSize) newSeq(result.data, initialSize)
proc toOrderedTable*[A, B](pairs: openArray[tuple[key: A, proc toOrderedTable*[A, B](pairs: openArray[(A,
val: B]]): OrderedTable[A, B] = B)]): OrderedTable[A, B] =
## creates a new ordered hash table that contains the given `pairs`. ## creates a new ordered hash table that contains the given `pairs`.
result = initOrderedTable[A, B](rightSize(pairs.len)) result = initOrderedTable[A, B](rightSize(pairs.len))
for key, val in items(pairs): result[key] = val for key, val in items(pairs): result[key] = val
@ -595,7 +595,7 @@ proc `$`*[A, B](t: OrderedTable[A, B]): string =
dollarImpl() dollarImpl()
proc sort*[A, B](t: var OrderedTable[A, B], proc sort*[A, B](t: var OrderedTable[A, B],
cmp: proc (x,y: tuple[key: A, val: B]): int) = cmp: proc (x,y: (A, B)): int) =
## sorts `t` according to `cmp`. This modifies the internal list ## sorts `t` according to `cmp`. This modifies the internal list
## that kept the insertion order, so insertion order is lost after this ## that kept the insertion order, so insertion order is lost after this
## call but key lookup and insertions remain possible after `sort` (in ## call but key lookup and insertions remain possible after `sort` (in
@ -651,13 +651,13 @@ template forAllOrderedPairs(yieldStmt: stmt) {.dirty, immediate.} =
if isFilled(t.data[h].hcode): yieldStmt if isFilled(t.data[h].hcode): yieldStmt
h = nxt h = nxt
iterator pairs*[A, B](t: OrderedTableRef[A, B]): tuple[key: A, val: B] = iterator pairs*[A, B](t: OrderedTableRef[A, B]): (A, B) =
## iterates over any (key, value) pair in the table `t` in insertion ## iterates over any (key, value) pair in the table `t` in insertion
## order. ## order.
forAllOrderedPairs: forAllOrderedPairs:
yield (t.data[h].key, t.data[h].val) yield (t.data[h].key, t.data[h].val)
iterator mpairs*[A, B](t: OrderedTableRef[A, B]): tuple[key: A, val: var B] = iterator mpairs*[A, B](t: OrderedTableRef[A, B]): (A, var B) =
## iterates over any (key, value) pair in the table `t` in insertion ## iterates over any (key, value) pair in the table `t` in insertion
## order. The values can be modified. ## order. The values can be modified.
forAllOrderedPairs: forAllOrderedPairs:
@ -721,8 +721,7 @@ proc newOrderedTable*[A, B](initialSize=64): OrderedTableRef[A, B] =
new(result) new(result)
result[] = initOrderedTable[A, B]() result[] = initOrderedTable[A, B]()
proc newOrderedTable*[A, B](pairs: openArray[tuple[key: A, proc newOrderedTable*[A, B](pairs: openArray[(A, B)]): OrderedTableRef[A, B] =
val: B]]): OrderedTableRef[A, B] =
## creates a new ordered hash table that contains the given `pairs`. ## creates a new ordered hash table that contains the given `pairs`.
result = newOrderedTable[A, B](rightSize(pairs.len)) result = newOrderedTable[A, B](rightSize(pairs.len))
for key, val in items(pairs): result[key] = val for key, val in items(pairs): result[key] = val
@ -732,7 +731,7 @@ proc `$`*[A, B](t: OrderedTableRef[A, B]): string =
dollarImpl() dollarImpl()
proc sort*[A, B](t: OrderedTableRef[A, B], proc sort*[A, B](t: OrderedTableRef[A, B],
cmp: proc (x,y: tuple[key: A, val: B]): int) = cmp: proc (x,y: (A, B)): int) =
## sorts `t` according to `cmp`. This modifies the internal list ## sorts `t` according to `cmp`. This modifies the internal list
## that kept the insertion order, so insertion order is lost after this ## that kept the insertion order, so insertion order is lost after this
## call but key lookup and insertions remain possible after `sort` (in ## call but key lookup and insertions remain possible after `sort` (in
@ -754,12 +753,12 @@ proc len*[A](t: CountTable[A]): int =
## returns the number of keys in `t`. ## returns the number of keys in `t`.
result = t.counter result = t.counter
iterator pairs*[A](t: CountTable[A]): tuple[key: A, val: int] = iterator pairs*[A](t: CountTable[A]): (A, int) =
## iterates over any (key, value) pair in the table `t`. ## iterates over any (key, value) pair in the table `t`.
for h in 0..high(t.data): for h in 0..high(t.data):
if t.data[h].val != 0: yield (t.data[h].key, t.data[h].val) if t.data[h].val != 0: yield (t.data[h].key, t.data[h].val)
iterator mpairs*[A](t: var CountTable[A]): tuple[key: A, val: var int] = iterator mpairs*[A](t: var CountTable[A]): (A, var int) =
## iterates over any (key, value) pair in the table `t`. The values can ## iterates over any (key, value) pair in the table `t`. The values can
## be modified. ## be modified.
for h in 0..high(t.data): for h in 0..high(t.data):
@ -902,12 +901,12 @@ proc len*[A](t: CountTableRef[A]): int =
## returns the number of keys in `t`. ## returns the number of keys in `t`.
result = t.counter result = t.counter
iterator pairs*[A](t: CountTableRef[A]): tuple[key: A, val: int] = iterator pairs*[A](t: CountTableRef[A]): (A, int) =
## iterates over any (key, value) pair in the table `t`. ## iterates over any (key, value) pair in the table `t`.
for h in 0..high(t.data): for h in 0..high(t.data):
if t.data[h].val != 0: yield (t.data[h].key, t.data[h].val) if t.data[h].val != 0: yield (t.data[h].key, t.data[h].val)
iterator mpairs*[A](t: CountTableRef[A]): tuple[key: A, val: var int] = iterator mpairs*[A](t: CountTableRef[A]): (A, var int) =
## iterates over any (key, value) pair in the table `t`. The values can ## iterates over any (key, value) pair in the table `t`. The values can
## be modified. ## be modified.
for h in 0..high(t.data): for h in 0..high(t.data):
@ -970,11 +969,11 @@ proc inc*[A](t: CountTableRef[A], key: A, val = 1) =
## increments `t[key]` by `val`. ## increments `t[key]` by `val`.
t[].inc(key, val) t[].inc(key, val)
proc smallest*[A](t: CountTableRef[A]): tuple[key: A, val: int] = proc smallest*[A](t: CountTableRef[A]): (A, int) =
## returns the largest (key,val)-pair. Efficiency: O(n) ## returns the largest (key,val)-pair. Efficiency: O(n)
t[].smallest t[].smallest
proc largest*[A](t: CountTableRef[A]): tuple[key: A, val: int] = proc largest*[A](t: CountTableRef[A]): (A, int) =
## returns the (key,val)-pair with the largest `val`. Efficiency: O(n) ## returns the (key,val)-pair with the largest `val`. Efficiency: O(n)
t[].largest t[].largest

9
tests/collections/ttablesref.nim
View file

@ -2,7 +2,7 @@ discard """
output: '''true''' output: '''true'''
""" """
import hashes, tables import hashes, tables, sequtils
const const
data = { data = {
@ -103,9 +103,10 @@ block countTableTest1:
block SyntaxTest: block SyntaxTest:
var x = newTable[int, string]({:}) var x = newTable[int, string]({:})
discard x
block nilTest: block nilTest:
var i, j: PTable[int, int] = nil var i, j: TableRef[int, int] = nil
assert i == j assert i == j
j = newTable[int, int]() j = newTable[int, int]()
assert i != j assert i != j
@ -131,6 +132,10 @@ proc orderedTableSortTest() =
# check that insert still works: # check that insert still works:
t["newKeyHere"] = 80 t["newKeyHere"] = 80
block anonZipTest:
let keys = @['a','b','c']
let values = @[1, 2, 3]
doAssert "{a: 1, b: 2, c: 3}" == $ toTable zip(keys, values)
orderedTableSortTest() orderedTableSortTest()
echo "true" echo "true"