diff options
Diffstat (limited to 'tests/generics')
36 files changed, 291 insertions, 111 deletions
diff --git a/tests/generics/mbind_bracket.nim b/tests/generics/mbind_bracket.nim new file mode 100644 index 000000000..4bf18b471 --- /dev/null +++ b/tests/generics/mbind_bracket.nim @@ -0,0 +1,17 @@ + +import tables + +type + UUIDObject* = ref object + uuid: string + + Registry*[T] = ref object + objects: Table[string, T] + +proc newRegistry*[T](): Registry[T] = + result = Registry[T]() + result.objects = initTable[string, T](128) + +proc register*[T](self: Registry[T], obj: T) = + self.objects[obj.uuid] = obj + diff --git a/tests/generics/mclosed_sym.nim b/tests/generics/mclosed_sym.nim new file mode 100644 index 000000000..bcccd9a85 --- /dev/null +++ b/tests/generics/mclosed_sym.nim @@ -0,0 +1,10 @@ + +type R* = object + +type Data*[T] = object + d*: T + +proc same(r:R, d:int) = echo "TEST2" + +proc doIt*(d:Data, r:R) = + r.same(1) # Expecting this to invoke the local `same()` method diff --git a/tests/generics/mmodule_same_as_proc.nim b/tests/generics/mmodule_same_as_proc.nim new file mode 100644 index 000000000..048b98336 --- /dev/null +++ b/tests/generics/mmodule_same_as_proc.nim @@ -0,0 +1,2 @@ + +proc mmodule_same_as_proc*(x: string) = discard diff --git a/tests/generics/moverloading_typedesc.nim b/tests/generics/moverloading_typedesc.nim new file mode 100644 index 000000000..92805fb7b --- /dev/null +++ b/tests/generics/moverloading_typedesc.nim @@ -0,0 +1,11 @@ +import tables + +type + FFoo* = object + FBar* = object + +proc new*(_: typedesc[FFoo]): int = 2 +proc new*[T](_: typedesc[T]): int = 3 +proc new*(_: typedesc): int = 4 +proc new*(_: typedesc[seq[Table[int, seq[Table[int, string]]]]]): int = 5 +proc new*(_: typedesc[seq[Table[int, seq[Table[int, typedesc]]]]]): int = 6 diff --git a/tests/generics/t1056.nim b/tests/generics/t1056.nim index b1fe25894..de8bde8ef 100644 --- a/tests/generics/t1056.nim +++ b/tests/generics/t1056.nim @@ -17,7 +17,7 @@ proc echoMatrix(a: TMatrix) = proc echoMat2(a: TMat2) = echo TMat2.M - + var m = TMatrix[3,3,int](data: [1,2,3,4,5,6,7,8,9]) echoMatrix m diff --git a/tests/generics/t1789.nim b/tests/generics/t1789.nim index 188db88f6..c3fe336af 100644 --- a/tests/generics/t1789.nim +++ b/tests/generics/t1789.nim @@ -38,7 +38,7 @@ type proc `[]`*[N, T](f: Bar[N, T], n: range[0..(N - 1)]): T = assert high(n) == N-1 result = f.bar[n] - + var b: Bar[3, int] echo b[2] diff --git a/tests/generics/tbind_bracket.nim b/tests/generics/tbind_bracket.nim new file mode 100644 index 000000000..d0c5e2c6b --- /dev/null +++ b/tests/generics/tbind_bracket.nim @@ -0,0 +1,20 @@ +discard """ + output: "317" +""" + +# bug #2599 + +import mbind_bracket + +# also test that `[]` can be passed now as a first class construct: + +template takeBracket(x, a, i: untyped) = + echo x(a, i) + +var a: array[10, int] +a[8] = 317 + +takeBracket(`[]`, a, 8) + +let reg = newRegistry[UUIDObject]() +reg.register(UUIDObject()) diff --git a/tests/generics/tbintre2.nim b/tests/generics/tbintre2.nim index 2a7225411..eb46b5157 100644 --- a/tests/generics/tbintre2.nim +++ b/tests/generics/tbintre2.nim @@ -15,7 +15,7 @@ if find(root, "world"): for str in items(root): stdout.write(str) else: - stdout.writeln("BUG") + stdout.writeLine("BUG") var r2: PBinaryTree[int] diff --git a/tests/generics/tbintree.nim b/tests/generics/tbintree.nim index 8cc8acb82..13163f764 100644 --- a/tests/generics/tbintree.nim +++ b/tests/generics/tbintree.nim @@ -92,7 +92,7 @@ when isMainModule: for str in items(root): stdout.write(str) else: - stdout.writeln("BUG") + stdout.writeLine("BUG") var r2: PBinaryTree[int] diff --git a/tests/generics/tcan_alias_generic.nim b/tests/generics/tcan_alias_generic.nim index 780a47841..b357b33e9 100644 --- a/tests/generics/tcan_alias_generic.nim +++ b/tests/generics/tcan_alias_generic.nim @@ -2,10 +2,9 @@ ## can_alias_generic Nim Module ## ## Created by Eric Doughty-Papassideris on 2011-02-16. -## Copyright (c) 2011 FWA. All rights reserved. type TGen[T] = object TGen2[T] = TGen[T] - + diff --git a/tests/generics/tcan_alias_specialised_generic.nim b/tests/generics/tcan_alias_specialised_generic.nim index a737d3580..c94edd611 100644 --- a/tests/generics/tcan_alias_specialised_generic.nim +++ b/tests/generics/tcan_alias_specialised_generic.nim @@ -6,12 +6,11 @@ discard """ ## can_alias_specialised_generic Nim Module ## ## Created by Eric Doughty-Papassideris on 2011-02-16. -## Copyright (c) 2011 FWA. All rights reserved. type TGen[T] = object TSpef = TGen[string] - + var s: TSpef diff --git a/tests/generics/tcan_inherit_generic.nim b/tests/generics/tcan_inherit_generic.nim index ce2b6452f..331fcfd5c 100644 --- a/tests/generics/tcan_inherit_generic.nim +++ b/tests/generics/tcan_inherit_generic.nim @@ -2,12 +2,11 @@ ## can_inherit_generic Nim Module ## ## Created by Eric Doughty-Papassideris on 2011-02-16. -## Copyright (c) 2011 FWA. All rights reserved. type TGen[T] = object of TObject x, y: T - + TSpef[T] = object of TGen[T] diff --git a/tests/generics/tcan_specialise_generic.nim b/tests/generics/tcan_specialise_generic.nim index c510910e8..78896db38 100644 --- a/tests/generics/tcan_specialise_generic.nim +++ b/tests/generics/tcan_specialise_generic.nim @@ -2,10 +2,9 @@ ## can_specialise_generic Nim Module ## ## Created by Eric Doughty-Papassideris on 2011-02-16. -## Copyright (c) 2011 FWA. All rights reserved. type TGen[T] = object {.inheritable.} TSpef = object of TGen[string] - + diff --git a/tests/generics/tclosed_sym.nim b/tests/generics/tclosed_sym.nim new file mode 100644 index 000000000..ff620c267 --- /dev/null +++ b/tests/generics/tclosed_sym.nim @@ -0,0 +1,11 @@ +discard """ + output: "TEST2" +""" + +# bug #2664 + +import mclosed_sym + +proc same(r:R, d:int) = echo "TEST1" + +doIt(Data[int](d:123), R()) diff --git a/tests/generics/tconfusing_arrow.nim b/tests/generics/tconfusing_arrow.nim index 6a5a9d682..f63a874e0 100644 --- a/tests/generics/tconfusing_arrow.nim +++ b/tests/generics/tconfusing_arrow.nim @@ -5,7 +5,7 @@ type Deck = object proc sort(h: var seq[Deck]) = # works: - h.sort(proc (x, y: Deck): auto = + h.sort(proc (x, y: Deck): auto = cmp(x.value, y.value)) # fails: h.sort((x, y: Deck) => cmp(ord(x.value), ord(y.value))) diff --git a/tests/generics/tdictdestruct.nim b/tests/generics/tdictdestruct.nim new file mode 100644 index 000000000..228d93e66 --- /dev/null +++ b/tests/generics/tdictdestruct.nim @@ -0,0 +1,20 @@ + +type + TDict[TK, TV] = object + k: TK + v: TV + PDict[TK, TV] = ref TDict[TK, TV] + +proc fakeNew[T](x: var ref T, destroy: proc (a: ref T) {.nimcall.}) = + discard + +proc destroyDict[TK, TV](a: PDict[TK, TV]) = + return +proc newDict[TK, TV](a: TK, b: TV): PDict[TK, TV] = + fakeNew(result, destroyDict[TK, TV]) + +# Problem: destroyDict is not instantiated when newDict is instantiated! + +discard newDict("a", "b") + + diff --git a/tests/generics/tdont_use_inner_scope.nim b/tests/generics/tdont_use_inner_scope.nim new file mode 100644 index 000000000..45b11fc22 --- /dev/null +++ b/tests/generics/tdont_use_inner_scope.nim @@ -0,0 +1,27 @@ + +# bug #2752 + +import future, sequtils + +proc myFilter[T](it: (iterator(): T), f: (proc(anything: T):bool)): (iterator(): T) = + iterator aNameWhichWillConflict(): T {.closure.}= + for x in it(): + if f(x): + yield x + result = aNameWhichWillConflict + + +iterator testIt():int {.closure.}= + yield -1 + yield 2 + +#let unusedVariable = myFilter(testIt, (x: int) => x > 0) + +proc onlyPos(it: (iterator(): int)): (iterator(): int)= + iterator aNameWhichWillConflict(): int {.closure.}= + var filtered = onlyPos(myFilter(it, (x:int) => x > 0)) + for x in filtered(): + yield x + result = aNameWhichWillConflict + +let x = onlyPos(testIt) diff --git a/tests/generics/texplicitgeneric1.nim b/tests/generics/texplicitgeneric1.nim index d54044368..ac0197c1a 100644 --- a/tests/generics/texplicitgeneric1.nim +++ b/tests/generics/texplicitgeneric1.nim @@ -5,33 +5,33 @@ discard """ # test explicit type instantiation type - TDict*[TKey, TValue] = object + TDict*[TKey, TValue] = object data: seq[tuple[k: TKey, v: TValue]] PDict*[TKey, #with `==`(a, b: TKey): bool - # hash(a: TKey): int, + # hash(a: TKey): int, TValue] = ref TDict[TKey, TValue] - -proc newDict*[TKey, TValue](): PDict[TKey, TValue] = + +proc newDict*[TKey, TValue](): PDict[TKey, TValue] = new(result) result.data = @[] - -proc add*[TKey, TValue](d: PDict[TKey, TValue], k: TKey, v: TValue) = + +proc add*[TKey, TValue](d: PDict[TKey, TValue], k: TKey, v: TValue) = d.data.add((k, v)) - -iterator items*[Tkey, TValue](d: PDict[TKey, TValue]): tuple[k: TKey, - v: TValue] = + +iterator items*[Tkey, TValue](d: PDict[TKey, TValue]): tuple[k: TKey, + v: TValue] = for k, v in items(d.data): yield (k, v) - + var d = newDict[int, string]() d.add(12, "12") d.add(13, "13") -for k, v in items(d): +for k, v in items(d): stdout.write("Key: ", $k, " value: ", v) var c = newDict[char, string]() c.add('A', "12") c.add('B', "13") -for k, v in items(c): +for k, v in items(c): stdout.write(" Key: ", $k, " value: ", v) diff --git a/tests/generics/texplicitgeneric2.nim b/tests/generics/texplicitgeneric2.nim index 95461d023..c4af17b7b 100644 --- a/tests/generics/texplicitgeneric2.nim +++ b/tests/generics/texplicitgeneric2.nim @@ -6,30 +6,30 @@ discard """ # test explicit type instantiation type - TDict*[TKey, TValue] = object + TDict*[TKey, TValue] = object data: seq[tuple[k: TKey, v: TValue]] PDict*[TKey, TValue] = ref TDict[TKey, TValue] - -proc newDict*[TKey, TValue](): PDict[TKey, TValue] = + +proc newDict*[TKey, TValue](): PDict[TKey, TValue] = new(result) result.data = @[] - -proc add*(d: PDict, k: TKey, v: TValue) = + +proc add*(d: PDict, k: TKey, v: TValue) = d.data.add((k, v)) - -#iterator items*(d: PDict): tuple[k: TKey, v: TValue] = + +#iterator items*(d: PDict): tuple[k: TKey, v: TValue] = # for k, v in items(d.data): yield (k, v) - + var d = newDict[int, string]() d.add(12, "12") d.add(13, "13") -for k, v in items(d): +for k, v in items(d): stdout.write("Key: ", $k, " value: ", v) var c = newDict[char, string]() c.add('A', "12") c.add('B', "13") -for k, v in items(c): +for k, v in items(c): stdout.write(" Key: ", $k, " value: ", v) diff --git a/tests/generics/tgeneric1.nim b/tests/generics/tgeneric1.nim index 5d20a864b..5349f8f1d 100644 --- a/tests/generics/tgeneric1.nim +++ b/tests/generics/tgeneric1.nim @@ -9,7 +9,7 @@ type TBinHeap[T] = object heap: seq[TNode[T]] last: int - + PBinHeap[T] = ref TBinHeap[T] proc newBinHeap*[T](heap: var PBinHeap[T], size: int) = @@ -17,7 +17,7 @@ proc newBinHeap*[T](heap: var PBinHeap[T], size: int) = heap.last = 0 newSeq(heap.heap, size) #newSeq(heap.seq, size) - + proc parent(elem: int): int {.inline.} = return (elem-1) div 2 diff --git a/tests/generics/tgeneric3.nim b/tests/generics/tgeneric3.nim index 289bf1fd5..d4dac9385 100644 --- a/tests/generics/tgeneric3.nim +++ b/tests/generics/tgeneric3.nim @@ -37,25 +37,25 @@ proc clean[T: SomeOrdinal|SomeNumber](o: var T) {.inline.} = discard proc clean[T: string|seq](o: var T) {.inline.} = o = nil -proc clean[T,D] (o: ref TItem[T,D]) {.inline.} = +proc clean[T,D] (o: ref TItem[T,D]) {.inline.} = when (D is string) : o.value = nil else : o.val_set = false -proc isClean[T,D] (it: ref TItem[T,D]): bool {.inline.} = +proc isClean[T,D] (it: ref TItem[T,D]): bool {.inline.} = when (D is string) : return it.value == nil else : return not it.val_set -proc isClean[T,D](n: PNode[T,D], x: int): bool {.inline.} = +proc isClean[T,D](n: PNode[T,D], x: int): bool {.inline.} = when (D is string): return n.slots[x].value == nil else: return not n.slots[x].val_set -proc setItem[T,D](Akey: T, Avalue: D, ANode: PNode[T,D]): ref TItem[T,D] {.inline.} = +proc setItem[T,D](Akey: T, Avalue: D, ANode: PNode[T,D]): ref TItem[T,D] {.inline.} = new(result) result.key = Akey result.value = Avalue @@ -72,8 +72,8 @@ template binSearchImpl *(docmp: expr) {.immediate.} = var H = haystack.len -1 while result <= H : var I {.inject.} = (result + H) shr 1 - var SW = docmp - if SW < 0: result = I + 1 + var SW = docmp + if SW < 0: result = I + 1 else: H = I - 1 if SW == 0 : bFound = true @@ -85,14 +85,14 @@ proc bSearch[T,D] (haystack: PNode[T,D], needle:T): int {.inline.} = proc DeleteItem[T,D] (n: PNode[T,D], x: int): PNode[T,D] {.inline.} = var w = n.slots[x] - if w.node != nil : + if w.node != nil : clean(w) return n dec(n.count) if n.count > 0 : for i in countup(x, n.count -1) : n.slots[i] = n.slots[i + 1] n.slots[n.count] = nil - case n.count + case n.count of cLen1 : setLen(n.slots, cLen1) of cLen2 : setLen(n.slots, cLen2) of cLen3 : setLen(n.slots, cLen3) @@ -106,7 +106,7 @@ proc DeleteItem[T,D] (n: PNode[T,D], x: int): PNode[T,D] {.inline.} = n.slots = nil n.left = nil -proc internalDelete[T,D] (ANode: PNode[T,D], key: T, Avalue: var D): PNode[T,D] = +proc internalDelete[T,D] (ANode: PNode[T,D], key: T, Avalue: var D): PNode[T,D] = var Path: array[0..20, RPath[T,D]] var n = ANode result = n @@ -126,20 +126,20 @@ proc internalDelete[T,D] (ANode: PNode[T,D], key: T, Avalue: var D): PNode[T,D] n = n.slots[x].node else : n = nil - else : + else : dec(x) if isClean(n, x) : return Avalue = n.slots[x].value var n2 = DeleteItem(n, x) dec(h) while (n2 != n) and (h >=0) : - n = n2 + n = n2 var w = addr Path[h] x = w.Xi -1 if x >= 0 : if (n == nil) and isClean(w.Nd, x) : n = w.Nd - n.slots[x].node = nil + n.slots[x].node = nil n2 = DeleteItem(n, x) else : w.Nd.slots[x].node = n @@ -161,7 +161,7 @@ proc internalFind[T,D] (n: PNode[T,D], key: T): ref TItem[T,D] {.inline.} = wn = wn.left else : x = (-x) -1 - if x < wn.count : + if x < wn.count : wn = wn.slots[x].node else : return nil @@ -171,7 +171,7 @@ proc internalFind[T,D] (n: PNode[T,D], key: T): ref TItem[T,D] {.inline.} = return nil proc traceTree[T,D](root: PNode[T,D]) = - proc traceX(x: int) = + proc traceX(x: int) = write stdout, "(" write stdout, x write stdout, ") " @@ -184,7 +184,7 @@ proc traceTree[T,D](root: PNode[T,D]) = proc traceln(space: string) = - writeln stdout, "" + writeLine stdout, "" write stdout, space proc doTrace(n: PNode[T,D], level: int) = @@ -192,7 +192,7 @@ proc traceTree[T,D](root: PNode[T,D]) = traceln(space) write stdout, "node: " if n == nil: - writeln stdout, "is empty" + writeLine stdout, "is empty" return write stdout, n.count write stdout, " elements: " @@ -204,7 +204,7 @@ proc traceTree[T,D](root: PNode[T,D]) = if el != nil and not isClean(el): traceln(space) traceX(i) - if i >= n.count: + if i >= n.count: write stdout, "error " else: traceEl(el) @@ -219,14 +219,14 @@ proc traceTree[T,D](root: PNode[T,D]) = else : write stdout, el.key if el.node != nil: doTrace(el.node, level +1) else : write stdout, " empty " - writeln stdout,"" + writeLine stdout,"" doTrace(root, 0) proc InsertItem[T,D](APath: RPath[T,D], ANode:PNode[T,D], Akey: T, Avalue: D) = var x = - APath.Xi inc(APath.Nd.count) - case APath.Nd.count + case APath.Nd.count of cLen1: setLen(APath.Nd.slots, cLen2) of cLen2: setLen(APath.Nd.slots, cLen3) of cLen3: setLen(APath.Nd.slots, cLenCenter) @@ -286,7 +286,7 @@ proc internalPut[T,D](ANode: ref TNode[T,D], Akey: T, Avalue: D, Oldvalue: var D if x <= 0 : Path[h].Nd = n Path[h].Xi = x - inc(h) + inc(h) if x == 0 : n = n.left else : @@ -337,40 +337,40 @@ proc CleanTree[T,D](n: PNode[T,D]): PNode[T,D] = proc VisitAllNodes[T,D](n: PNode[T,D], visit: proc(n: PNode[T,D]): PNode[T,D] {.closure.} ): PNode[T,D] = if n != nil : if n.left != nil : - n.left = VisitAllNodes(n.left, visit) + n.left = VisitAllNodes(n.left, visit) for i in 0 .. n.count - 1 : var w = n.slots[i] if w.node != nil : - w.node = VisitAllNodes(w.node, visit) + w.node = VisitAllNodes(w.node, visit) return visit(n) return nil proc VisitAllNodes[T,D](n: PNode[T,D], visit: proc(n: PNode[T,D]) {.closure.} ) = if n != nil: if n.left != nil : - VisitAllNodes(n.left, visit) + VisitAllNodes(n.left, visit) for i in 0 .. n.count - 1 : var w = n.slots[i] if w.node != nil : - VisitAllNodes(w.node, visit) + VisitAllNodes(w.node, visit) visit(n) proc VisitAll[T,D](n: PNode[T,D], visit: proc(Akey: T, Avalue: D) {.closure.} ) = if n != nil: if n.left != nil : - VisitAll(n.left, visit) + VisitAll(n.left, visit) for i in 0 .. n.count - 1 : var w = n.slots[i] if not w.isClean : - visit(w.key, w.value) + visit(w.key, w.value) if w.node != nil : - VisitAll(w.node, visit) + VisitAll(w.node, visit) proc VisitAll[T,D](n: PNode[T,D], visit: proc(Akey: T, Avalue: var D):bool {.closure.} ): PNode[T,D] = if n != nil: var n1 = n.left if n1 != nil : - var n2 = VisitAll(n1, visit) + var n2 = VisitAll(n1, visit) if n1 != n2 : n.left = n2 var i = 0 @@ -395,7 +395,7 @@ iterator keys* [T,D] (n: PNode[T,D]): T = var level = 0 var nd = n var i = -1 - while true : + while true : if i < nd.count : Path[level].Nd = nd Path[level].Xi = i @@ -471,4 +471,4 @@ when isMainModule: - test() \ No newline at end of file + test() diff --git a/tests/generics/tgenericdefaults.nim b/tests/generics/tgenericdefaults.nim index ad96f1851..a4c90a884 100644 --- a/tests/generics/tgenericdefaults.nim +++ b/tests/generics/tgenericdefaults.nim @@ -1,4 +1,4 @@ -type +type TFoo[T, U, R = int] = object x: T y: U @@ -12,7 +12,7 @@ static: assert type(x1.x) is int assert type(x1.y) is float assert type(x1.z) is int - + var x2: TFoo[string, R = float, U = seq[int]] static: diff --git a/tests/generics/tgenericmatcher.nim b/tests/generics/tgenericmatcher.nim index edd0c4cf1..2edf46187 100644 --- a/tests/generics/tgenericmatcher.nim +++ b/tests/generics/tgenericmatcher.nim @@ -16,7 +16,7 @@ type min, max: int PMatcher[T] = ref TMatcher[T] -var +var m: PMatcher[int] diff --git a/tests/generics/tgenericmatcher2.nim b/tests/generics/tgenericmatcher2.nim index aa2f9dbb3..6832f80b7 100644 --- a/tests/generics/tgenericmatcher2.nim +++ b/tests/generics/tgenericmatcher2.nim @@ -12,7 +12,7 @@ type matcher: ref TMatcher[T] min, max: int -var +var m: ref TMatcher[int] diff --git a/tests/generics/tgenericrefs.nim b/tests/generics/tgenericrefs.nim index a44b96af9..245789caf 100644 --- a/tests/generics/tgenericrefs.nim +++ b/tests/generics/tgenericrefs.nim @@ -1,4 +1,4 @@ -type +type PA[T] = ref TA[T] TA[T] = object field: T @@ -20,18 +20,18 @@ foo 23 when false: # Compiles unless you use var a: PA[string] - type + type PA = ref TA TA[T] = object # Cannot instantiate: - type + type TA[T] = object a: PA[T] PA[T] = ref TA[T] - type + type PA[T] = ref TA[T] TA[T] = object diff --git a/tests/generics/tgenericshardcases.nim b/tests/generics/tgenericshardcases.nim index e3b805db6..72a2f4ec2 100644 --- a/tests/generics/tgenericshardcases.nim +++ b/tests/generics/tgenericshardcases.nim @@ -7,7 +7,7 @@ import typetraits proc typeNameLen(x: typedesc): int {.compileTime.} = result = x.name.len - + macro selectType(a, b: typedesc): typedesc = result = a @@ -33,7 +33,7 @@ static: assert high(f1.data2) == 5 # length of MyEnum minus one, because we used T.high assert high(f2.data1) == 126 - assert high(f2.data2) == 3 + assert high(f2.data2) == 3 assert high(f1.data3) == 6 # length of MyEnum assert high(f2.data3) == 4 # length of int8 diff --git a/tests/generics/tgenericvariant.nim b/tests/generics/tgenericvariant.nim index 0150cda8d..348d3da6e 100644 --- a/tests/generics/tgenericvariant.nim +++ b/tests/generics/tgenericvariant.nim @@ -1,4 +1,4 @@ -type +type TMaybe[T] = object case empty: bool of false: value: T diff --git a/tests/generics/tinferredgenericprocs.nim b/tests/generics/tinferredgenericprocs.nim index 12adfe965..359c71ba8 100644 --- a/tests/generics/tinferredgenericprocs.nim +++ b/tests/generics/tinferredgenericprocs.nim @@ -5,10 +5,11 @@ discard """ 3''' """ +import sequtils # https://github.com/Araq/Nim/issues/797 proc foo[T](s:T):string = $s -type IntStringProc = proc(x: int): string +type IntStringProc = proc(x: int): string var f1 = IntStringProc(foo) var f2: proc(x: int): string = foo diff --git a/tests/generics/tmap_auto.nim b/tests/generics/tmap_auto.nim new file mode 100644 index 000000000..572556722 --- /dev/null +++ b/tests/generics/tmap_auto.nim @@ -0,0 +1,13 @@ +import future, sequtils + +let x = map(@[1, 2, 3], x => x+10) +assert x == @[11, 12, 13] + +let y = map(@[(1,"a"), (2,"b"), (3,"c")], x => $x[0] & x[1]) +assert y == @["1a", "2b", "3c"] + +proc eatsTwoArgProc[T,S,U](a: T, b: S, f: proc(t: T, s: S): U): U = + f(a,b) + +let z = eatsTwoArgProc(1, "a", (t,s) => $t & s) +assert z == "1a" diff --git a/tests/generics/tmodule_same_as_proc.nim b/tests/generics/tmodule_same_as_proc.nim new file mode 100644 index 000000000..113ca1bc3 --- /dev/null +++ b/tests/generics/tmodule_same_as_proc.nim @@ -0,0 +1,9 @@ + +# bug #1965 + +import mmodule_same_as_proc + +proc test[T](t: T) = + mmodule_same_as_proc"a" + +test(0) diff --git a/tests/generics/toverloading_typedesc.nim b/tests/generics/toverloading_typedesc.nim new file mode 100644 index 000000000..5882640f2 --- /dev/null +++ b/tests/generics/toverloading_typedesc.nim @@ -0,0 +1,23 @@ +discard """ + exitcode: 0 +""" +import moverloading_typedesc +import tables + +type + LFoo = object + LBar = object + + +when isMainModule: + doAssert FBar.new() == 3 + + proc new(_: typedesc[LFoo]): int = 0 + proc new[T](_: typedesc[T]): int = 1 + proc new*(_: typedesc[seq[Table[int, seq[Table[int, typedesc]]]]]): int = 7 + + doAssert LFoo.new() == 0 # Tests selecting more precise type + doAssert LBar.new() == 1 # Tests preferring function from local scope + doAssert FBar.new() == 1 + doAssert FFoo.new() == 2 # Tests selecting more precise type from other module + doAssert seq[Table[int, seq[Table[int, string]]]].new() == 5 # Truly complex type test diff --git a/tests/generics/tspecialised_is_equivalent.nim b/tests/generics/tspecialised_is_equivalent.nim index ace562862..56fd72630 100644 --- a/tests/generics/tspecialised_is_equivalent.nim +++ b/tests/generics/tspecialised_is_equivalent.nim @@ -2,7 +2,6 @@ ## specialised_is_equivalent Nim Module ## ## Created by Eric Doughty-Papassideris on 2011-02-16. -## Copyright (c) 2011 FWA. All rights reserved. type TGen[T] = tuple[a: T] diff --git a/tests/generics/tthread_generic.nim b/tests/generics/tthread_generic.nim index fdd11d9d1..e8946caf6 100644 --- a/tests/generics/tthread_generic.nim +++ b/tests/generics/tthread_generic.nim @@ -3,7 +3,7 @@ discard """ """ type - TThreadFuncArgs[T] = object of TObject + TThreadFuncArgs[T] = object of RootObj a: proc(): T {.thread.} b: proc(val: T) {.thread.} @@ -13,7 +13,7 @@ proc handleThreadFunc(arg: TThreadFuncArgs[int]){.thread.} = var output = fn() callback(output) -proc `@||->`*[T](fn: proc(): T {.thread.}, +proc `@||->`*[T](fn: proc(): T {.thread.}, callback: proc(val: T){.thread.}): TThread[TThreadFuncArgs[T]] = var thr: TThread[TThreadFuncArgs[T]] var args: TThreadFuncArgs[T] @@ -31,7 +31,7 @@ when isMainModule: return 1 proc callbackFunc(val: int) {.thread.} = echo($(val)) - + var thr = (testFunc @||-> callbackFunc) echo("test") joinThread(thr) diff --git a/tests/generics/twrong_field_caching.nim b/tests/generics/twrong_field_caching.nim index 595c58eb7..667ffbbe5 100644 --- a/tests/generics/twrong_field_caching.nim +++ b/tests/generics/twrong_field_caching.nim @@ -13,10 +13,10 @@ x32: 3x2 (3x2)''' type RectArray*[R, C: static[int], T] = distinct array[R * C, T] - + var a23: RectArray[2, 3, int] var a32: RectArray[3, 2, int] - + echo "a23: ", a23.R, "x", a23.C echo "a32: ", a32.R, "x", a32.C @@ -34,8 +34,8 @@ echo "t32: ", t32.R, "x", t32.C # Output: # t32: 3x2 - - + + # Everything is still OK. Now let's use the rectangular array inside another # generic type: type @@ -62,7 +62,7 @@ var x32 = x23.transpose echo "x23: ", x23.R, "x", x23.C, " (", x23.theArray.R, "x", x23.theArray.C, ")" echo "x32: ", x32.R, "x", x32.C, " (", x32.theArray.R, "x", x32.theArray.C, ")" - + # Output: # x23: 2x3 (2x3) # x32: 3x2 (3x2) <--- this is incorrect. R and C do not match! diff --git a/tests/generics/twrong_floatlit_type.nim b/tests/generics/twrong_floatlit_type.nim index 2db8b4353..c1830cd5a 100644 --- a/tests/generics/twrong_floatlit_type.nim +++ b/tests/generics/twrong_floatlit_type.nim @@ -35,48 +35,48 @@ proc translation*[T](p: Vector2D[T]): Matrix2x3[T] = proc scale*[T](v: Vector2D[T]): Matrix2x3[T] = Matrix2x3[T]([v.x, T(0.0), T(0.0), T(0.0), v.y, T(0.0)]) -proc rotation*[T](th: T): Matrix2x3[T] = - let +proc rotation*[T](th: T): Matrix2x3[T] = + let c = T(cos(th.float)) s = T(sin(th.float)) - + Matrix2x3[T]([c, -s, T(0.0), s, c, T(0.0)]) - -proc `*`*[T](a, b: Matrix2x3[T]): Matrix2x3[T] = + +proc `*`*[T](a, b: Matrix2x3[T]): Matrix2x3[T] = # Here we pretend that row 3 is [0,0,0,1] without # actually storing it in the matrix. - Matrix2x3[T]([a.M11*b.M11 + a.M12*b.M21, - a.M11*b.M12 + a.M12*b.M22, - a.M11*b.M13 + a.M12*b.M23 + a.M13, - + Matrix2x3[T]([a.M11*b.M11 + a.M12*b.M21, + a.M11*b.M12 + a.M12*b.M22, + a.M11*b.M13 + a.M12*b.M23 + a.M13, + a.M21*b.M11 + a.M22*b.M21, a.M21*b.M12 + a.M22*b.M22, a.M21*b.M13 + a.M22*b.M23 + a.M23]) - -proc `*`*[T](a: Matrix2x3[T], p: Point2D[T]): Point2D[T] = - let + +proc `*`*[T](a: Matrix2x3[T], p: Point2D[T]): Point2D[T] = + let x = a.M11*p.x + a.M12*p.y + a.M13 y = a.M21*p.x + a.M22*p.y + a.M23 - + Point2D[T](x: x, y: y) - + # making these so things like "line" that need a constructor don't stick out. # 2x2 determinant: |a b| # |c d| = ad - bc - + # String rendering # -template ff[S](x: S): string = +template ff[S](x: S): string = formatFloat(float(x), ffDefault, 0) - -proc `$`*[S](p: Point2D[S]): string = + +proc `$`*[S](p: Point2D[S]): string = "P($1, $2)" % [ff(p.x), ff(p.y)] - -proc `$`*[S](p: Vector2D[S]): string = + +proc `$`*[S](p: Vector2D[S]): string = "V($1, $2)" % [ff(p.x), ff(p.y)] - + proc `$`*[S](m: Matrix2x3[S]): string = - "M($1 $2 $3/$4 $5 $6)" % [ff(m.M11), ff(m.M12), ff(m.M13), + "M($1 $2 $3/$4 $5 $6)" % [ff(m.M11), ff(m.M12), ff(m.M13), ff(m.M21), ff(m.M22), ff(m.M23)] # @@ -102,7 +102,7 @@ proc `/`*[S](v: Vector2D[S], sc: S): Vector2D[S] = proc `/`*[S](sc: S; v: Vector2D[S]): Vector2D[S] = Vector2D[S](x: sc/v.x, y: sc/v.y) -proc `/`*[S](a, b: Vector2D[S]): Vector2D[S] = +proc `/`*[S](a, b: Vector2D[S]): Vector2D[S] = Vector2D[S](x: a.x/b.x, y: a.y/b.y) #proc vec[S](x, y: S): Vector2D[S] proc vec[S](x, y: S): Vector2D[S] = diff --git a/tests/generics/twrong_generic_object.nim b/tests/generics/twrong_generic_object.nim new file mode 100644 index 000000000..00d90c55e --- /dev/null +++ b/tests/generics/twrong_generic_object.nim @@ -0,0 +1,21 @@ +discard """ + errormsg: "cannot instantiate: 'GenericNodeObj'" + line: 21 +""" +# bug #2509 +type + GenericNodeObj[T] = ref object + obj: T + + Node* = ref object + children*: seq[Node] + parent*: Node + + nodeObj*: GenericNodeObj # [int] + +proc newNode*(nodeObj: GenericNodeObj): Node = + result = Node(nodeObj: nodeObj) + newSeq(result.children, 10) + +var genericObj = GenericNodeObj[int]() +var myNode = newNode(genericObj) |