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

introduce temporary <//> for 'owned' to get this compile with 0.19 (#11145)

Browse source 
* introduce temporary <//> for 'owned' to get this compile with 0.19
* make newTable[string, owned Node]() compile (but it crashes)
* make sink/owned parameters consistent
* make actiontable test compile again
* VM: support sytem.move; makes tests green
This commit is contained in:
Andreas Rumpf 2019-05-02 08:07:09 +02:00 • committed by GitHub
commit e1515b53d1
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
9 changed files with 69 additions and 46 deletions
Download patch file Download diff file Expand all files Collapse all files

18
lib/pure/collections/lists.nim
View file

@ -80,14 +80,15 @@ type
DoublyLinkedNodeObj*[T] = object ## A node a doubly linked list consists of.
##
## It consists of a `value` field, and pointers to `next` and `prev`.
next*, prev*: ref DoublyLinkedNodeObj[T]
next*: <//>(ref DoublyLinkedNodeObj[T])
prev*: ref DoublyLinkedNodeObj[T]
value*: T
DoublyLinkedNode*[T] = ref DoublyLinkedNodeObj[T]
SinglyLinkedNodeObj*[T] = object ## A node a singly linked list consists of.
##
## It consists of a `value` field, and a pointer to `next`.
next*: ref SinglyLinkedNodeObj[T]
next*: <//>(ref SinglyLinkedNodeObj[T])
value*: T
SinglyLinkedNode*[T] = ref SinglyLinkedNodeObj[T]
@ -95,19 +96,22 @@ type
##
## Use `initSinglyLinkedList proc <#initSinglyLinkedList>`_ to create
## a new empty list.
head*, tail*: SinglyLinkedNode[T]
head*: <//>(SinglyLinkedNode[T])
tail*: SinglyLinkedNode[T]
DoublyLinkedList*[T] = object ## A doubly linked list.
##
## Use `initDoublyLinkedList proc <#initDoublyLinkedList>`_ to create
## a new empty list.
head*, tail*: DoublyLinkedNode[T]
head*: <//>(DoublyLinkedNode[T])
tail*: DoublyLinkedNode[T]
SinglyLinkedRing*[T] = object ## A singly linked ring.
##
## Use `initSinglyLinkedRing proc <#initSinglyLinkedRing>`_ to create
## a new empty ring.
head*, tail*: SinglyLinkedNode[T]
head*: <//>(SinglyLinkedNode[T])
tail*: SinglyLinkedNode[T]
DoublyLinkedRing*[T] = object ## A doubly linked ring.
##
@ -147,7 +151,7 @@ proc initDoublyLinkedRing*[T](): DoublyLinkedRing[T] =
var a = initDoublyLinkedRing[int]()
discard
proc newDoublyLinkedNode*[T](value: T): DoublyLinkedNode[T] =
proc newDoublyLinkedNode*[T](value: T): <//>(DoublyLinkedNode[T]) =
## Creates a new doubly linked node with the given `value`.
runnableExamples:
var n = newDoublyLinkedNode[int](5)
@ -156,7 +160,7 @@ proc newDoublyLinkedNode*[T](value: T): DoublyLinkedNode[T] =
new(result)
result.value = value
proc newSinglyLinkedNode*[T](value: T): SinglyLinkedNode[T] =
proc newSinglyLinkedNode*[T](value: T): <//>(SinglyLinkedNode[T]) =
## Creates a new singly linked node with the given `value`.
runnableExamples:
var n = newSinglyLinkedNode[int](5)

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

@ -274,7 +274,7 @@ proc enlarge[A, B](t: var Table[A, B]) =
var j: Hash = eh and maxHash(t)
while isFilled(t.data[j].hcode):
j = nextTry(j, maxHash(t))
rawInsert(t, t.data, n[i].key, n[i].val, eh, j)
rawInsert(t, t.data, move n[i].key, move n[i].val, eh, j)
@ -768,7 +768,7 @@ iterator allValues*[A, B](t: Table[A, B]; key: A): B =
# -------------------------------------------------------------------
proc newTable*[A, B](initialsize = defaultInitialSize): TableRef[A, B] =
proc newTable*[A, B](initialsize = defaultInitialSize): <//>TableRef[A, B] =
## Creates a new ref hash table that is empty.
##
## ``initialSize`` must be a power of two (default: 64).
@ -789,7 +789,7 @@ proc newTable*[A, B](initialsize = defaultInitialSize): TableRef[A, B] =
new(result)
result[] = initTable[A, B](initialSize)
proc newTable*[A, B](pairs: openArray[(A, B)]): TableRef[A, B] =
proc newTable*[A, B](pairs: openArray[(A, B)]): <//>TableRef[A, B] =
## Creates a new ref hash table that contains the given ``pairs``.
##
## ``pairs`` is a container consisting of ``(key, value)`` tuples.
@ -805,7 +805,7 @@ proc newTable*[A, B](pairs: openArray[(A, B)]): TableRef[A, B] =
new(result)
result[] = toTable[A, B](pairs)
proc newTableFrom*[A, B, C](collection: A, index: proc(x: B): C): TableRef[C, B] =
proc newTableFrom*[A, B, C](collection: A, index: proc(x: B): C): <//>TableRef[C, B] =
## Index the collection with the proc provided.
# TODO: As soon as supported, change collection: A to collection: A[B]
result = newTable[C, B]()
@ -1690,7 +1690,7 @@ iterator mvalues*[A, B](t: var OrderedTable[A, B]): var B =
# --------------------------- OrderedTableRef -------------------------------
# ---------------------------------------------------------------------------
proc newOrderedTable*[A, B](initialsize = defaultInitialSize): OrderedTableRef[A, B] =
proc newOrderedTable*[A, B](initialsize = defaultInitialSize): <//>OrderedTableRef[A, B] =
## Creates a new ordered ref hash table that is empty.
##
## ``initialSize`` must be a power of two (default: 64).
@ -1711,7 +1711,7 @@ proc newOrderedTable*[A, B](initialsize = defaultInitialSize): OrderedTableRef[A
new(result)
result[] = initOrderedTable[A, B](initialSize)
proc newOrderedTable*[A, B](pairs: openArray[(A, B)]): OrderedTableRef[A, B] =
proc newOrderedTable*[A, B](pairs: openArray[(A, B)]): <//>OrderedTableRef[A, B] =
## Creates a new ordered ref hash table that contains the given ``pairs``.
##
## ``pairs`` is a container consisting of ``(key, value)`` tuples.
@ -2412,7 +2412,7 @@ iterator mvalues*[A](t: var CountTable[A]): var int =
proc inc*[A](t: CountTableRef[A], key: A, val = 1)
proc newCountTable*[A](initialsize = defaultInitialSize): CountTableRef[A] =
proc newCountTable*[A](initialsize = defaultInitialSize): <//>CountTableRef[A] =
## Creates a new ref count table that is empty.
##
## ``initialSize`` must be a power of two (default: 64).
@ -2429,7 +2429,7 @@ proc newCountTable*[A](initialsize = defaultInitialSize): CountTableRef[A] =
new(result)
result[] = initCountTable[A](initialSize)
proc newCountTable*[A](keys: openArray[A]): CountTableRef[A] =
proc newCountTable*[A](keys: openArray[A]): <//>CountTableRef[A] =
## Creates a new ref count table with every member of a container ``keys``
## having a count of how many times it occurs in that container.
result = newCountTable[A](rightSize(keys.len))