Home Explore Help
Sign In
levovix
/
Nim
mirror of https://github.com/nim-lang/Nim
Watch 1
Star 0
Fork 1
Files Issues 0 Wiki
Tree: d69e064e0c
Branches Tags
Nim
/
tables.idx

tables.idx 19 KB
History Raw

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199 
  1. nimTitle	tables	tables.html	module std/tables		0
    2. 

  2. nim	Table	tables.html#Table	object Table		206
    3. 

  3. nim	TableRef	tables.html#TableRef	type TableRef		215
    4. 

  4. nim	defaultInitialSize	tables.html#defaultInitialSize	const defaultInitialSize		15
    5. 

  5. nim	initTable	tables.html#initTable	proc initTable[A, B](initialSize = defaultInitialSize): Table[A, B]		268
    6. 

  6. nim	`[]=`	tables.html#[]=,Table[A,B],A,sinkB	proc `[]=`[A, B](t: var Table[A, B]; key: A; val: sink B)		284
    7. 

  7. nim	toTable	tables.html#toTable,openArray[]	proc toTable[A, B](pairs: openArray[(A, B)]): Table[A, B]		300
    8. 

  8. nim	`[]`	tables.html#[],Table[A,B],A	proc `[]`[A, B](t: Table[A, B]; key: A): lent B		316
    9. 

  9. nim	`[]`	tables.html#[],Table[A,B],A_2	proc `[]`[A, B](t: var Table[A, B]; key: A): var B		339
    10. 

  10. nim	hasKey	tables.html#hasKey,Table[A,B],A	proc hasKey[A, B](t: Table[A, B]; key: A): bool		355
    11. 

  11. nim	contains	tables.html#contains,Table[A,B],A	proc contains[A, B](t: Table[A, B]; key: A): bool		373
    12. 

  12. nim	hasKeyOrPut	tables.html#hasKeyOrPut,Table[A,B],A,B	proc hasKeyOrPut[A, B](t: var Table[A, B]; key: A; val: B): bool		383
    13. 

  13. nim	getOrDefault	tables.html#getOrDefault,Table[A,B],A	proc getOrDefault[A, B](t: Table[A, B]; key: A): B		403
    14. 

  14. nim	getOrDefault	tables.html#getOrDefault,Table[A,B],A,B	proc getOrDefault[A, B](t: Table[A, B]; key: A; def: B): B		422
    15. 

  15. nim	mgetOrPut	tables.html#mgetOrPut,Table[A,B],A,B	proc mgetOrPut[A, B](t: var Table[A, B]; key: A; val: B): var B		439
    16. 

  16. nim	mgetOrPut	tables.html#mgetOrPut,Table[A,B],A	proc mgetOrPut[A, B](t: var Table[A, B]; key: A): var B		477
    17. 

  17. nim	len	tables.html#len,Table[A,B]	proc len[A, B](t: Table[A, B]): int		489
    18. 

  18. nim	add	tables.html#add,Table[A,B],A,sinkB	proc add[A, B](t: var Table[A, B]; key: A; val: sink B)		497
    19. 

  19. nim	del	tables.html#del,Table[A,B],A	proc del[A, B](t: var Table[A, B]; key: A)		511
    20. 

  20. nim	pop	tables.html#pop,Table[A,B],A,B	proc pop[A, B](t: var Table[A, B]; key: A; val: var B): bool		529
    21. 

  21. nim	take	tables.html#take,Table[A,B],A,B	proc take[A, B](t: var Table[A, B]; key: A; val: var B): bool		560
    22. 

  22. nim	clear	tables.html#clear,Table[A,B]	proc clear[A, B](t: var Table[A, B])		565
    23. 

  23. nim	`$`	tables.html#$,Table[A,B]	proc `$`[A, B](t: Table[A, B]): string		579
    24. 

  24. nim	`==`	tables.html#==,Table[A,B],Table[A,B]	proc `==`[A, B](s, t: Table[A, B]): bool		584
    25. 

  25. nim	indexBy	tables.html#indexBy,A,proc(B)	proc indexBy[A, B, C](collection: A; index: proc (x: B): C): Table[C, B]		595
    26. 

  26. nim	withValue	tables.html#withValue.t,Table[A,B],A,untyped,untyped	template withValue[A, B](t: var Table[A, B]; key: A; value, body: untyped)		604
    27. 

  27. nim	withValue	tables.html#withValue.t,Table[A,B],A,untyped,untyped,untyped	template withValue[A, B](t: var Table[A, B]; key: A; value, body1, body2: untyped)		638
    28. 

  28. nim	pairs	tables.html#pairs.i,Table[A,B]	iterator pairs[A, B](t: Table[A, B]): (A, B)		680
    29. 

  29. nim	mpairs	tables.html#mpairs.i,Table[A,B]	iterator mpairs[A, B](t: var Table[A, B]): (A, var B)		711
    30. 

  30. nim	keys	tables.html#keys.i,Table[A,B]	iterator keys[A, B](t: Table[A, B]): lent A		733
    31. 

  31. nim	values	tables.html#values.i,Table[A,B]	iterator values[A, B](t: Table[A, B]): lent B		754
    32. 

  32. nim	mvalues	tables.html#mvalues.i,Table[A,B]	iterator mvalues[A, B](t: var Table[A, B]): var B		775
    33. 

  33. nim	allValues	tables.html#allValues.i,Table[A,B],A	iterator allValues[A, B](t: Table[A, B]; key: A): B		797
    34. 

  34. nim	newTable	tables.html#newTable	proc newTable[A, B](initialSize = defaultInitialSize): TableRef[A, B]		826
    35. 

  35. nim	newTable	tables.html#newTable,openArray[]	proc newTable[A, B](pairs: openArray[(A, B)]): TableRef[A, B]		842
    36. 

  36. nim	newTableFrom	tables.html#newTableFrom,A,proc(B)	proc newTableFrom[A, B, C](collection: A; index: proc (x: B): C): TableRef[C, B]		859
    37. 

  37. nim	`[]`	tables.html#[],TableRef[A,B],A	proc `[]`[A, B](t: TableRef[A, B]; key: A): var B		867
    38. 

  38. nim	`[]=`	tables.html#[]=,TableRef[A,B],A,sinkB	proc `[]=`[A, B](t: TableRef[A, B]; key: A; val: sink B)		891
    39. 

  39. nim	hasKey	tables.html#hasKey,TableRef[A,B],A	proc hasKey[A, B](t: TableRef[A, B]; key: A): bool		907
    40. 

  40. nim	contains	tables.html#contains,TableRef[A,B],A	proc contains[A, B](t: TableRef[A, B]; key: A): bool		925
    41. 

  41. nim	hasKeyOrPut	tables.html#hasKeyOrPut,TableRef[A,B],A,B	proc hasKeyOrPut[A, B](t: TableRef[A, B]; key: A; val: B): bool		935
    42. 

  42. nim	getOrDefault	tables.html#getOrDefault,TableRef[A,B],A	proc getOrDefault[A, B](t: TableRef[A, B]; key: A): B		955
    43. 

  43. nim	getOrDefault	tables.html#getOrDefault,TableRef[A,B],A,B	proc getOrDefault[A, B](t: TableRef[A, B]; key: A; def: B): B		974
    44. 

  44. nim	mgetOrPut	tables.html#mgetOrPut,TableRef[A,B],A,B	proc mgetOrPut[A, B](t: TableRef[A, B]; key: A; val: B): var B		992
    45. 

  45. nim	mgetOrPut	tables.html#mgetOrPut,TableRef[A,B],A	proc mgetOrPut[A, B](t: TableRef[A, B]; key: A): var B		1028
    46. 

  46. nim	len	tables.html#len,TableRef[A,B]	proc len[A, B](t: TableRef[A, B]): int		1040
    47. 

  47. nim	add	tables.html#add,TableRef[A,B],A,sinkB	proc add[A, B](t: TableRef[A, B]; key: A; val: sink B)		1048
    48. 

  48. nim	del	tables.html#del,TableRef[A,B],A	proc del[A, B](t: TableRef[A, B]; key: A)		1058
    49. 

  49. nim	pop	tables.html#pop,TableRef[A,B],A,B	proc pop[A, B](t: TableRef[A, B]; key: A; val: var B): bool		1076
    50. 

  50. nim	take	tables.html#take,TableRef[A,B],A,B	proc take[A, B](t: TableRef[A, B]; key: A; val: var B): bool		1102
    51. 

  51. nim	clear	tables.html#clear,TableRef[A,B]	proc clear[A, B](t: TableRef[A, B])		1107
    52. 

  52. nim	`$`	tables.html#$,TableRef[A,B]	proc `$`[A, B](t: TableRef[A, B]): string		1121
    53. 

  53. nim	`==`	tables.html#==,TableRef[A,B],TableRef[A,B]	proc `==`[A, B](s, t: TableRef[A, B]): bool		1126
    54. 

  54. nim	pairs	tables.html#pairs.i,TableRef[A,B]	iterator pairs[A, B](t: TableRef[A, B]): (A, B)		1142
    55. 

  55. nim	mpairs	tables.html#mpairs.i,TableRef[A,B]	iterator mpairs[A, B](t: TableRef[A, B]): (A, var B)		1173
    56. 

  56. nim	keys	tables.html#keys.i,TableRef[A,B]	iterator keys[A, B](t: TableRef[A, B]): lent A		1195
    57. 

  57. nim	values	tables.html#values.i,TableRef[A,B]	iterator values[A, B](t: TableRef[A, B]): lent B		1216
    58. 

  58. nim	mvalues	tables.html#mvalues.i,TableRef[A,B]	iterator mvalues[A, B](t: TableRef[A, B]): var B		1237
    59. 

  59. nim	OrderedTable	tables.html#OrderedTable	object OrderedTable		1273
    60. 

  60. nim	OrderedTableRef	tables.html#OrderedTableRef	type OrderedTableRef		1280
    61. 

  61. nim	initOrderedTable	tables.html#initOrderedTable	proc initOrderedTable[A, B](initialSize = defaultInitialSize): OrderedTable[A, B]		1335
    62. 

  62. nim	`[]=`	tables.html#[]=,OrderedTable[A,B],A,sinkB	proc `[]=`[A, B](t: var OrderedTable[A, B]; key: A; val: sink B)		1352
    63. 

  63. nim	toOrderedTable	tables.html#toOrderedTable,openArray[]	proc toOrderedTable[A, B](pairs: openArray[(A, B)]): OrderedTable[A, B]		1368
    64. 

  64. nim	`[]`	tables.html#[],OrderedTable[A,B],A	proc `[]`[A, B](t: OrderedTable[A, B]; key: A): lent B		1385
    65. 

  65. nim	`[]`	tables.html#[],OrderedTable[A,B],A_2	proc `[]`[A, B](t: var OrderedTable[A, B]; key: A): var B		1409
    66. 

  66. nim	hasKey	tables.html#hasKey,OrderedTable[A,B],A	proc hasKey[A, B](t: OrderedTable[A, B]; key: A): bool		1425
    67. 

  67. nim	contains	tables.html#contains,OrderedTable[A,B],A	proc contains[A, B](t: OrderedTable[A, B]; key: A): bool		1444
    68. 

  68. nim	hasKeyOrPut	tables.html#hasKeyOrPut,OrderedTable[A,B],A,B	proc hasKeyOrPut[A, B](t: var OrderedTable[A, B]; key: A; val: B): bool		1454
    69. 

  69. nim	getOrDefault	tables.html#getOrDefault,OrderedTable[A,B],A	proc getOrDefault[A, B](t: OrderedTable[A, B]; key: A): B		1474
    70. 

  70. nim	getOrDefault	tables.html#getOrDefault,OrderedTable[A,B],A,B	proc getOrDefault[A, B](t: OrderedTable[A, B]; key: A; def: B): B		1493
    71. 

  71. nim	mgetOrPut	tables.html#mgetOrPut,OrderedTable[A,B],A,B	proc mgetOrPut[A, B](t: var OrderedTable[A, B]; key: A; val: B): var B		1510
    72. 

  72. nim	mgetOrPut	tables.html#mgetOrPut,OrderedTable[A,B],A	proc mgetOrPut[A, B](t: var OrderedTable[A, B]; key: A): var B		1530
    73. 

  73. nim	len	tables.html#len,OrderedTable[A,B]	proc len[A, B](t: OrderedTable[A, B]): int		1542
    74. 

  74. nim	add	tables.html#add,OrderedTable[A,B],A,sinkB	proc add[A, B](t: var OrderedTable[A, B]; key: A; val: sink B)		1550
    75. 

  75. nim	del	tables.html#del,OrderedTable[A,B],A	proc del[A, B](t: var OrderedTable[A, B]; key: A)		1560
    76. 

  76. nim	pop	tables.html#pop,OrderedTable[A,B],A,B	proc pop[A, B](t: var OrderedTable[A, B]; key: A; val: var B): bool		1593
    77. 

  77. nim	clear	tables.html#clear,OrderedTable[A,B]	proc clear[A, B](t: var OrderedTable[A, B])		1623
    78. 

  78. nim	sort	tables.html#sort,OrderedTable[A,B],proc(,)	proc sort[A, B](t: var OrderedTable[A, B]; cmp: proc (x, y: (A, B)): int;\n           order = SortOrder.Ascending)		1639
    79. 

  79. nim	`$`	tables.html#$,OrderedTable[A,B]	proc `$`[A, B](t: OrderedTable[A, B]): string		1698
    80. 

  80. nim	`==`	tables.html#==,OrderedTable[A,B],OrderedTable[A,B]	proc `==`[A, B](s, t: OrderedTable[A, B]): bool		1703
    81. 

  81. nim	pairs	tables.html#pairs.i,OrderedTable[A,B]	iterator pairs[A, B](t: OrderedTable[A, B]): (A, B)		1730
    82. 

  82. nim	mpairs	tables.html#mpairs.i,OrderedTable[A,B]	iterator mpairs[A, B](t: var OrderedTable[A, B]): (A, var B)		1762
    83. 

  83. nim	keys	tables.html#keys.i,OrderedTable[A,B]	iterator keys[A, B](t: OrderedTable[A, B]): lent A		1784
    84. 

  84. nim	values	tables.html#values.i,OrderedTable[A,B]	iterator values[A, B](t: OrderedTable[A, B]): lent B		1805
    85. 

  85. nim	mvalues	tables.html#mvalues.i,OrderedTable[A,B]	iterator mvalues[A, B](t: var OrderedTable[A, B]): var B		1825
    86. 

  86. nim	newOrderedTable	tables.html#newOrderedTable	proc newOrderedTable[A, B](initialSize = defaultInitialSize): OrderedTableRef[A, B]		1852
    87. 

  87. nim	newOrderedTable	tables.html#newOrderedTable,openArray[]	proc newOrderedTable[A, B](pairs: openArray[(A, B)]): OrderedTableRef[A, B]		1868
    88. 

  88. nim	`[]`	tables.html#[],OrderedTableRef[A,B],A	proc `[]`[A, B](t: OrderedTableRef[A, B]; key: A): var B		1887
    89. 

  89. nim	`[]=`	tables.html#[]=,OrderedTableRef[A,B],A,sinkB	proc `[]=`[A, B](t: OrderedTableRef[A, B]; key: A; val: sink B)		1910
    90. 

  90. nim	hasKey	tables.html#hasKey,OrderedTableRef[A,B],A	proc hasKey[A, B](t: OrderedTableRef[A, B]; key: A): bool		1926
    91. 

  91. nim	contains	tables.html#contains,OrderedTableRef[A,B],A	proc contains[A, B](t: OrderedTableRef[A, B]; key: A): bool		1944
    92. 

  92. nim	hasKeyOrPut	tables.html#hasKeyOrPut,OrderedTableRef[A,B],A,B	proc hasKeyOrPut[A, B](t: OrderedTableRef[A, B]; key: A; val: B): bool		1954
    93. 

  93. nim	getOrDefault	tables.html#getOrDefault,OrderedTableRef[A,B],A	proc getOrDefault[A, B](t: OrderedTableRef[A, B]; key: A): B		1974
    94. 

  94. nim	getOrDefault	tables.html#getOrDefault,OrderedTableRef[A,B],A,B	proc getOrDefault[A, B](t: OrderedTableRef[A, B]; key: A; def: B): B		1993
    95. 

  95. nim	mgetOrPut	tables.html#mgetOrPut,OrderedTableRef[A,B],A,B	proc mgetOrPut[A, B](t: OrderedTableRef[A, B]; key: A; val: B): var B		2011
    96. 

  96. nim	mgetOrPut	tables.html#mgetOrPut,OrderedTableRef[A,B],A	proc mgetOrPut[A, B](t: OrderedTableRef[A, B]; key: A): var B		2031
    97. 

  97. nim	len	tables.html#len,OrderedTableRef[A,B]	proc len[A, B](t: OrderedTableRef[A, B]): int		2043
    98. 

  98. nim	add	tables.html#add,OrderedTableRef[A,B],A,sinkB	proc add[A, B](t: OrderedTableRef[A, B]; key: A; val: sink B)		2051
    99. 

  99. nim	del	tables.html#del,OrderedTableRef[A,B],A	proc del[A, B](t: OrderedTableRef[A, B]; key: A)		2061
    100. 

  100. nim	pop	tables.html#pop,OrderedTableRef[A,B],A,B	proc pop[A, B](t: OrderedTableRef[A, B]; key: A; val: var B): bool		2075
    101. 

  101. nim	clear	tables.html#clear,OrderedTableRef[A,B]	proc clear[A, B](t: OrderedTableRef[A, B])		2098
    102. 

  102. nim	sort	tables.html#sort,OrderedTableRef[A,B],proc(,)	proc sort[A, B](t: OrderedTableRef[A, B]; cmp: proc (x, y: (A, B)): int;\n           order = SortOrder.Ascending)		2111
    103. 

  103. nim	`$`	tables.html#$,OrderedTableRef[A,B]	proc `$`[A, B](t: OrderedTableRef[A, B]): string		2132
    104. 

  104. nim	`==`	tables.html#==,OrderedTableRef[A,B],OrderedTableRef[A,B]	proc `==`[A, B](s, t: OrderedTableRef[A, B]): bool		2137
    105. 

  105. nim	pairs	tables.html#pairs.i,OrderedTableRef[A,B]	iterator pairs[A, B](t: OrderedTableRef[A, B]): (A, B)		2153
    106. 

  106. nim	mpairs	tables.html#mpairs.i,OrderedTableRef[A,B]	iterator mpairs[A, B](t: OrderedTableRef[A, B]): (A, var B)		2185
    107. 

  107. nim	keys	tables.html#keys.i,OrderedTableRef[A,B]	iterator keys[A, B](t: OrderedTableRef[A, B]): lent A		2207
    108. 

  108. nim	values	tables.html#values.i,OrderedTableRef[A,B]	iterator values[A, B](t: OrderedTableRef[A, B]): lent B		2228
    109. 

  109. nim	mvalues	tables.html#mvalues.i,OrderedTableRef[A,B]	iterator mvalues[A, B](t: OrderedTableRef[A, B]): var B		2248
    110. 

  110. nim	CountTable	tables.html#CountTable	object CountTable		2281
    111. 

  111. nim	CountTableRef	tables.html#CountTableRef	type CountTableRef		2289
    112. 

  112. nim	inc	tables.html#inc,CountTable[A],A,int	proc inc[A](t: var CountTable[A]; key: A; val = 1)		2325
    113. 

  113. nim	initCountTable	tables.html#initCountTable	proc initCountTable[A](initialSize = defaultInitialSize): CountTable[A]		2329
    114. 

  114. nim	toCountTable	tables.html#toCountTable,openArray[A]	proc toCountTable[A](keys: openArray[A]): CountTable[A]		2342
    115. 

  115. nim	`[]`	tables.html#[],CountTable[A],A	proc `[]`[A](t: CountTable[A]; key: A): int		2348
    116. 

  116. nim	`[]=`	tables.html#[]=,CountTable[A],A,int	proc `[]=`[A](t: var CountTable[A]; key: A; val: int)		2366
    117. 

  117. nim	len	tables.html#len,CountTable[A]	proc len[A](t: CountTable[A]): int		2402
    118. 

  118. nim	smallest	tables.html#smallest,CountTable[A]	proc smallest[A](t: CountTable[A]): tuple[key: A, val: int]		2406
    119. 

  119. nim	largest	tables.html#largest,CountTable[A]	proc largest[A](t: CountTable[A]): tuple[key: A, val: int]		2418
    120. 

  120. nim	hasKey	tables.html#hasKey,CountTable[A],A	proc hasKey[A](t: CountTable[A]; key: A): bool		2429
    121. 

  121. nim	contains	tables.html#contains,CountTable[A],A	proc contains[A](t: CountTable[A]; key: A): bool		2441
    122. 

  122. nim	getOrDefault	tables.html#getOrDefault,CountTable[A],A,int	proc getOrDefault[A](t: CountTable[A]; key: A; def: int = 0): int		2446
    123. 

  123. nim	del	tables.html#del,CountTable[A],A	proc del[A](t: var CountTable[A]; key: A)		2456
    124. 

  124. nim	pop	tables.html#pop,CountTable[A],A,int	proc pop[A](t: var CountTable[A]; key: A; val: var int): bool		2473
    125. 

  125. nim	clear	tables.html#clear,CountTable[A]	proc clear[A](t: var CountTable[A])		2497
    126. 

  126. nim	sort	tables.html#sort,CountTable[A]	proc sort[A](t: var CountTable[A]; order = SortOrder.Descending)		2509
    127. 

  127. nim	merge	tables.html#merge,CountTable[A],CountTable[A]	proc merge[A](s: var CountTable[A]; t: CountTable[A])		2530
    128. 

  128. nim	`$`	tables.html#$,CountTable[A]	proc `$`[A](t: CountTable[A]): string		2556
    129. 

  129. nim	`==`	tables.html#==,CountTable[A],CountTable[A]	proc `==`[A](s, t: CountTable[A]): bool		2561
    130. 

  130. nim	pairs	tables.html#pairs.i,CountTable[A]	iterator pairs[A](t: CountTable[A]): (A, int)		2567
    131. 

  131. nim	mpairs	tables.html#mpairs.i,CountTable[A]	iterator mpairs[A](t: var CountTable[A]): (A, var int)		2601
    132. 

  132. nim	keys	tables.html#keys.i,CountTable[A]	iterator keys[A](t: CountTable[A]): lent A		2620
    133. 

  133. nim	values	tables.html#values.i,CountTable[A]	iterator values[A](t: CountTable[A]): int		2638
    134. 

  134. nim	mvalues	tables.html#mvalues.i,CountTable[A]	iterator mvalues[A](t: var CountTable[A]): var int		2656
    135. 

  135. nim	inc	tables.html#inc,CountTableRef[A],A,int	proc inc[A](t: CountTableRef[A]; key: A; val = 1)		2685
    136. 

  136. nim	newCountTable	tables.html#newCountTable	proc newCountTable[A](initialSize = defaultInitialSize): CountTableRef[A]		2687
    137. 

  137. nim	newCountTable	tables.html#newCountTable,openArray[A]	proc newCountTable[A](keys: openArray[A]): CountTableRef[A]		2699
    138. 

  138. nim	`[]`	tables.html#[],CountTableRef[A],A	proc `[]`[A](t: CountTableRef[A]; key: A): int		2706
    139. 

  139. nim	`[]=`	tables.html#[]=,CountTableRef[A],A,int	proc `[]=`[A](t: CountTableRef[A]; key: A; val: int)		2720
    140. 

  140. nim	smallest	tables.html#smallest,CountTableRef[A]	proc smallest[A](t: CountTableRef[A]): tuple[key: A, val: int]		2741
    141. 

  141. nim	largest	tables.html#largest,CountTableRef[A]	proc largest[A](t: CountTableRef[A]): tuple[key: A, val: int]		2748
    142. 

  142. nim	hasKey	tables.html#hasKey,CountTableRef[A],A	proc hasKey[A](t: CountTableRef[A]; key: A): bool		2755
    143. 

  143. nim	contains	tables.html#contains,CountTableRef[A],A	proc contains[A](t: CountTableRef[A]; key: A): bool		2766
    144. 

  144. nim	getOrDefault	tables.html#getOrDefault,CountTableRef[A],A,int	proc getOrDefault[A](t: CountTableRef[A]; key: A; def: int): int		2771
    145. 

  145. nim	len	tables.html#len,CountTableRef[A]	proc len[A](t: CountTableRef[A]): int		2781
    146. 

  146. nim	del	tables.html#del,CountTableRef[A],A	proc del[A](t: CountTableRef[A]; key: A)		2785
    147. 

  147. nim	pop	tables.html#pop,CountTableRef[A],A,int	proc pop[A](t: CountTableRef[A]; key: A; val: var int): bool		2793
    148. 

  148. nim	clear	tables.html#clear,CountTableRef[A]	proc clear[A](t: CountTableRef[A])		2804
    149. 

  149. nim	sort	tables.html#sort,CountTableRef[A]	proc sort[A](t: CountTableRef[A]; order = SortOrder.Descending)		2812
    150. 

  150. nim	merge	tables.html#merge,CountTableRef[A],CountTableRef[A]	proc merge[A](s, t: CountTableRef[A])		2823
    151. 

  151. nim	`$`	tables.html#$,CountTableRef[A]	proc `$`[A](t: CountTableRef[A]): string		2834
    152. 

  152. nim	`==`	tables.html#==,CountTableRef[A],CountTableRef[A]	proc `==`[A](s, t: CountTableRef[A]): bool		2839
    153. 

  153. nim	pairs	tables.html#pairs.i,CountTableRef[A]	iterator pairs[A](t: CountTableRef[A]): (A, int)		2848
    154. 

  154. nim	mpairs	tables.html#mpairs.i,CountTableRef[A]	iterator mpairs[A](t: CountTableRef[A]): (A, var int)		2882
    155. 

  155. nim	keys	tables.html#keys.i,CountTableRef[A]	iterator keys[A](t: CountTableRef[A]): A		2901
    156. 

  156. nim	values	tables.html#values.i,CountTableRef[A]	iterator values[A](t: CountTableRef[A]): int		2919
    157. 

  157. nim	mvalues	tables.html#mvalues.i,CountTableRef[A]	iterator mvalues[A](t: CountTableRef[A]): var int		2937
    158. 

  158. nim	hash	tables.html#hash,Table[K,V]	proc hash[K, V](s: Table[K, V]): Hash		2955
    159. 

  159. nim	hash	tables.html#hash,OrderedTable[K,V]	proc hash[K, V](s: OrderedTable[K, V]): Hash		2961
    160. 

  160. nim	hash	tables.html#hash,CountTable[V]	proc hash[V](s: CountTable[V]): Hash		2967
    161. 

  161. idx	hash table	tables.html#hash-table_1	Module tables		0
    162. 

  162. idx	dictionary	tables.html#dictionary_1	Module tables		0
    163. 

  163. heading	Basic usage	tables.html#basic-usage	 Basic usage		0
    164. 

  164. heading	Table	tables.html#basic-usage-table	  Table		0
    165. 

  165. heading	OrderedTable	tables.html#basic-usage-orderedtable	  OrderedTable		0
    166. 

  166. heading	CountTable	tables.html#basic-usage-counttable	  CountTable		0
    167. 

  167. heading	Hashing	tables.html#basic-usage-hashing	  Hashing		0
    168. 

  168. heading	See also	tables.html#see-also	 See also		0
    169. 

  169. nimgrp	haskey	tables.html#hasKey-procs-all	proc		355
    170. 

  170. nimgrp	==	tables.html#==-procs-all	proc		584
    171. 

  171. nimgrp	sort	tables.html#sort-procs-all	proc		1639
    172. 

  172. nimgrp	smallest	tables.html#smallest-procs-all	proc		2406
    173. 

  173. nimgrp	del	tables.html#del-procs-all	proc		511
    174. 

  174. nimgrp	$	tables.html#$-procs-all	proc		579
    175. 

  175. nimgrp	newtable	tables.html#newTable-procs-all	proc		826
    176. 

  176. nimgrp	newcounttable	tables.html#newCountTable-procs-all	proc		2687
    177. 

  177. nimgrp	[]=	tables.html#[]=-procs-all	proc		284
    178. 

  178. nimgrp	take	tables.html#take-procs-all	proc		560
    179. 

  179. nimgrp	getordefault	tables.html#getOrDefault-procs-all	proc		403
    180. 

  180. nimgrp	contains	tables.html#contains-procs-all	proc		373
    181. 

  181. nimgrp	haskeyorput	tables.html#hasKeyOrPut-procs-all	proc		383
    182. 

  182. nimgrp	inc	tables.html#inc-procs-all	proc		2325
    183. 

  183. nimgrp	[]	tables.html#[]-procs-all	proc		316
    184. 

  184. nimgrp	clear	tables.html#clear-procs-all	proc		565
    185. 

  185. nimgrp	largest	tables.html#largest-procs-all	proc		2418
    186. 

  186. nimgrp	len	tables.html#len-procs-all	proc		489
    187. 

  187. nimgrp	add	tables.html#add-procs-all	proc		497
    188. 

  188. nimgrp	pop	tables.html#pop-procs-all	proc		529
    189. 

  189. nimgrp	neworderedtable	tables.html#newOrderedTable-procs-all	proc		1852
    190. 

  190. nimgrp	mgetorput	tables.html#mgetOrPut-procs-all	proc		439
    191. 

  191. nimgrp	merge	tables.html#merge-procs-all	proc		2530
    192. 

  192. nimgrp	hash	tables.html#hash-procs-all	proc		2955
    193. 

  193. nimgrp	values	tables.html#values-iterators-all	iterator		754
    194. 

  194. nimgrp	mpairs	tables.html#mpairs-iterators-all	iterator		711
    195. 

  195. nimgrp	mvalues	tables.html#mvalues-iterators-all	iterator		775
    196. 

  196. nimgrp	pairs	tables.html#pairs-iterators-all	iterator		680
    197. 

  197. nimgrp	keys	tables.html#keys-iterators-all	iterator		733
    198. 

  198. nimgrp	withvalue	tables.html#withValue-templates-all	template		604
    199. 

  199.