DeferredChannel(pid::Integer=myid(), num::Integer=1; content::DataType=Any) -> DeferredChannel

Create a DeferredChannel with a reference to a remote channel of a specific size and type. f() is a function that when executed on pid must return an implementation of an AbstractChannel.

The default pid is the current process.

DeferredChannel(pid::Integer=myid(), num::Integer=1; content::DataType=Any) -> DeferredChannel

Create a DeferredChannel. The default pid is the current process. When initialized, the DeferredChannel will reference a Channel{content}(num) on process pid.

Note that the data in the DeferredChannel will still be located wherever the first piece of data was put! from. The pid argument controls where the outermost reference to that data is located.

DeferredFuture(pid::Integer=myid()) -> DeferredFuture

Create a DeferredFuture on process pid. The default pid is the current process.

Note that the data in the DeferredFuture will still be located wherever it was put! from. The pid argument controlls where the outermost reference to that data is located.

DeferredRemoteRef is the common supertype of DeferredFuture and DeferredChannel and is the counterpart of Distributed.AbstractRemoteRef.

reset!{T<:DeferredRemoteRef}(ref::T) -> T

Removes any data from the DeferredRemoteRef and allows it to be reinitialized with data.

Returns the input DeferredRemoteRef.

@defer Future(...)
@defer RemoteChannel(...)

@defer transforms a Future or RemoteChannel construction into a 'DeferredFuture' or 'DeferredChannel' construction.

close(ref::DeferredChannel)

Closes a DeferredChannel. An exception is thrown by:

• put! on a closed DeferredChannel
• take! and fetch on an empty, closed DeferredChannel

fetch(ref::DeferredRemoteRef) -> Any

Wait for and get the value of a remote reference.

isready(ref::DeferredRemoteRef) -> Bool

Determine whether a DeferredRemoteRef has a value stored to it. Note that this function can cause race conditions, since by the time you receive its result it may no longer be true.

put!(rr::DeferredChannel, val) -> DeferredChannel

Store a value to the DeferredChannel. If the channel is full, blocks until space is available. Returns its first argument.

put!(ref::DeferredFuture, v) -> DeferredFuture

Store a value to a DeferredFuture. DeferredFutures, like Futures, are write-once remote references. A put! on an already set DeferredFuture throws an Exception. Returns its first argument.

show(io::IO, ref::DeferredChannel)

Print a simplified string representation of the DeferredChannel with its RemoteChannel parameters and its function.

show(io::IO, ref::DeferredFuture)

Print a simplified string representation of the DeferredFuture with its RemoteChannel parameters.

take!(ref::DeferredChannel, args...)

Fetch value(s) from a DeferredChannel, removing the value(s) in the processs. Note that take! passes through args... to the innermost AbstractChannel and the default Channel accepts no args....

wait(ref::DeferredRemoteRef) -> DeferredRemoteRef

Block the current task until a value becomes available on the DeferredRemoteRef. Returns its first argument.

finalize_ref(ref::DeferredRemoteRef)

This finalizer is attached to both DeferredFuture and DeferredChannel on construction and finalizes the inner and outer RemoteChannels.

For more information on finalizing remote references, see the Julia manual^[1].

serialize(s::AbstractSerializer, ref::DeferredChannel)

Serialize a DeferredChannel such that it can de deserialized by deserialize in a cluster.

serialize(s::AbstractSerializer, ref::DeferredFuture)

Serialize a DeferredFuture such that it can de deserialized by deserialize in a cluster.