renaming: AsyncResultIterator => AsyncResultIter to have it consistent with other iterators

Author: marcinczenko

codex/erasure/erasure.nim

@@ -121,13 +121,13 @@ func indexToPos(steps, idx, step: int): int {.inline.} =
 
 proc getPendingBlocks(
     self: Erasure, manifest: Manifest, indices: seq[int]
-): AsyncResultIterator[(?!bt.Block, int)] =
+): AsyncResultIter[(?!bt.Block, int)] =
   ## Get pending blocks iterator
   ##
 
   if indices.len == 0:
     trace "No indices to fetch blocks for", treeCid = manifest.treeCid
-    return AsyncResultIterator[(?!bt.Block, int)].empty()
+    return AsyncResultIter[(?!bt.Block, int)].empty()
 
   var pendingBlocks: seq[Future[(?!bt.Block, int)].Raising([CancelledError])] = @[]
 
@@ -162,8 +162,8 @@ proc getPendingBlocks(
       # but we check for that at the very beginning - 
       # thus, if this happens, we raise an assert
       raiseAssert("fatal: pendingBlocks is empty - this should never happen")
-  
-  AsyncResultIterator[(?!bt.Block, int)].new(genNext, isFinished)
+
+  AsyncResultIter[(?!bt.Block, int)].new(genNext, isFinished)
 
 proc prepareEncodingData(
     self: Erasure,

codex/stores/blockstore.nim

@@ -154,9 +154,7 @@ method hasBlock*(
 
 method listBlocks*(
     self: BlockStore, blockType = BlockType.Manifest
-): Future[?!AsyncResultIterator[Cid]] {.
-    base, async: (raises: [CancelledError]), gcsafe
-.} =
+): Future[?!AsyncResultIter[Cid]] {.base, async: (raises: [CancelledError]), gcsafe.} =
   ## Get the list of blocks in the BlockStore. This is an intensive operation
   ##
 

codex/stores/cachestore.nim

@@ -139,7 +139,7 @@ func cids(self: CacheStore): (iterator (): Cid {.gcsafe, raises: [].}) =
 
 method listBlocks*(
     self: CacheStore, blockType = BlockType.Manifest
-): Future[?!AsyncResultIterator[Cid]] {.async: (raises: [CancelledError]).} =
+): Future[?!AsyncResultIter[Cid]] {.async: (raises: [CancelledError]).} =
   ## Get the list of blocks in the BlockStore. This is an intensive operation
   ##
 
@@ -152,7 +152,7 @@ method listBlocks*(
     success(cids())
 
   let iter = await (
-    AsyncResultIterator[Cid].new(genNext, isFinished).filter(
+    AsyncResultIter[Cid].new(genNext, isFinished).filter(
       proc(cid: ?!Cid): Future[bool] {.async: (raises: [CancelledError]).} =
         without cid =? cid, err:
           trace "Cannot get Cid from the iterator", err = err.msg

codex/stores/maintenance.nim

@@ -18,7 +18,7 @@ import pkg/questionable/results
 
 import ./repostore
 import ../utils/timer
-import ../utils/asyncresultiterator
+import ../utils/asyncresultiter
 import ../clock
 import ../logutils
 import ../systemclock

codex/stores/networkstore.nim

@@ -19,7 +19,7 @@ import ../blockexchange
 import ../logutils
 import ../merkletree
 import ../utils/asyncheapqueue
-import ../utils/asyncresultiterator
+import ../utils/asyncresultiter
 import ./blockstore
 
 export blockstore, blockexchange, asyncheapqueue
@@ -127,7 +127,7 @@ method ensureExpiry*(
 
 method listBlocks*(
     self: NetworkStore, blockType = BlockType.Manifest
-): Future[?!AsyncResultIterator[Cid]] {.async: (raw: true, raises: [CancelledError]).} =
+): Future[?!AsyncResultIter[Cid]] {.async: (raw: true, raises: [CancelledError]).} =
   self.localStore.listBlocks(blockType)
 
 method delBlock*(

codex/stores/queryiterhelper.nim

@@ -4,16 +4,16 @@ import pkg/chronos
 import pkg/chronicles
 import pkg/datastore/typedds
 
-import ../utils/asyncresultiterator
+import ../utils/asyncresultiter
 
 {.push raises: [].}
 
 type KeyVal*[T] = tuple[key: Key, value: T]
 
-proc toAsyncResultIterator*[T](
+proc toAsyncResultIter*[T](
     queryIter: QueryIter[T], finishOnErr: bool = true
-): Future[?!AsyncResultIterator[QueryResponse[T]]] {.async: (raises: [CancelledError]).} =
-  ## Converts `QueryIter[T]` to `AsyncResultIterator[QueryResponse[T]]` and automatically
+): Future[?!AsyncResultIter[QueryResponse[T]]] {.async: (raises: [CancelledError]).} =
+  ## Converts `QueryIter[T]` to `AsyncResultIter[QueryResponse[T]]` and automatically
   ## runs dispose whenever `QueryIter` finishes or whenever an error occurs (only
   ## if the flag finishOnErr is set to true)
   ##
@@ -22,7 +22,7 @@ proc toAsyncResultIterator*[T](
     trace "Disposing iterator"
     if error =? (await queryIter.dispose()).errorOption:
       return failure(error)
-    return success(AsyncResultIterator[QueryResponse[T]].empty())
+    return success(AsyncResultIter[QueryResponse[T]].empty())
 
   var errOccurred = false
 
@@ -42,11 +42,11 @@ proc toAsyncResultIterator*[T](
   proc isFinished(): bool =
     queryIter.finished
 
-  AsyncResultIterator[QueryResponse[T]].new(genNext, isFinished).success
+  AsyncResultIter[QueryResponse[T]].new(genNext, isFinished).success
 
 proc filterSuccess*[T](
-    iter: AsyncResultIterator[QueryResponse[T]]
-): Future[AsyncResultIterator[tuple[key: Key, value: T]]] {.
+    iter: AsyncResultIter[QueryResponse[T]]
+): Future[AsyncResultIter[tuple[key: Key, value: T]]] {.
     async: (raises: [CancelledError])
 .} =
   ## Filters out any items that are not success

codex/stores/repostore/store.nim

@@ -295,12 +295,12 @@ method hasBlock*(
 
 method listBlocks*(
     self: RepoStore, blockType = BlockType.Manifest
-): Future[?!AsyncResultIterator[Cid]] {.async: (raises: [CancelledError]).} =
+): Future[?!AsyncResultIter[Cid]] {.async: (raises: [CancelledError]).} =
   ## Get the list of blocks in the RepoStore.
   ## This is an intensive operation
   ##
 
-  var iter = AsyncResultIterator[Cid]()
+  var iter = AsyncResultIter[Cid]()
 
   let key =
     case blockType
@@ -346,7 +346,7 @@ proc blockRefCount*(self: RepoStore, cid: Cid): Future[?!Natural] {.async.} =
 
 method getBlockExpirations*(
     self: RepoStore, maxNumber: int, offset: int
-): Future[?!AsyncResultIterator[BlockExpiration]] {.
+): Future[?!AsyncResultIter[BlockExpiration]] {.
     async: (raises: [CancelledError]), base, gcsafe
 .} =
   ## Get iterator with block expirations
@@ -360,11 +360,11 @@ method getBlockExpirations*(
     error "Unable to execute block expirations query", err = err.msg
     return failure(err)
 
-  without asyncQueryIter =? (await queryIter.toAsyncResultIterator()), err:
+  without asyncQueryIter =? (await queryIter.toAsyncResultIter()), err:
     error "Unable to convert QueryIter to AsyncIter", err = err.msg
     return failure(err)
 
-  let filteredIter: AsyncResultIterator[KeyVal[BlockMetadata]] =
+  let filteredIter: AsyncResultIter[KeyVal[BlockMetadata]] =
     await asyncQueryIter.filterSuccess()
 
   proc mapping(

codex/utils.nim

@@ -19,9 +19,9 @@ import pkg/chronos
 import ./utils/asyncheapqueue
 import ./utils/fileutils
 import ./utils/iter
-import ./utils/asyncresultiterator
+import ./utils/asyncresultiter
 
-export asyncheapqueue, fileutils, iter, asyncresultiterator, chronos
+export asyncheapqueue, fileutils, iter, asyncresultiter, chronos
 
 when defined(posix):
   import os, posix

codex/utils/asynciter.nim

@@ -40,11 +40,9 @@ import ./iter
 ## - empty - to create an empty async iterator (AsyncIter)
 
 type
-  AsyncIterFunc[T, U] =
-    proc(fut: T): Future[U] {.async.}
+  AsyncIterFunc[T, U] = proc(fut: T): Future[U] {.async.}
   AsyncIterIsFinished = proc(): bool {.raises: [], gcsafe.}
-  AsyncIterGenNext[T] =
-    proc(): Future[T] {.async.}
+  AsyncIterGenNext[T] = proc(): Future[T] {.async.}
 
   AsyncIter*[T] = ref object
     finished: bool
@@ -218,4 +216,4 @@ proc empty*[T](_: type AsyncIter[T]): AsyncIter[T] =
   proc isFinished(): bool =
     true
 
-  AsyncIter[T].new(genNext, isFinished)
+  AsyncIter[T].new(genNext, isFinished)