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

use single backtick (#17166)

Browse source
This commit is contained in:
flywind 2021-02-23 23:05:39 -06:00 • committed by GitHub
commit 47c078e29c
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
12 changed files with 305 additions and 305 deletions
Download patch file Download diff file Expand all files Collapse all files

76
lib/pure/asyncfutures.nim
View file

@ -86,19 +86,19 @@ when isFutureLoggingEnabled:
var callSoonProc {.threadvar.}: proc (cbproc: proc ()) {.gcsafe.}
proc getCallSoonProc*(): (proc(cbproc: proc ()) {.gcsafe.}) =
## Get current implementation of ``callSoon``.
## Get current implementation of `callSoon`.
return callSoonProc
proc setCallSoonProc*(p: (proc(cbproc: proc ()) {.gcsafe.})) =
## Change current implementation of ``callSoon``. This is normally called when dispatcher from ``asyncdispatcher`` is initialized.
## Change current implementation of `callSoon`. This is normally called when dispatcher from `asyncdispatcher` is initialized.
callSoonProc = p
proc callSoon*(cbproc: proc ()) =
## Call ``cbproc`` "soon".
## Call `cbproc` "soon".
##
## If async dispatcher is running, ``cbproc`` will be executed during next dispatcher tick.
## If async dispatcher is running, `cbproc` will be executed during next dispatcher tick.
##
## If async dispatcher is not running, ``cbproc`` will be executed immediately.
## If async dispatcher is not running, `cbproc` will be executed immediately.
if callSoonProc.isNil:
# Loop not initialized yet. Call the function directly to allow setup code to use futures.
cbproc()
@ -117,29 +117,29 @@ template setupFutureBase(fromProc: string) =
proc newFuture*[T](fromProc: string = "unspecified"): owned(Future[T]) =
## Creates a new future.
##
## Specifying ``fromProc``, which is a string specifying the name of the proc
## Specifying `fromProc`, which is a string specifying the name of the proc
## that this future belongs to, is a good habit as it helps with debugging.
setupFutureBase(fromProc)
when isFutureLoggingEnabled: logFutureStart(result)
proc newFutureVar*[T](fromProc = "unspecified"): owned(FutureVar[T]) =
## Create a new ``FutureVar``. This Future type is ideally suited for
## Create a new `FutureVar`. This Future type is ideally suited for
## situations where you want to avoid unnecessary allocations of Futures.
##
## Specifying ``fromProc``, which is a string specifying the name of the proc
## Specifying `fromProc`, which is a string specifying the name of the proc
## that this future belongs to, is a good habit as it helps with debugging.
let fo = newFuture[T](fromProc)
result = typeof(result)(fo)
when isFutureLoggingEnabled: logFutureStart(Future[T](result))
proc clean*[T](future: FutureVar[T]) =
## Resets the ``finished`` status of ``future``.
## Resets the `finished` status of `future`.
Future[T](future).finished = false
Future[T](future).error = nil
proc checkFinished[T](future: Future[T]) =
## Checks whether `future` is finished. If it is then raises a
## ``FutureError``.
## `FutureError`.
when not defined(release):
if future.finished:
var msg = ""
@ -190,7 +190,7 @@ proc add(callbacks: var CallbackList, function: CallbackFunc) =
last.next = newCallback
proc complete*[T](future: Future[T], val: T) =
## Completes ``future`` with value ``val``.
## Completes `future` with value `val`.
#assert(not future.finished, "Future already finished, cannot finish twice.")
checkFinished(future)
assert(future.error == nil)
@ -200,7 +200,7 @@ proc complete*[T](future: Future[T], val: T) =
when isFutureLoggingEnabled: logFutureFinish(future)
proc complete*(future: Future[void]) =
## Completes a void ``future``.
## Completes a void `future`.
#assert(not future.finished, "Future already finished, cannot finish twice.")
checkFinished(future)
assert(future.error == nil)
@ -209,7 +209,7 @@ proc complete*(future: Future[void]) =
when isFutureLoggingEnabled: logFutureFinish(future)
proc complete*[T](future: FutureVar[T]) =
## Completes a ``FutureVar``.
## Completes a `FutureVar`.
template fut: untyped = Future[T](future)
checkFinished(fut)
assert(fut.error == nil)
@ -218,7 +218,7 @@ proc complete*[T](future: FutureVar[T]) =
when isFutureLoggingEnabled: logFutureFinish(Future[T](future))
proc complete*[T](future: FutureVar[T], val: T) =
## Completes a ``FutureVar`` with value ``val``.
## Completes a `FutureVar` with value `val`.
##
## Any previously stored value will be overwritten.
template fut: untyped = Future[T](future)
@ -230,7 +230,7 @@ proc complete*[T](future: FutureVar[T], val: T) =
when isFutureLoggingEnabled: logFutureFinish(future)
proc fail*[T](future: Future[T], error: ref Exception) =
## Completes ``future`` with ``error``.
## Completes `future` with `error`.
#assert(not future.finished, "Future already finished, cannot finish twice.")
checkFinished(future)
future.finished = true
@ -247,7 +247,7 @@ proc clearCallbacks*(future: FutureBase) =
proc addCallback*(future: FutureBase, cb: proc() {.closure, gcsafe.}) =
## Adds the callbacks proc to be called when the future completes.
##
## If future has already completed then ``cb`` will be called immediately.
## If future has already completed then `cb` will be called immediately.
assert cb != nil
if future.finished:
callSoon(cb)
@ -258,7 +258,7 @@ proc addCallback*[T](future: Future[T],
cb: proc (future: Future[T]) {.closure, gcsafe.}) =
## Adds the callbacks proc to be called when the future completes.
##
## If future has already completed then ``cb`` will be called immediately.
## If future has already completed then `cb` will be called immediately.
future.addCallback(
proc() =
cb(future)
@ -267,9 +267,9 @@ proc addCallback*[T](future: Future[T],
proc `callback=`*(future: FutureBase, cb: proc () {.closure, gcsafe.}) =
## Clears the list of callbacks and sets the callback proc to be called when the future completes.
##
## If future has already completed then ``cb`` will be called immediately.
## If future has already completed then `cb` will be called immediately.
##
## It's recommended to use ``addCallback`` or ``then`` instead.
## It's recommended to use `addCallback` or `then` instead.
future.clearCallbacks
future.addCallback cb
@ -277,7 +277,7 @@ proc `callback=`*[T](future: Future[T],
cb: proc (future: Future[T]) {.closure, gcsafe.}) =
## Sets the callback proc to be called when the future completes.
##
## If future has already completed then ``cb`` will be called immediately.
## If future has already completed then `cb` will be called immediately.
future.callback = proc () = cb(future)
proc getHint(entry: StackTraceEntry): string =
@ -359,8 +359,8 @@ proc injectStacktrace[T](future: Future[T]) =
future.error.msg = newMsg
proc read*[T](future: Future[T] | FutureVar[T]): T =
## Retrieves the value of ``future``. Future must be finished otherwise
## this function will fail with a ``ValueError`` exception.
## Retrieves the value of `future`. Future must be finished otherwise
## this function will fail with a `ValueError` exception.
##
## If the result of the future is an error then that error will be raised.
{.push hint[ConvFromXtoItselfNotNeeded]: off.}
@ -380,40 +380,40 @@ proc read*[T](future: Future[T] | FutureVar[T]): T =
raise newException(ValueError, "Future still in progress.")
proc readError*[T](future: Future[T]): ref Exception =
## Retrieves the exception stored in ``future``.
## Retrieves the exception stored in `future`.
##
## An ``ValueError`` exception will be thrown if no exception exists
## An `ValueError` exception will be thrown if no exception exists
## in the specified Future.
if future.error != nil: return future.error
else:
raise newException(ValueError, "No error in future.")
proc mget*[T](future: FutureVar[T]): var T =
## Returns a mutable value stored in ``future``.
## Returns a mutable value stored in `future`.
##
## Unlike ``read``, this function will not raise an exception if the
## Unlike `read`, this function will not raise an exception if the
## Future has not been finished.
result = Future[T](future).value
proc finished*(future: FutureBase | FutureVar): bool =
## Determines whether ``future`` has completed.
## Determines whether `future` has completed.
##
## ``True`` may indicate an error or a value. Use ``failed`` to distinguish.
## `True` may indicate an error or a value. Use `failed` to distinguish.
when future is FutureVar:
result = (FutureBase(future)).finished
else:
result = future.finished
proc failed*(future: FutureBase): bool =
## Determines whether ``future`` completed with an error.
## Determines whether `future` completed with an error.
return future.error != nil
proc asyncCheck*[T](future: Future[T]) =
## Sets a callback on ``future`` which raises an exception if the future
## Sets a callback on `future` which raises an exception if the future
## finished with an error.
##
## This should be used instead of ``discard`` to discard void futures,
## or use ``waitFor`` if you need to wait for the future's completion.
## This should be used instead of `discard` to discard void futures,
## or use `waitFor` if you need to wait for the future's completion.
assert(not future.isNil, "Future is nil")
# TODO: We can likely look at the stack trace here and inject the location
# where the `asyncCheck` was called to give a better error stack message.
@ -424,7 +424,7 @@ proc asyncCheck*[T](future: Future[T]) =
future.callback = asyncCheckCallback
proc `and`*[T, Y](fut1: Future[T], fut2: Future[Y]): Future[void] =
## Returns a future which will complete once both ``fut1`` and ``fut2``
## Returns a future which will complete once both `fut1` and `fut2`
## complete.
var retFuture = newFuture[void]("asyncdispatch.`and`")
fut1.callback =
@ -440,7 +440,7 @@ proc `and`*[T, Y](fut1: Future[T], fut2: Future[Y]): Future[void] =
return retFuture
proc `or`*[T, Y](fut1: Future[T], fut2: Future[Y]): Future[void] =
## Returns a future which will complete once either ``fut1`` or ``fut2``
## Returns a future which will complete once either `fut1` or `fut2`
## complete.
var retFuture = newFuture[void]("asyncdispatch.`or`")
proc cb[X](fut: Future[X]) =
@ -453,14 +453,14 @@ proc `or`*[T, Y](fut1: Future[T], fut2: Future[Y]): Future[void] =
proc all*[T](futs: varargs[Future[T]]): auto =
## Returns a future which will complete once
## all futures in ``futs`` complete.
## all futures in `futs` complete.
## If the argument is empty, the returned future completes immediately.
##
## If the awaited futures are not ``Future[void]``, the returned future
## If the awaited futures are not `Future[void]`, the returned future
## will hold the values of all awaited futures in a sequence.
##
## If the awaited futures *are* ``Future[void]``,
## this proc returns ``Future[void]``.
## If the awaited futures *are* `Future[void]`,
## this proc returns `Future[void]`.
when T is void:
var