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

sequtils refactoring: prefer typeof over type (#14212)

Browse source
This commit is contained in:
Andreas Rumpf 2020-05-04 11:18:29 +02:00 • committed by GitHub
commit a73d403901
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
1 changed files with 15 additions and 15 deletions
Download patch file Download diff file Expand all files Collapse all files

30
lib/pure/collections/sequtils.nim
View file

@ -566,7 +566,7 @@ template filterIt*(s, pred: untyped): untyped =
assert acceptable == @[-2.0, 24.5, 44.31] assert acceptable == @[-2.0, 24.5, 44.31]
assert notAcceptable == @[-272.15, 99.9, -113.44] assert notAcceptable == @[-272.15, 99.9, -113.44]
var result = newSeq[type(s[0])]() var result = newSeq[typeof(s[0])]()
for it {.inject.} in items(s): for it {.inject.} in items(s):
if pred: result.add(it) if pred: result.add(it)
result result
@ -705,7 +705,7 @@ template anyIt*(s, pred: untyped): bool =
template toSeq1(s: not iterator): untyped = template toSeq1(s: not iterator): untyped =
# overload for typed but not iterator # overload for typed but not iterator
type OutType = type(items(s)) type OutType = typeof(items(s))
when compiles(s.len): when compiles(s.len):
block: block:
evalOnceAs(s2, s, compiles((let _ = s))) evalOnceAs(s2, s, compiles((let _ = s)))
@ -726,13 +726,13 @@ template toSeq2(iter: iterator): untyped =
evalOnceAs(iter2, iter(), false) evalOnceAs(iter2, iter(), false)
when compiles(iter2.len): when compiles(iter2.len):
var i = 0 var i = 0
var result = newSeq[type(iter2)](iter2.len) var result = newSeq[typeof(iter2)](iter2.len)
for x in iter2: for x in iter2:
result[i] = x result[i] = x
inc i inc i
result result
else: else:
type OutType = type(iter2()) type OutType = typeof(iter2())
var result: seq[OutType] = @[] var result: seq[OutType] = @[]
when compiles(iter2()): when compiles(iter2()):
evalOnceAs(iter4, iter, false) evalOnceAs(iter4, iter, false)
@ -752,8 +752,8 @@ template toSeq*(iter: untyped): untyped =
let let
myRange = 1..5 myRange = 1..5
mySet: set[int8] = {5'i8, 3, 1} mySet: set[int8] = {5'i8, 3, 1}
assert type(myRange) is HSlice[system.int, system.int] assert typeof(myRange) is HSlice[system.int, system.int]
assert type(mySet) is set[int8] assert typeof(mySet) is set[int8]
let let
mySeq1 = toSeq(myRange) mySeq1 = toSeq(myRange)
@ -770,14 +770,14 @@ template toSeq*(iter: untyped): untyped =
when compiles(iter.len): when compiles(iter.len):
block: block:
evalOnceAs(iter2, iter, true) evalOnceAs(iter2, iter, true)
var result = newSeq[type(iter)](iter2.len) var result = newSeq[typeof(iter)](iter2.len)
var i = 0 var i = 0
for x in iter2: for x in iter2:
result[i] = x result[i] = x
inc i inc i
result result
else: else:
var result: seq[type(iter)] = @[] var result: seq[typeof(iter)] = @[]
for x in iter: for x in iter:
result.add(x) result.add(x)
result result
@ -815,7 +815,7 @@ template foldl*(sequence, operation: untyped): untyped =
let s = sequence let s = sequence
assert s.len > 0, "Can't fold empty sequences" assert s.len > 0, "Can't fold empty sequences"
var result: type(s[0]) var result: typeof(s[0])
result = s[0] result = s[0]
for i in 1..<s.len: for i in 1..<s.len:
let let
@ -843,7 +843,7 @@ template foldl*(sequence, operation, first): untyped =
digits = foldl(numbers, a & (chr(b + ord('0'))), "") digits = foldl(numbers, a & (chr(b + ord('0'))), "")
assert digits == "0815" assert digits == "0815"
var result: type(first) var result: typeof(first)
result = first result = first
for x in items(sequence): for x in items(sequence):
let let
@ -885,7 +885,7 @@ template foldr*(sequence, operation: untyped): untyped =
let s = sequence let s = sequence
assert s.len > 0, "Can't fold empty sequences" assert s.len > 0, "Can't fold empty sequences"
var result: type(s[0]) var result: typeof(s[0])
result = sequence[s.len - 1] result = sequence[s.len - 1]
for i in countdown(s.len - 2, 0): for i in countdown(s.len - 2, 0):
let let
@ -920,9 +920,9 @@ template mapIt*(s: typed, op: untyped): untyped =
var it{.inject.}: typeof(items(s), typeOfIter); var it{.inject.}: typeof(items(s), typeOfIter);
op), typeOfProc) op), typeOfProc)
else: else:
type OutType = type(( type OutType = typeof((
block: block:
var it{.inject.}: type(items(s)); var it{.inject.}: typeof(items(s));
op)) op))
when OutType is not (proc): when OutType is not (proc):
# Here, we avoid to create closures in loops. # Here, we avoid to create closures in loops.
@ -958,7 +958,7 @@ template mapIt*(s: typed, op: untyped): untyped =
when defined(nimHasTypeof): when defined(nimHasTypeof):
type InType = typeof(items(s), typeOfIter) type InType = typeof(items(s), typeOfIter)
else: else:
type InType = type(items(s)) type InType = typeof(items(s))
# Use a help proc `f` to create closures for each element in `s` # Use a help proc `f` to create closures for each element in `s`
let f = proc (x: InType): OutType = let f = proc (x: InType): OutType =
let it {.inject.} = x let it {.inject.} = x
@ -1004,7 +1004,7 @@ template newSeqWith*(len: int, init: untyped): untyped =
import random import random
var seqRand = newSeqWith(20, rand(10)) var seqRand = newSeqWith(20, rand(10))
var result = newSeq[type(init)](len) var result = newSeq[typeof(init)](len)
for i in 0 ..< len: for i in 0 ..< len:
result[i] = init result[i] = init
result result