Merge pull request #4 from shirleyquirk/lc_useVersion

I mean it this time

16 files changed, 367 insertions, 221 deletions

diff --git a/Makefile b/Makefile
index 2af010c..04ce4cb 100644
--- a/Makefile
+++ b/Makefile
@@ -55,7 +55,6 @@ NIM_OPTIMIZE = size
 NIM_CACHE_DIR = nimcache
 
 NIM_OPTIONS = \
-	--useVersion:'1.0' \
 	--putenv:'PROG_VERSION'="${RVERSION}" \
 	--putenv:'PROG_COPYRIGHT'="${COPYRIGHT}" \
 	--putenv:'PROG_PKGLIBDIR'="${PKGLIBDIR}" \
diff --git a/src/args.nim b/src/args.nim
index 6da84fd..cd778f6 100644
--- a/src/args.nim
+++ b/src/args.nim
@@ -1,6 +1,6 @@
 import
   options, os, posix, sequtils, sets, strutils, sugar,
-  utils, "listcomp"
+  utils
 
 type
   ArgumentType* {.pure.} = enum
@@ -104,9 +104,10 @@ proc splitArgs*(params: seq[string],
       let argsResult = toSeq(splitSingle(current[1 .. ^1], optionsWithParameter, next))
       let consumedNext = argsResult.map(a => a.consumedNext).foldl(a or b)
       let newNext = next.filter(n => not consumedNext)
-
-      return (lc[(x.key, x.value, ArgumentType.short) | (x <- argsResult), Argument],
-        newNext, stdinConsumed, false)
+      return((block:collect(newSeq):
+        for x in argsResult:
+          (x.key,x.value,ArgumentType.short)
+        ), newNext, stdinConsumed, false)
     else:
       return (@[(current, none(string), ArgumentType.target)], next, stdinConsumed, false)
 
@@ -139,7 +140,10 @@ proc splitArgs*(params: seq[string],
     discard close(0)
     discard open("/dev/tty", O_RDONLY)
 
-  lc[x | (y <- cycle.args, x <- y.arg), Argument]
+  collect(newSeq):
+    for y in cycle.args:
+      for x in y.arg:
+        x
 
 proc isShort*(arg: Argument): bool = arg.atype == ArgumentType.short
 proc isLong*(arg: Argument): bool = arg.atype == ArgumentType.long
@@ -168,8 +172,10 @@ iterator items*(op: OptionPair): OptionKey =
 proc filter*(args: seq[Argument], removeMatches: bool, keepTargets: bool,
   pairs: varargs[OptionPair]): seq[Argument] =
   let pairsSeq = @pairs
-  let argsSet = lc[x | (y <- pairsSeq, x <- y), OptionKey].toHashSet
-
+  let argsSet = collect(initHashSet):
+    for y in pairsSeq:
+      for x in y:
+        {x}
   args.filter(arg => (arg.isShort and (removeMatches xor (arg.key, false) in argsSet)) or
     (arg.isLong and (removeMatches xor (arg.key, true) in argsSet)) or
     (arg.isTarget and keepTargets))
diff --git a/src/aur.nim b/src/aur.nim
index 9b0628f..8f555cb 100644
--- a/src/aur.nim
+++ b/src/aur.nim
@@ -1,7 +1,7 @@
 import
   json, lists, options, re, sequtils, sets, strutils, sugar, tables,
   package, utils,
-  "wrapper/curl", "listcomp"
+  "wrapper/curl"
 
 type
   AurComment* = tuple[
@@ -70,9 +70,16 @@ proc getRpcPackageInfos*(pkgs: seq[string], repo: string, useTimeout: bool):
               .foldl(a & "&arg[]=" & b)
             performString(url, useTimeout)))
 
-        let table = lc[(x.name, x) | (z <- responses, y <- parseJson(z)["results"],
-          x <- parseRpcPackageInfo(y, repo)), (string, RpcPackageInfo)].toTable
-        (lc[x | (p <- pkgs, x <- table.opt(p)), RpcPackageInfo], none(string))
+        let table = collect(initTable):
+          for z in responses:
+            for y in parseJson(z)["results"]:
+              for x in parseRpcPackageInfo(y,repo):
+                {x.name:x}
+        ((block:collect(newSeq):
+          for p in pkgs:
+            for x in table.opt(p):
+              x
+        ),none(string))
       except CurlError:
         (@[], some(getCurrentException().msg))
       except JsonParsingError:
@@ -95,8 +102,11 @@ proc getAurPackageInfos*(pkgs: seq[string], repo: string, arch: string, useTimeo
             error: Option[string]
           ]
 
-        let deduplicated = lc[x.base | (x <- rpcInfos), string].deduplicate
-
+        let deduplicated = deduplicate:
+          collect(newSeq):
+            for x in rpcInfos:
+              x.base
+        
         proc obtainAndParse(base: string, index: int): ParseResult =
           let (srcInfo, operror) = obtainPkgBaseSrcInfo(base, useTimeout)
 
@@ -108,11 +118,20 @@ proc getAurPackageInfos*(pkgs: seq[string], repo: string, arch: string, useTimeo
             (pkgInfos, none(string))
 
         let parsed = deduplicated.foldl(a & obtainAndParse(b, a.len), newSeq[ParseResult]())
-        let infos = lc[x | (y <- parsed, x <- y.infos), PackageInfo]
-        let errors = lc[x | (y <- parsed, x <- y.error), string]
+        let infos = collect(newSeq):
+          for y in parsed:
+            for x in y.infos:
+              x
+        let errors = collect(newSeq):
+          for y in parsed:
+            for x in y.error:
+              x
 
         let table = infos.map(i => (i.rpc.name, i)).toTable
-        let pkgInfos = lc[x | (p <- pkgs, x <- table.opt(p)), PackageInfo]
+        let pkgInfos = collect(newSeq):
+          for p in pkgs:
+            for x in table.opt(p):
+              x
 
         let names = rpcInfos.map(i => i.name).toHashSet
         let additionalPkgInfos = infos.filter(i => not (i.rpc.name in names))
@@ -132,7 +151,10 @@ proc findAurPackages*(query: seq[string], repo: string, useTimeout: bool):
 
           let response = performString(url, useTimeout)
           let results = parseJson(response)["results"]
-          let rpcInfos = lc[x | (y <- results, x <- parseRpcPackageInfo(y, repo)), RpcPackageInfo]
+          let rpcInfos = collect(newSeq):
+            for y in results:
+              for x in parseRpcPackageInfo(y,repo):
+                x
 
           let filteredRpcInfos = if query.len > 1: (block:
               let queryLow = query[1 .. ^1].map(q => q.toLowerAscii)
diff --git a/src/common.nim b/src/common.nim
index 055474e..f7de141 100644
--- a/src/common.nim
+++ b/src/common.nim
@@ -1,7 +1,7 @@
 import
   options, os, osproc, posix, sequtils, sets, strutils, sugar, tables,
   args, config, format, lists, package, pacman, utils,
-  "wrapper/alpm", "listcomp"
+  "wrapper/alpm"
 
 type
   CacheKind* {.pure.} = enum
@@ -153,8 +153,12 @@ proc findSyncTargets*(handle: ptr AlpmHandle, dbs: seq[ptr AlpmDatabase],
         return @[]
     else:
       if allowGroups and target.reference.constraint.isNone:
-        let groupRepo = lc[d | (d <- dbs, g <- d.groups,
-          $g.name == target.reference.name), ptr AlpmDatabase].optFirst
+        let groupRepo = optFirst:
+          collect(newSeq):
+            for d in dbs:
+              for g in d.groups:
+                if $g.name == target.reference.name:
+                  d
         if groupRepo.isSome:
           return @[($groupRepo.unsafeGet.name, none(SyncFoundPackageInfo))]
 
@@ -233,25 +237,50 @@ proc queryUnrequired*(handle: ptr AlpmHandle, withOptional: bool, withoutOptiona
       installed.add(pkg.toPackageReference)
       if pkg.reason == AlpmReason.explicit:
         explicit &= $pkg.name
-      dependsTable.add($pkg.name,
-        depends.map(x => (x, false)) + optional.map(x => (x, true)))
+      dependsTable[$pkg.name]=
+        depends.map(x => (x, false)) + optional.map(x => (x, true))
       if provides.len > 0:
-        alternatives.add($pkg.name, provides)
+        alternatives[$pkg.name]= provides
 
     (installed, explicit.toHashSet + assumeExplicit, dependsTable, alternatives)
 
-  let providedBy = lc[(y, x.key) | (x <- alternatives.namedPairs, y <- x.value),
-    tuple[reference: PackageReference, name: string]]
+  let providedBy = collect(newSeq):
+    for x in alternatives.namedPairs:
+      for y in x.value:
+        (reference:y,name:x.key)
 
   proc findRequired(withOptional: bool, results: HashSet[string],
     check: HashSet[string]): HashSet[string] =
     let full = results + check
 
-    let direct = lc[x.reference | (y <- dependsTable.namedPairs, y.key in check,
-      x <- y.value, withOptional or not x.optional), PackageReference]
-
-    let indirect = lc[x.name | (y <- direct, x <- providedBy,
-      y.isProvidedBy(x.reference, true)), string].toHashSet
+    when NimVersion >= "1.3.5":
+      let direct = collect(newSeq):
+        for y in dependsTable.namedPairs:
+          if y.key in check:
+            for x in y.value:
+              if withOptional or not x.optional:
+                x.reference
+      let indirect = collect(initHashSet):
+        for y in direct:
+          for x in providedBy:
+            if y.isProvidedBy(x.reference, true):
+              {x.name}
+    else:
+      let direct = block:
+        var tmp = newSeq[PackageReference]()
+        for y in dependsTable.namedPairs:
+          if y.key in check:
+            for x in y.value:
+              if withOptional or not x.optional:
+                tmp.add(x.reference)
+        tmp
+      let indirect = block:
+        var tmp = initHashSet[string]()
+        for y in direct:
+          for x in providedBy:
+            if y.isProvidedBy(x.reference, true):
+              tmp.incl(x.name)
+        tmp
 
     let checkNext = (direct.map(p => p.name).toHashSet + indirect) - full
     if checkNext.len > 0: findRequired(withOptional, full, checkNext) else: full
@@ -484,7 +513,7 @@ proc cloneBareRepo(config: Config, bareKind: BareKind, bareName: string,
 
   if forkWait(() => (block:
     if not dropPrivileges or dropPrivileges():
-      if existsDir(repoPath):
+      if dirExists(repoPath):
         let branch = branchOption.get("master")
         execResult(gitCmd, "-C", repoPath, "fetch", "-q", "--no-tags",
           "origin", branch & ":" & branch)
@@ -622,13 +651,21 @@ proc obtainBuildPkgInfosInternal(config: Config, bases: seq[LookupBaseGroup],
           (list[tuple[pkgInfos: seq[PackageInfo], path: Option[string]]](), 0))
 
         let pkgInfosWithPaths = pkgInfosWithPathsReversed.reversed
-        let pkgInfos = lc[x | (y <- pkgInfosWithPaths, x <- y.pkgInfos), PackageInfo]
-        let paths = lc[x | (y <- pkgInfosWithPaths, x <- y.path), string]
+        let pkgInfos = collect(newSeq):
+          for y in pkgInfosWithPaths:
+            for x in y.pkgInfos:
+              x
+        let paths = collect(newSeq):
+          for y in pkgInfosWithPaths:
+            for x in y.path:
+              x
 
         let pkgInfosTable = pkgInfos.map(i => (i.rpc.name, i)).toTable
-
-        let foundPkgInfos = lc[x | (y <- pacmanTargetNames,
-          x <- pkgInfosTable.opt(y)), PackageInfo]
+        
+        let foundPkgInfos = collect(newSeq):
+          for y in pacmanTargetNames:
+            for x in pkgInfosTable.opt(y):
+              x
         let errorMessages = pacmanTargetNames
           .filter(n => not pkgInfosTable.hasKey(n))
           .map(n => tr"$#: failed to get package info" % [n])
@@ -665,7 +702,7 @@ proc cloneAurRepo*(config: Config, base: string, gitUrl: string,
 
   if message.isSome:
     (1, message)
-  elif repoPath.existsDir():
+  elif repoPath.dirExists():
     (0, none(string))
   else:
     let fullName = bareFullName(BareKind.pkg, base)
@@ -674,7 +711,7 @@ proc cloneAurRepo*(config: Config, base: string, gitUrl: string,
 
     let cloneBareCode = forkWait(() => (block:
       if not dropPrivileges or dropPrivileges():
-        if existsDir(bareRepoPath):
+        if dirExists(bareRepoPath):
           execResult(gitCmd, "-C", bareRepoPath, "fetch", "-q", "--no-tags",
             "origin", "master:master")
         else:
@@ -738,7 +775,10 @@ proc cloneAurReposWithPackageInfos*(config: Config, rpcInfos: seq[RpcPackageInfo
 
   let (fullPkgInfos, paths, errors) = cloneNext(0, nil, nil, nil)
   let pkgInfosTable = fullPkgInfos.map(i => (i.rpc.name, i)).toTable
-  let resultPkgInfos = lc[x | (y <- rpcInfos, x <- pkgInfosTable.opt(y.name)), PackageInfo]
+  let resultPkgInfos = collect(newSeq):
+    for y in rpcInfos:
+      for x in pkgInfosTable.opt(y.name):
+        x
 
   let names = rpcInfos.map(i => i.name).toHashSet
   let additionalPkgInfos = fullPkgInfos.filter(i => not (i.rpc.name in names))
diff --git a/src/config.nim b/src/config.nim
index e8be1fc..1afa89a 100644
--- a/src/config.nim
+++ b/src/config.nim
@@ -81,9 +81,9 @@ proc readConfigFile*(configFile: string):
                 table[currentCategory] = category
             elif currentCategory.len > 0:
               if line.match(re"(\w+)\ *=\ *(.*)", matches):
-                category[].add(matches[0], matches[1])
+                category[matches[0]]= matches[1]
               else:
-                category[].add(line, "")
+                category[line]=""
 
         false
       except EOFError:
diff --git a/src/feature/syncclean.nim b/src/feature/syncclean.nim
index 6b1f853..ad0c255 100644
--- a/src/feature/syncclean.nim
+++ b/src/feature/syncclean.nim
@@ -31,7 +31,7 @@ proc handleSyncClean*(args: seq[Argument], config: Config): int =
       else:
         echo(tr"removing all package repositories...")
 
-      if existsDir(reposCacheDir):
+      if dirExists(reposCacheDir):
         withAlpmConfig(config, false, handle, dbs, errors):
           for e in errors: printError(config.color, e)
 
diff --git a/src/feature/syncinfo.nim b/src/feature/syncinfo.nim
index a06c88d..6f8dda9 100644
--- a/src/feature/syncinfo.nim
+++ b/src/feature/syncinfo.nim
@@ -2,7 +2,7 @@ import
   options, posix, sequtils, strutils, sugar, tables,
   "../args", "../aur", "../common", "../config", "../format", "../package",
     "../pacman", "../utils",
-  "../wrapper/alpm", "../listcomp"
+  "../wrapper/alpm"
 
 const
   pacmanInfoStrings = [
@@ -131,7 +131,8 @@ proc handleSyncInfo*(args: seq[Argument], config: Config): int =
       let padding = pacmanInfoStrings.map(s => s.trp).computeMaxLength
       let pkgInfosTable = pkgInfos.map(i => (i.rpc.toPackageReference, i)).toTable
 
-      let codes = code & lc[handleTarget(config, padding, finalArgs, x,
-        x.rpcInfo.map(i => pkgInfosTable.opt(i.toPackageReference)).flatten) |
-        (x <- fullTargets), int]
+      let codes = code & (block:collect(newSeq):
+        for x in fullTargets:
+          handleTarget(config, padding, finalArgs, x, x.rpcInfo.map(i => pkgInfosTable.opt(i.toPackageReference)).flatten)
+        )
       codes.filter(c => c != 0).optFirst.get(0)
diff --git a/src/feature/syncinstall.nim b/src/feature/syncinstall.nim
index bb97178..813eb45 100644
--- a/src/feature/syncinstall.nim
+++ b/src/feature/syncinstall.nim
@@ -2,7 +2,7 @@ import
   algorithm, options, os, posix, sequtils, sets, strutils, sugar, tables,
   "../args", "../aur", "../config", "../common", "../format", "../lists", "../package",
     "../pacman", "../utils",
-  "../wrapper/alpm", "../listcomp"
+  "../wrapper/alpm"
 
 type
   Installed = tuple[
@@ -66,7 +66,11 @@ proc isVcs(name: string): bool =
 
 proc orderInstallation(ordered: seq[seq[seq[PackageInfo]]], grouped: seq[seq[PackageInfo]],
   satisfied: Table[PackageReference, SatisfyResult]): seq[seq[seq[PackageInfo]]] =
-  let orderedNamesSet = lc[c.rpc.name | (a <- ordered, b <- a, c <- b), string].toHashSet
+  let orderedNamesSet = collect(initHashSet):
+    for a in ordered:
+      for b in a:
+        for c in b:
+          {c.rpc.name}
 
   proc hasBuildDependency(pkgInfos: seq[PackageInfo]): bool =
     for pkgInfo in pkgInfos:
@@ -241,8 +245,13 @@ proc findDependencies(config: Config, handle: ptr AlpmHandle, dbs: seq[ptr AlpmD
     success.map(r => (r.reference, r.result.unsafeGet)) &
     aurSuccess.map(r => (r.reference, r.result.unsafeGet))).toTable
 
-  let newUnsatisfied = lc[x | (y <- aurSuccess, r <- y.result, i <- r.buildPkgInfo,
-    x <- i.allDepends), PackageReference].deduplicate
+  let newUnsatisfied = deduplicate:
+    collect(newSeq):
+      for y in aurSuccess:
+        for r in y.result:
+          for i in r.buildPkgInfo:
+            for x in i.allDepends:
+              x
 
   let newTotalAurFail = (totalAurFail & aurFail).deduplicate
   let newTotalUnsatisfied = (newUnsatisfied & newTotalAurFail).deduplicate
@@ -261,7 +270,11 @@ proc findDependencies(config: Config, handle: ptr AlpmHandle,
   (Table[PackageReference, SatisfyResult], seq[PackageReference], seq[string]) =
   let satisfied = pkgInfos.map(p => ((p.rpc.name, none(string), none(VersionConstraint)),
     (false, p.rpc.name, some(p)))).toTable
-  let unsatisfied = lc[x | (i <- pkgInfos, x <- i.allDepends), PackageReference].deduplicate
+  let unsatisfied = deduplicate:
+    collect(newSeq):
+      for i in pkgInfos:
+        for x in i.allDepends:
+          x
   findDependencies(config, handle, dbs, satisfied, unsatisfied, @[],
     additionalPkgInfos, @[], nodepsCount, assumeInstalled, printMode, noaur)
 
@@ -473,7 +486,10 @@ proc buildLoop(config: Config, pkgInfos: seq[PackageInfo], skipDeps: bool,
         else:
           resultByNames
 
-      let failedNames = lc[x.name | (x <- resultByIndices, x.pkgInfo.isNone), string]
+      let failedNames = collect(newSeq):
+        for x in resultByIndices:
+          if x.pkgInfo.isNone:
+            x.name
 
       if failedNames.len > 0:
         for name in failedNames:
@@ -563,11 +579,16 @@ proc installGroupFromSources(config: Config, commonArgs: seq[Argument],
     let arch = if pkgInfo.archs.len > 0: config.common.arch else: "any"
     config.tmpRootInitial & "/" & pkgInfo.rpc.name & "-" & pkgInfo.rpc.version & "-" & arch & ext
 
-  let allFiles = lc[(r.name, formatArchiveFile(r.pkgInfo, br.ext)) |
-    (br <- buildResults, r <- br.replacePkgInfos), tuple[name: Option[string], file: string]]
+  let allFiles = collect(newSeq):
+    for br in buildResults:
+      for r in br.replacePkgInfos:
+        (name:r.name, file:formatArchiveFile(r.pkgInfo, br.ext))
   let filesTable = allFiles.filter(f => f.name.isSome).map(f => (f.name.unsafeGet, f.file)).toTable
-  let install = lc[(i.rpc.name, x) | (g <- basePackages, i <- g, x <- filesTable.opt(i.rpc.name)),
-    tuple[name: string, file: string]]
+  let install = collect(newSeq):
+    for g in basePackages:
+      for i in g:
+        for x in filesTable.opt(i.rpc.name):
+          (name:i.rpc.name,file:x)
 
   proc handleTmpRoot(clear: bool) =
     let installFiles = install.map(p => p.file)
@@ -632,7 +653,11 @@ proc installGroupFromSources(config: Config, commonArgs: seq[Argument],
         cacheDir & $cacheUser & $cacheGroup &
         $pacmanUpgradeParams.len & pacmanUpgradeParams &
         $pacmanDatabaseParams.len & pacmanDatabaseParams &
-        lc[x | (i <- installWithReason, x <- [i.name, i.file, i.mode]), string]
+        (block:collect(newSeq):
+          for i in installWithReason:
+            for x in [i.name,i.file,i.mode]:
+              x
+        )
 
       let code = forkWait(() => execResult(installParams))
       if code != 0:
@@ -662,8 +687,11 @@ proc installGroupFromSources(config: Config, commonArgs: seq[Argument],
             run(gitCmd, "-C", bareRepoPath, "tag", tag)
 
         handleTmpRoot(true)
-        let installedAs = lc[(r.name.unsafeGet, r.pkgInfo.rpc.name) | (br <- buildResults,
-          r <- br.replacePkgInfos, r.name.isSome), (string, string)]
+        let installedAs = collect(newSeq):
+          for br in buildResults:
+            for r in br.replacePkgInfos:
+              if r.name.isSome:
+                (r.name.unsafeGet, r.pkgInfo.rpc.name)
         (installedAs, 0)
 
 proc deduplicatePkgInfos(pkgInfos: seq[PackageInfo],
@@ -695,12 +723,16 @@ proc resolveDependencies(config: Config, pkgInfos: seq[PackageInfo],
       newSeq[seq[seq[PackageInfo]]](), newSeq[string]())
   else:
     let buildAndAurNamesSet = pkgInfos.map(i => i.rpc.name).toHashSet
-    let fullPkgInfos = (pkgInfos & lc[i | (s <- satisfied.values,
-      i <- s.buildPkgInfo, not (i.rpc.name in buildAndAurNamesSet)), PackageInfo])
-      .deduplicatePkgInfos(config, false)
-
-    let additionalPacmanTargets = lc[x.name | (x <- satisfied.values,
-      not x.installed and x.buildPkgInfo.isNone), string]
+    let fullPkgInfos = (pkgInfos & (block:collect(newSeq):
+      for s in satisfied.values:
+        for i in s.buildPkgInfo:
+          if not (i.rpc.name in buildAndAurNamesSet):
+            i
+      )).deduplicatePkgInfos(config,false)
+    let additionalPacmanTargets = collect(newSeq):
+      for x in satisfied.values:
+        if not x.installed and x.buildPkgInfo.isNone:
+          x.name
     let orderedPkgInfos = orderInstallation(fullPkgInfos, satisfied)
 
     (true, satisfied, additionalPacmanTargets, orderedPkgInfos, paths)
@@ -709,16 +741,20 @@ proc confirmViewAndImportKeys(config: Config, basePackages: seq[seq[seq[PackageI
   installed: seq[Installed], noconfirm: bool): int =
   if basePackages.len > 0: (block:
     let installedVersions = installed.map(i => (i.name, i.version)).toTable
-
-    printPackages(config.color, config.common.verbosePkgLists,
-      lc[(i.rpc.name, i.rpc.repo, installedVersions.opt(i.rpc.name), i.rpc.version) |
-        (g <- basePackages, b <- g, i <- b), PackageInstallFormat]
-        .sorted((a, b) => cmp(a.name, b.name)))
+    printPackages(config.color, config.common.verbosePkgLists,(block:collect(newSeq):
+      for g in basePackages:
+        for b in g:
+          for i in b:
+            (i.rpc.name,i.rpc.repo,installedVersions.opt(i.rpc.name),i.rpc.version).PackageInstallFormat
+      ).sorted((a,b) => cmp(a.name, b.name)))
     let input = printColonUserChoice(config.color,
       tr"Proceed with building?", ['y', 'n'], 'y', 'n', noconfirm, 'y')
 
     if input == 'y':
-      let flatBasePackages = lc[x | (a <- basePackages, x <- a), seq[PackageInfo]]
+      let flatBasePackages = collect(newSeq):
+        for a in basePackages:
+          for x in a:
+            x
 
       proc checkNext(index: int, skipEdit: bool, skipKeys: bool): int =
         if index < flatBasePackages.len:
@@ -749,7 +785,11 @@ proc confirmViewAndImportKeys(config: Config, basePackages: seq[seq[seq[PackageI
           else:
             let resultPkgInfos = reloadPkgInfos(config,
               repoPath & "/" & pkgInfos[0].rpc.gitSubdir.get("."), pkgInfos)
-            let pgpKeys = lc[x | (p <- resultPkgInfos, x <- p.pgpKeys), string].deduplicate
+            let pgpKeys = deduplicate:
+              collect(newSeq):
+                for p in resultPkgInfos:
+                  for x in p.pgpKeys:
+                    x
 
             proc keysLoop(index: int, skipKeys: bool): char =
               if index >= pgpKeys.len:
@@ -890,8 +930,10 @@ proc filterIgnoresAndConflicts(config: Config, pkgInfos: seq[PackageInfo],
   targetNamesSet: HashSet[string], installed: Table[string, Installed],
   printMode: bool, noconfirm: bool): (seq[PackageInfo], seq[PackageInfo]) =
   let acceptedPkgInfos = pkgInfos.filter(pkgInfo => (block:
-    let instGroups = lc[x | (i <- installed.opt(pkgInfo.rpc.name),
-      x <- i.groups), string]
+    let instGroups = collect(newSeq):
+      for i in installed.opt(pkgInfo.rpc.name):
+        for x in i.groups:
+          x
 
     if config.ignored(pkgInfo.rpc.name, (instGroups & pkgInfo.groups).deduplicate):
       if pkgInfo.rpc.name in targetNamesSet:
@@ -908,10 +950,20 @@ proc filterIgnoresAndConflicts(config: Config, pkgInfos: seq[PackageInfo],
       true))
 
   let nonConflicingPkgInfos = acceptedPkgInfos.foldl(block:
-    let conflictsWith = lc[p | (p <- a, p.rpc.name != b.rpc.name and
-      (lc[0 | (c <- b.conflicts, c.isProvidedBy(p.rpc.toPackageReference, true)), int].len > 0 or
-        lc[0 | (c <- p.conflicts, c.isProvidedBy(b.rpc.toPackageReference, true)), int].len > 0)),
-      PackageInfo]
+    let conflictsWith = collect(newSeq):
+      for p in a:
+        if p.rpc.name != b.rpc.name and 
+            (block:collect(newSeq):
+              for c in b.conflicts:
+                if c.isProvidedBy(p.rpc.toPackageReference, true):
+                  0
+            ).len>0 or 
+            (block:collect(newSeq):
+              for c in p.conflicts:
+                if c.isProvidedBy(p.rpc.toPackageReference, true):
+                  0
+            ).len>0:
+          p
     if not printMode and conflictsWith.len > 0:
       for conflict in conflictsWith:
         printWarning(config.color,
@@ -1043,7 +1095,9 @@ proc obtainInstalledWithAur(config: Config): (seq[Installed], seq[string]) =
       ($package.name, $package.version, package.groupsSeq,
         package.reason == AlpmReason.explicit, foreign)
 
-    let installed = lc[createInstalled(p) | (p <- handle.local.packages), Installed]
+    let installed = collect(newSeq):
+      for p in handle.local.packages:
+        createInstalled(p)
     let checkAurUpgradeNames = installed
       .filter(i => i.foreign and (config.checkIgnored or not config.ignored(i.name, i.groups)))
       .map(i => i.name)
@@ -1076,7 +1130,10 @@ proc resolveBuildTargets(config: Config, syncTargets: seq[SyncPackageTarget],
   let installedTable = installed.map(i => (i.name, i)).toTable
   let rpcAurTargets = fullTargets.filter(f => f.isAurTargetFull(config.aurRepo))
 
-  let targetRpcInfos = lc[x | (t <- rpcAurTargets, x <- t.rpcInfo), RpcPackageInfo]
+  let targetRpcInfos = collect(newSeq):
+    for t in rpcAurTargets:
+      for x in t.rpcInfo:
+        x
   let targetRpcInfoNames = targetRpcInfos.map(i => i.name).toHashSet
   let rpcInfos = targetRpcInfos & upgradeRpcInfos.filter(i => not (i.name in targetRpcInfoNames))
 
@@ -1224,8 +1281,11 @@ proc handleInstall(args: seq[Argument], config: Config, syncTargets: seq[SyncPac
                           return true
                     return false
 
-                  lc[x.key | (x <- satisfied.namedPairs, not x.value.installed and
-                    x.value.buildPkgInfo.isNone and not x.key.checkSatisfied), PackageReference]
+                  collect(newSeq):
+                    for x in satisfied.namedPairs:
+                      if not x.value.installed and x.value.buildPkgInfo.isNone and
+                          not x.key.checkSatisfied:
+                        x.key
               else:
                 @[]
 
diff --git a/src/feature/syncsource.nim b/src/feature/syncsource.nim
index c050e6a..f966085 100644
--- a/src/feature/syncsource.nim
+++ b/src/feature/syncsource.nim
@@ -129,10 +129,11 @@ proc cloneAndCopy(config: Config, quiet: bool, fullTargets: seq[FullPackageTarge
         a & (pkg.base, pkg.version, b.sync.target.destination.get(pkg.base), none(string), git),
     newSeq[BaseTarget]())
 
-  let (update, terminate) = if quiet:
-      (proc (a: int, b: int) {.closure.} = discard, proc () {.closure.} = discard)
-    else:
+  let (update, terminate) = if not quiet:
       printProgressShare(config.common.progressBar, tr"cloning repositories")
+    else:
+      (proc (i0: int, i1: int) {.sideEffect,closure.} = discard, proc () {.sideEffect,closure.} = discard)
+
 
   let (results, rerrors) = cloneRepositories(config, baseTargets, update)
   terminate()
diff --git a/src/format.nim b/src/format.nim
index b8061f9..bd6d393 100644
--- a/src/format.nim
+++ b/src/format.nim
@@ -1,6 +1,6 @@
 import
   macros, options, posix, sequtils, strutils, sugar, times, unicode,
-  utils, "listcomp"
+  utils
 
 type
   PackageLineFormat* = tuple[
@@ -110,7 +110,10 @@ proc printPackageInfo*(minPadding: int, color: bool, lines: varargs[PackageLineF
     if values.len == 0:
       @[]
     elif forceBreak:
-      lc[x | (y <- values.map(s => strutils.strip(s).splitLines(lineSize)), x <- y), string]
+      collect(newSeq):
+        for y in values.map(s => strutils.strip(s).splitLines(lineSize)):
+          for x in y:
+            x
     else:
       values.map(v => strutils.strip(v)).foldl(a & "  " & b).splitLines(lineSize)
 
@@ -301,7 +304,7 @@ proc printProgressFull*(bar: bool, title: string): ((string, float) -> void, ()
 
   if not bar or width <= 0:
     echo(title, "...")
-    (proc (a: string, c: float) {.closure.} = discard, proc {.closure.} = discard)
+    (proc (a: string, c: float) {.sideEffect,closure.} = discard, proc {.sideEffect,closure.} = discard)
   else:
     let infoLen = max(width * 6 / 10, 50).int
     let progressLen = width - infoLen
@@ -311,7 +314,7 @@ proc printProgressFull*(bar: bool, title: string): ((string, float) -> void, ()
     var lastProgress = 0f
     var averageSpeed = -1f
 
-    proc update(prefix: string, progress: float) {.closure.} =
+    proc update(prefix: string, progress: float) {.sideEffect,closure.} =
       let progressTrim = max(min(1, progress + 0.005), 0)
       let progressStr = $(progressTrim * 100).int & "%"
       let paddedProgressStr = ' '.repeat(5 - progressStr.len) & progressStr
@@ -349,7 +352,7 @@ proc printProgressFull*(bar: bool, title: string): ((string, float) -> void, ()
         ' ', timeLeft, indicator, paddedProgressStr, "\x1b[0K\r")
       stdout.flushFile()
 
-    proc terminate() {.closure.} =
+    proc terminate() {.sideEffect,closure.} =
       echo()
 
     update(" ", 0)
@@ -359,7 +362,7 @@ proc printProgressFull*(bar: bool, title: string): ((string, float) -> void, ()
 proc printProgressShare*(bar: bool, title: string): ((int, int) -> void, () -> void) =
   let (updateFull, terminate) = printProgressFull(bar, title)
 
-  proc update(current: int, total: int) {.closure.} =
+  proc update(current: int, total: int) {.sideEffect,closure.} =
     let prefix = if total > 0:
         "(" & ' '.repeat(($total).len - ($current).len) & $current & "/" &
           $total & ") "
diff --git a/src/listcomp.nim b/src/listcomp.nim
deleted file mode 100644
index c9f8dc0..0000000
--- a/src/listcomp.nim
+++ /dev/null
@@ -1,69 +0,0 @@
-import macros
-
-type ListComprehension = object
-var lc* : ListComprehension
-
-template `|`*(lc: ListComprehension, comp: untyped): untyped = lc
-
-macro `[]`*(lc: ListComprehension, comp, typ: untyped): untyped =
-  ## List comprehension, returns a sequence. `comp` is the actual list
-  ## comprehension, for example ``x | (x <- 1..10, x mod 2 == 0)``. `typ` is
-  ## the type that will be stored inside the result seq.
-  ##
-  ## .. code-block:: nim
-  ##
-  ##   echo lc[x | (x <- 1..10, x mod 2 == 0), int]
-  ##
-  ##   const n = 20
-  ##   echo lc[(x,y,z) | (x <- 1..n, y <- x..n, z <- y..n, x*x + y*y == z*z),
-  ##           tuple[a,b,c: int]]
-
-  expectLen(comp, 3)
-  expectKind(comp, nnkInfix)
-  assert($comp[0] == "|")
-
-  result = newCall(
-    newDotExpr(
-      newIdentNode("result"),
-      newIdentNode("add")),
-    comp[1])
-
-  for i in countdown(comp[2].len-1, 0):
-    let x = comp[2][i]
-    expectMinLen(x, 1)
-    if x[0].kind == nnkIdent and x[0].strVal == "<-":
-      expectLen(x, 3)
-      result = newNimNode(nnkForStmt).add(x[1], x[2], result)
-    else:
-      result = newIfStmt((x, result))
-
-  result = newNimNode(nnkCall).add(
-    newNimNode(nnkPar).add(
-      newNimNode(nnkLambda).add(
-        newEmptyNode(),
-        newEmptyNode(),
-        newEmptyNode(),
-        newNimNode(nnkFormalParams).add(
-          newNimNode(nnkBracketExpr).add(
-            newIdentNode("seq"),
-            typ)),
-        newEmptyNode(),
-        newEmptyNode(),
-        newStmtList(
-          newAssignment(
-            newIdentNode("result"),
-            newNimNode(nnkPrefix).add(
-              newIdentNode("@"),
-              newNimNode(nnkBracket))),
-          result))))
-
-
-when isMainModule:
-  var a = lc[x | (x <- 1..10, x mod 2 == 0), int]
-  assert a == @[2, 4, 6, 8, 10]
-
-  const n = 20
-  var b = lc[(x,y,z) | (x <- 1..n, y <- x..n, z <- y..n, x*x + y*y == z*z),
-             tuple[a,b,c: int]]
-  assert b == @[(a: 3, b: 4, c: 5), (a: 5, b: 12, c: 13), (a: 6, b: 8, c: 10),
-(a: 8, b: 15, c: 17), (a: 9, b: 12, c: 15), (a: 12, b: 16, c: 20)]
diff --git a/src/main.nim b/src/main.nim
index 3de4a65..d8ad5a5 100644
--- a/src/main.nim
+++ b/src/main.nim
@@ -1,6 +1,6 @@
 import
   options, os, posix, re, sequtils, strutils, sugar,
-  args, config, format, pacman, utils, "listcomp"
+  args, config, format, pacman, utils
 
 import
   "feature/localquery",
@@ -11,9 +11,11 @@ import
   "feature/syncsource"
 
 proc execSudo*(args: seq[Argument]): int =
-  execResult(sudoPrefix & getAppFilename() &
-    lc[x | (y <- args, x <- y.collectArg), string])
-
+  execResult(sudoPrefix & getAppFilename() & (block:collect(newSeq):
+    for y in args:
+      for x in y.collectArg:
+        x
+    ))
 proc passValidation(args: seq[Argument], config: Config,
   nonRootArgs: openArray[OptionPair], rootArgs: openArray[OptionPair],
   opts: varargs[seq[CommandOption]]): int =
diff --git a/src/package.nim b/src/package.nim
index 612f98f..feab377 100644
--- a/src/package.nim
+++ b/src/package.nim
@@ -1,6 +1,6 @@
 import
   options, os, re, sequtils, sets, strutils, sugar, tables, utils,
-  "wrapper/alpm", "listcomp"
+  "wrapper/alpm"
 
 type
   ConstraintOperation* {.pure.} = enum
@@ -91,8 +91,14 @@ const
 
 static:
   # test only single match available
-  let osSet = lc[x | (r <- packageRepos, x <- r.os), string].toHashSet
-  let repoSet = lc[x | (r <- packageRepos, x <- r.repo), string].toHashSet
+  let osSet = collect(initHashSet):
+    for r in packageRepos:
+      for x in r.os:
+        {x}
+  let repoSet = collect(initHashSet):
+    for r in packageRepos:
+      for x in r.repo:
+        {x}
   for os in osSet:
     for repo in repoSet:
       let osValue = os
@@ -102,10 +108,14 @@ static:
           "only single matching repo available: " & os & ":" & repo)
 
   # test unique url <> bareName links
-  let bareNameToUrl = lc[(x, r.git.url) |
-    (r <- packageRepos, x <- r.git.bareName), (string, string)].toTable
-  let urlToBareName = lc[(r.git.url, x) |
-    (r <- packageRepos, x <- r.git.bareName), (string, string)].toTable
+  let bareNameToUrl = collect(initTable):
+    for r in packageRepos:
+      for x in r.git.bareName:
+        {x:r.git.url}
+  let urlToBareName = collect(initTable):
+    for r in packageRepos:
+      for x in r.git.bareName:
+        {r.git.url:x}
 
   template testBareNamesAndUrls(m1: untyped, m2: untyped) =
     for x1, x2 in m1:
@@ -262,9 +272,12 @@ proc parseSrcInfoName(repo: string, name: string, baseIndex: int, baseCount: int
   rpcInfos: seq[RpcPackageInfo], baseSeq: ref seq[SrcInfoPair], nameSeq: ref seq[SrcInfoPair],
   arch: string, gitUrl: string, gitSubdir: Option[string]): Option[PackageInfo] =
   proc collectFromPairs(pairs: seq[SrcInfoPair], keyName: string): seq[string] =
-    lc[x.value | (x <- pairs, x.key == keyName), string]
-
-  proc collect(baseOnly: bool, keyName: string): seq[string] =
+    collect(newSeq):
+      for x in pairs:
+        if x.key == keyName:
+          x.value
+  #changed the name as shadows collect macro from sugar
+  proc collectName(baseOnly: bool, keyName: string): seq[string] =
     let res = if baseOnly: @[] else: collectFromPairs(nameSeq[], keyName)
     if res.len == 0:
       collectFromPairs(baseSeq[], keyName).filter(x => x.len > 0)
@@ -272,28 +285,35 @@ proc parseSrcInfoName(repo: string, name: string, baseIndex: int, baseCount: int
       res.filter(x => x.len > 0)
 
   proc collectArch(baseOnly: bool, keyName: string): seq[PackageReference] =
-    (collect(baseOnly, keyName) & collect(baseOnly, keyName & "_" & arch))
+    (collectName(baseOnly, keyName) & collectName(baseOnly, keyName & "_" & arch))
       .map(n => parsePackageReference(n, true))
       .filter(c => c.name.len > 0)
 
   proc filterReferences(references: seq[PackageReference],
     filterWith: seq[PackageReference]): seq[PackageReference] =
     references.filter(r => filterWith.filter(w => r.isProvidedBy(w, true)).len == 0)
-
-  let base = lc[x.value | (x <- baseSeq[], x.key == "pkgbase"), string].optLast
-
-  let version = collect(true, "pkgver").optLast
-  let release = collect(true, "pkgrel").optLast
-  let epoch = collect(true, "epoch").optLast
-  let versionFull = lc[(v & "-" & r) | (v <- version, r <- release), string].optLast
-    .map(v => epoch.map(e => e & ":" & v).get(v))
-
-  let description = collect(false, "pkgdesc").optLast
-  let archs = collect(false, "arch").filter(a => a != "any")
-  let url = collect(false, "url").optLast
-  let licenses = collect(false, "license")
-  let groups = collect(false, "groups")
-  let pgpKeys = collect(true, "validpgpkeys")
+  
+  let base = optLast:
+    collect(newSeq):
+      for x in baseSeq[]:
+        if x.key == "pkgbase":
+          x.value
+
+  let version = collectName(true, "pkgver").optLast
+  let release = collectName(true, "pkgrel").optLast
+  let epoch = collectName(true, "epoch").optLast
+  let versionFull = (block:collect(newSeq):
+    for v in version:
+      for r in release:
+        (v & "-" & r)
+    ).optLast.map(v => epoch.map(e => e & ":" & v).get(v))
+
+  let description = collectName(false, "pkgdesc").optLast
+  let archs = collectName(false, "arch").filter(a => a != "any")
+  let url = collectName(false, "url").optLast
+  let licenses = collectName(false, "license")
+  let groups = collectName(false, "groups")
+  let pgpKeys = collectName(true, "validpgpkeys")
 
   let baseDepends = collectArch(true, "depends")
   let depends = collectArch(false, "depends")
@@ -308,12 +328,16 @@ proc parseSrcInfoName(repo: string, name: string, baseIndex: int, baseCount: int
 
   let info = rpcInfos.filter(i => i.name == name).optLast
 
-  lc[((repo, b, name, v, description, info.map(i => i.maintainer).flatten,
-    info.map(i => i.firstSubmitted).flatten, info.map(i => i.lastModified).flatten,
-    info.map(i => i.outOfDate).flatten, info.map(i => i.votes).get(0),
-    info.map(i => i.popularity).get(0), gitUrl, gitSubdir), baseIndex,  baseCount,
-    archs, url, licenses, groups, pgpKeys, depends, makeDepends, checkDepends,
-    optional, provides, conflicts, replaces) | (b <- base, v <- versionFull), PackageInfo].optLast
+  optLast:
+    collect(newSeq):
+      for b in base:
+        for v in versionFull:
+          ((repo, b, name, v, description, info.map(i => i.maintainer).flatten,
+          info.map(i => i.firstSubmitted).flatten, info.map(i => i.lastModified).flatten,
+          info.map(i => i.outOfDate).flatten, info.map(i => i.votes).get(0),
+          info.map(i => i.popularity).get(0), gitUrl, gitSubdir), baseIndex,  baseCount,
+          archs, url, licenses, groups, pgpKeys, depends, makeDepends, checkDepends,
+          optional, provides, conflicts, replaces)
 
 proc parseSrcInfo*(repo: string, srcInfo: string, arch: string, gitUrl: string,
   gitSubdir: Option[string], rpcInfos: seq[RpcPackageInfo] = @[]): seq[PackageInfo] =
diff --git a/src/pacman.nim b/src/pacman.nim
index 520a67e..ed80311 100644
--- a/src/pacman.nim
+++ b/src/pacman.nim
@@ -1,6 +1,6 @@
 import
   macros, options, posix, sequtils, sets, strutils, sugar, tables,
-  args, config, utils, "listcomp"
+  args, config, utils
 
 type
   OpGroup* {.pure.} = enum
@@ -36,7 +36,10 @@ proc calculateOptionsWithParameter(opts: seq[CommandOption]): seq[OptionKey] {.c
     else:
       @[]
 
-  lc[x | (y <- opts, x <- commandToSeq(y)), OptionKey]
+  collect(newSeq):
+    for y in opts:
+      for x in commandToSeq(y):
+        x
 
 proc o(long: string): CommandOption {.compileTime.} =
   ((none(string), long), false, false, {})
@@ -200,7 +203,10 @@ proc getOperation*(args: seq[Argument]): OperationType =
 proc filterOptions*(args: seq[Argument], removeMatches: bool, keepTargets: bool,
   includeOperations: bool, opts: varargs[seq[CommandOption]]): seq[Argument] =
   let optsSeq = @opts
-  let optsPairSeq = lc[x.pair | (y <- optsSeq, x <- y), OptionPair]
+  let optsPairSeq = collect(newSeq):
+    for y in optsSeq:
+      for x in y:
+        x.pair
 
   let work = if includeOperations:
       (optsPairSeq & operations.map(o => o.pair))
@@ -234,16 +240,30 @@ proc filterExtensions*(args: seq[Argument], removeMatches: bool, keepTargets: bo
   opts: varargs[seq[CommandOption]]): seq[Argument] =
   let optsSeq = @opts
   let optsFilter = if removeMatches:
-      lc[x | (y <- optsSeq, x <- y), CommandOption]
+      collect(newSeq):
+        for y in optsSeq:
+          for x in y:
+            x
     else: (block:
-      let pairs = lc[x.pair | (y <- optsSeq, x <- y), OptionPair].toHashSet
-      lc[x | (x <- allOptions, not (x.pair in pairs)), CommandOption])
-
-  let argsSeq = lc[x.pair | (x <- optsFilter, x.extension), OptionPair]
-  args.filter(removeMatches, keepTargets, argsSeq)
-
+      let pairs = collect(initHashSet):
+        for y in optsSeq:
+          for x in y:
+            {x.pair}
+      collect(newSeq):
+        for x in allOptions:
+          if not (x.pair in pairs):
+            x
+      )
+  let argsSeq = collect(newSeq):
+    for x in optsFilter:
+      if x.extension:
+        x.pair
+  args.filter(removeMatches,keepTargets,argsSeq)
 proc obtainConflictsPairs(conflicts: seq[ConflictingOptions]): Table[string, seq[OptionPair]] =
-  let all = lc[x | (y <- conflicts, x <- y.left & y.right), string].deduplicate
+  let all = collect(newSeq):
+    for y in conflicts:
+      for x in (y.left & y.right):
+        x
   all.map(c => (c, allOptions.filter(o => o.pair.long == c)
     .map(o => o.pair).deduplicate)).toTable
 
@@ -259,14 +279,32 @@ proc checkConflicts*(args: seq[Argument],
   let table = conflicts.obtainConflictsPairs
   template full(s: string): OptionPair = table[s][0]
 
-  lc[(c.left, w) | (c <- conflicts, args.check(c.left.full),
-    w <- c.right, args.check(w.full)), (string, string)].optFirst
+  when NimVersion >= "1.3.5":
+    optFirst:
+      collect(newSeq):
+        for c in conflicts:
+          if args.check(c.left.full):
+            for w in c.right:
+              if args.check(w.full):
+                (c.left,w)
+  else:
+    optFirst:
+      var tmp = newSeq[(string,string)]()
+      for c in conflicts:
+        if args.check(c.left.full):
+          for w in c.right:
+            if args.check(w.full):
+              tmp.add((c.left,w))
+      tmp
 
 proc pacmanParams*(color: bool, args: varargs[Argument]): seq[string] =
   let colorStr = if color: "always" else: "never"
   let argsSeq = ("color", some(colorStr), ArgumentType.long) &
     @args.filter(arg => not arg.matchOption(%%%"color"))
-  lc[x | (y <- argsSeq, x <- y.collectArg), string]
+  collect(newSeq):
+    for y in argsSeq:
+      for x in y.collectArg:
+        x
 
 proc pacmanExecInternal(root: bool, params: varargs[string]): int =
   let exec = if root: sudoPrefix & pacmanCmd & @params else: pacmanCmd & @params
@@ -283,7 +321,20 @@ proc pacmanRun*(root: bool, color: bool, args: varargs[Argument]): int =
 
 proc pacmanValidateAndThrow(args: varargs[tuple[arg: Argument, pass: bool]]): void =
   let argsSeq = @args
-  let collectedArgs = lc[x | (y <- argsSeq, y.pass, x <- y.arg.collectArg), string]
+  when NimVersion >= "1.3.5":
+    let collectedArgs = collect(newSeq):
+      for y in argsSeq:
+        if y.pass:
+          for x in y.arg.collectArg:
+            x
+  else:
+    let collectedArgs = block:
+      var tmp = newSeq[string]()
+      for y in argsSeq:
+       if y.pass:
+         for x in y.arg.collectArg:
+           tmp.add(x)
+      tmp
   let code = forkWait(() => pacmanExecInternal(false, "-T" & collectedArgs))
   if code != 0:
     raise haltError(code)
@@ -346,10 +397,14 @@ proc obtainPacmanConfig*(args: seq[Argument]): PacmanConfig =
 
   let debug = args.check(%%%"debug")
   let progressBar = not args.check(%%%"noprogressbar")
-  let ignorePkgs = lc[x | (y <- getAll(%%%"ignore"),
-    x <- y.split(',')), string].toHashSet
-  let ignoreGroups = lc[x | (y <- getAll(%%%"ignoregroup"),
-    x <- y.split(',')), string].toHashSet
+  let ignorePkgs = collect(initHashSet):
+    for y in getAll(%%%"ignore"):
+      for x in y.split(','):
+        {x}
+  let ignoreGroups = collect(initHashSet):
+    for y in getAll(%%%"ignoregroup"):
+      for x in y.split(','):
+        {x}
 
   let hasKeyserver = forkWaitRedirect(() => (block:
     if dropPrivileges():
diff --git a/src/utils.nim b/src/utils.nim
index 25d1b83..da9618b 100644
--- a/src/utils.nim
+++ b/src/utils.nim
@@ -211,7 +211,8 @@ proc forkWaitRedirect*(call: () -> int): tuple[output: seq[string], code: int] =
 proc getgrouplist*(user: cstring, group: Gid, groups: ptr cint, ngroups: var cint): cint
   {.importc, header: "<grp.h>".}
 
-proc setgroups*(size: int, groups: ptr cint): cint
+
+proc setgroups*(size: csize_t, groups: ptr cint): cint
   {.importc, header: "<grp.h>".}
 
 proc getUser(uid: int): User =
@@ -253,8 +254,8 @@ proc dropPrivileges*(): bool =
   if initialUser.isSome:
     let user = initialUser.unsafeGet
     var groups = user.groups.map(x => x.cint)
-
-    if setgroups(user.groups.len, addr(groups[0])) < 0:
+    
+    if setgroups(cast[csize_t](user.groups.len), addr(groups[0])) < 0:
       return false
     if setgid((Gid) user.gid) != 0:
       return false
diff --git a/src/wrapper/curl.nim b/src/wrapper/curl.nim
index 5597ef1..149f0a3 100644
--- a/src/wrapper/curl.nim
+++ b/src/wrapper/curl.nim
@@ -58,8 +58,9 @@ proc escape*(instance: ref CurlInstance, s: string): string =
   else:
     ""
 
-proc curlWriteMemory(mem: array[int.high, char], size: int, nmemb: int,
-  userdata: ref CurlInstance): int {.cdecl.} =
+proc curlWriteMemory(mem: array[csize_t.high, char], size: csize_t, nmemb: csize_t,
+  userdata: ref CurlInstance): csize_t {.cdecl.} =
+
   let total = size * nmemb
   if total > 0:
     userData.data &= mem[0 .. total - 1]