Add backticks and crossreferences to parallel/event docs (#19411)

Author: kshyatt

base/asyncmap.jl

@@ -11,10 +11,12 @@ If `ntasks` is unspecified, uses `max(100, nworkers())` tasks.
 For multiple collection arguments, apply `f` elementwise.
 Output is collected into `results`.
 
-Note: `next(::AsyncCollector, state) -> (nothing, state)`
+!!! note
+    `next(::AsyncCollector, state) -> (nothing, state)`
 
-Note: `for task in AsyncCollector(f, results, c...) end` is equivalent to
-`map!(f, results, c...)`.
+!!! note
+    `for task in AsyncCollector(f, results, c...) end` is equivalent to
+    `map!(f, results, c...)`.
 """
 type AsyncCollector
     f
@@ -154,10 +156,12 @@ end
 
 Apply `f` to each element of `c` using at most `ntasks` asynchronous tasks.
 If `ntasks` is unspecified, uses `max(100, nworkers())` tasks.
-For multiple collection arguments, apply f elementwise.
+For multiple collection arguments, apply `f` elementwise.
 Results are returned by the iterator as they become available.
-Note: `collect(AsyncGenerator(f, c...; ntasks=1))` is equivalent to
-`map(f, c...)`.
+
+!!! note
+    `collect(AsyncGenerator(f, c...; ntasks=1))` is equivalent to
+    `map(f, c...)`.
 """
 type AsyncGenerator
     collector::AsyncCollector
@@ -220,22 +224,22 @@ length(itr::AsyncGenerator) = length(itr.collector.enumerator)
 
 Transform collection `c` by applying `@async f` to each element.
 
-For multiple collection arguments, apply f elementwise.
+For multiple collection arguments, apply `f` elementwise.
 """
 asyncmap(f, c...) = collect(AsyncGenerator(f, c...))
 
 
 """
     asyncmap!(f, c)
 
-In-place version of `asyncmap()`.
+In-place version of [`asyncmap()`](:func:`asyncmap`).
 """
 asyncmap!(f, c) = (for x in AsyncCollector(f, c, c) end; c)
 
 
 """
     asyncmap!(f, results, c...)
 
-Like `asyncmap()`, but stores output in `results` rather returning a collection.
+Like [`asyncmap()`](:func:`asyncmap`), but stores output in `results` rather returning a collection.
 """
 asyncmap!(f, r, c1, c...) = (for x in AsyncCollector(f, r, c1, c...) end; r)

base/channels.jl

@@ -6,7 +6,8 @@ abstract AbstractChannel
     Channel{T}(sz::Int)
 
 Constructs a `Channel` with an internal buffer that can hold a maximum of `sz` objects
-of type `T`. `put!` calls on a full channel block until an object is removed with `take!`.
+of type `T`.
+[`put!`](:func:`put!`) calls on a full channel block until an object is removed with [`take!`](:func:`take!`).
 
 `Channel(0)` constructs an unbuffered channel. `put!` blocks until a matching `take!` is called.
 And vice-versa.
@@ -64,8 +65,8 @@ isbuffered(c::Channel) = c.sz_max==0 ? false : true
 
 Closes a channel. An exception is thrown by:
 
-* `put!` on a closed channel.
-* `take!` and `fetch` on an empty, closed channel.
+* [`put!`](:func:`put!`) on a closed channel.
+* [`take!`](:func:`take!`) and [`fetch`](:func:`fetch`) on an empty, closed channel.
 """
 function close(c::Channel)
     c.state = :closed
@@ -84,7 +85,7 @@ end
 
 Appends an item `v` to the channel `c`. Blocks if the channel is full.
 
-For unbuffered channels, blocks until a `take!` is performed by a different
+For unbuffered channels, blocks until a [`take!`](:func:`take!`) is performed by a different
 task.
 """
 function put!(c::Channel, v)
@@ -130,9 +131,9 @@ fetch_unbuffered(c::Channel) = throw(ErrorException("`fetch` is not supported on
 """
     take!(c::Channel)
 
-Removes and returns a value from a `Channel`. Blocks until data is available.
+Removes and returns a value from a [`Channel`](:obj:`Channel`). Blocks until data is available.
 
-For unbuffered channels, blocks until a `put!` is performed by a different
+For unbuffered channels, blocks until a [`put!`](:func:`put!`) is performed by a different
 task.
 """
 take!(c::Channel) = isbuffered(c) ? take_buffered(c) : take_unbuffered(c)
@@ -166,11 +167,11 @@ end
 """
     isready(c::Channel)
 
-Determine whether a `Channel` has a value stored to it. Returns
+Determine whether a [`Channel`](:obj:`Channel`) has a value stored to it. Returns
 immediately, does not block.
 
 For unbuffered channels returns `true` if there are tasks waiting
-on a `put!`.
+on a [`put!`](:func:`put!`).
 """
 isready(c::Channel) = n_avail(c) > 0
 n_avail(c::Channel) = isbuffered(c) ? length(c.data) : n_waiters(c.cond_put)

base/event.jl

@@ -5,9 +5,9 @@
 """
     Condition()
 
-Create an edge-triggered event source that tasks can wait for. Tasks that call `wait` on a
-`Condition` are suspended and queued. Tasks are woken up when `notify` is later called on
-the `Condition`. Edge triggering means that only tasks waiting at the time `notify` is
+Create an edge-triggered event source that tasks can wait for. Tasks that call [`wait`](:func:`wait`) on a
+`Condition` are suspended and queued. Tasks are woken up when [`notify`](:func:`notify`) is later called on
+the `Condition`. Edge triggering means that only tasks waiting at the time [`notify`](:func:`notify`) is
 called can be woken up. For level-triggered notifications, you must keep extra state to keep
 track of whether a notification has happened. The [`Channel`](:class:`Channel`) type does
 this, and so can be used for level-triggered events.
@@ -60,7 +60,7 @@ n_waiters(c::Condition) = length(c.waitq)
 """
     @schedule
 
-Wrap an expression in a `Task` and add it to the local machine's scheduler queue.
+Wrap an expression in a [`Task`](:obj:`Task`) and add it to the local machine's scheduler queue.
 """
 macro schedule(expr)
     expr = :(()->($expr))
@@ -84,11 +84,11 @@ schedule(t::Task) = enq_work(t)
 """
     schedule(t::Task, [val]; error=false)
 
-Add a task to the scheduler's queue. This causes the task to run constantly when the system
-is otherwise idle, unless the task performs a blocking operation such as `wait`.
+Add a [`Task`](:obj:`Task`) to the scheduler's queue. This causes the task to run constantly when the system
+is otherwise idle, unless the task performs a blocking operation such as [`wait`](:func:`wait`).
 
 If a second argument `val` is provided, it will be passed to the task (via the return value of
-`yieldto`) when it runs again. If `error` is `true`, the value is raised as an exception in
+[`yieldto`](:func:`yieldto`)) when it runs again. If `error` is `true`, the value is raised as an exception in
 the woken task.
 """
 function schedule(t::Task, arg; error=false)
@@ -124,7 +124,7 @@ tasks.
 yield() = (enq_work(current_task()); wait())
 
 """
-    yieldto(task, arg = nothing)
+    yieldto(t::Task, arg = nothing)
 
 Switch to the given task. The first time a task is switched to, the task's function is
 called with no arguments. On subsequent switches, `arg` is returned from the task's last
@@ -203,10 +203,11 @@ end
 """
     AsyncCondition()
 
-Create a async condition that wakes up tasks waiting for it (by calling `wait` on the object)
-when notified from C by a call to uv_async_send.
-Waiting tasks are woken with an error when the object is closed (by `close`).
-Use `isopen` to check whether it is still active.
+Create a async condition that wakes up tasks waiting for it
+(by calling [`wait`](:func:`wait`) on the object)
+when notified from C by a call to `uv_async_send`.
+Waiting tasks are woken with an error when the object is closed (by [`close`](:func:`close`).
+Use [`isopen`](:func:`isopen`) to check whether it is still active.
 """
 type AsyncCondition
     handle::Ptr{Void}
@@ -277,9 +278,9 @@ end
 """
     Timer(delay, repeat=0)
 
-Create a timer that wakes up tasks waiting for it (by calling `wait` on the timer object) at
+Create a timer that wakes up tasks waiting for it (by calling [`wait`](:func:`wait`) on the timer object) at
 a specified interval.  Times are in seconds.  Waiting tasks are woken with an error when the
-timer is closed (by `close`). Use `isopen` to check whether a timer is still active.
+timer is closed (by [`close`](:func:`close`). Use [`isopen`](:func:`isopen`) to check whether a timer is still active.
 """
 type Timer
     handle::Ptr{Void}
@@ -367,7 +368,7 @@ Create a timer to call the given `callback` function. The `callback` is passed o
 the timer object itself. The callback will be invoked after the specified initial `delay`,
 and then repeating with the given `repeat` interval. If `repeat` is `0`, the timer is only
 triggered once. Times are in seconds. A timer is stopped and has its resources freed by
-calling `close` on it.
+calling [`close`](:func:`close`) on it.
 """
 function Timer(cb::Function, timeout::Real, repeat::Real=0.0)
     t = Timer(timeout, repeat)

base/managers.jl

@@ -346,7 +346,7 @@ end
 Implemented by cluster managers. For every Julia worker launched by this function, it should
 append a `WorkerConfig` entry to `launched` and notify `launch_ntfy`. The function MUST exit
 once all workers, requested by `manager` have been launched. `params` is a dictionary of all
-keyword arguments `addprocs` was called with.
+keyword arguments [`addprocs`](:func:`addprocs`) was called with.
 """
 launch
 
@@ -510,9 +510,11 @@ end
 """
     kill(manager::ClusterManager, pid::Int, config::WorkerConfig)
 
-Implemented by cluster managers. It is called on the master process, by `rmprocs`. It should
-cause the remote worker specified by `pid` to exit. `Base.kill(manager::ClusterManager.....)`
-executes a remote `exit()` on `pid`
+Implemented by cluster managers.
+It is called on the master process, by [`rmprocs`](:func:`rmprocs`).
+It should cause the remote worker specified by `pid` to exit.
+`Base.kill(manager::ClusterManager.....)` executes a remote `exit()`
+on `pid`.
 """
 function kill(manager::ClusterManager, pid::Int, config::WorkerConfig)
     remote_do(exit, pid) # For TCP based transports this will result in a close of the socket