Channels

See Concurrency

Channel<T>

A channel for sending and receiving values between tasks. Equivalent to Go’s chan T.

let jobs = Channel.new<int>()
task jobs.send(7)
let first = jobs.receive()Some(7), once the task sends

Channel.new()

Creates an unbuffered Channel.

impl<T> Channel<T> {
  fn new() -> Channel<T>
}

let jobs = Channel.new<int>()capacity 0, so every send waits for a receive

Channel.buffered()

Creates a Channel with room for capacity values.

impl<T> Channel<T> {
  fn buffered(capacity: int) -> Channel<T>
}

let jobs = Channel.buffered<int>(4)room for 4 values before a send waits

Channel.send()

Sends a value into the Channel. Returns true if the value was sent, false if the Channel was closed.

impl<T> Channel<T> {
  fn send(self, value: T) -> bool
}

let jobs = Channel.buffered<int>(1)
let sent = jobs.send(7)

Channel.receive()

Receives a value from the Channel, or None once it is closed and drained.

impl<T> Channel<T> {
  fn receive(self) -> Option<T>
}

let jobs = Channel.buffered<int>(1)
jobs.send(7)
let job = jobs.receive()Some(7)

Channel.split()

Splits the Channel into a Sender and a Receiver.

impl<T> Channel<T> {
  fn split(self) -> (Sender<T>, Receiver<T>)
}

let (sender, receiver) = Channel.buffered<int>(1).split()
sender.send(7)
let job = receiver.receive()Some(7)

Channel.length()

Returns the number of values waiting in the Channel buffer.

impl<T> Channel<T> {
  fn length(self) -> int
}

let jobs = Channel.buffered<int>(4)
jobs.send(7)
let queued = jobs.length()1

Channel.is_empty()

Returns true if the Channel buffer holds no values.

impl<T> Channel<T> {
  fn is_empty(self) -> bool
}

let jobs = Channel.buffered<int>(4)
let idle = jobs.is_empty()true

Channel.capacity()

Returns how many values the Channel buffer can hold.

impl<T> Channel<T> {
  fn capacity(self) -> int
}

let jobs = Channel.buffered<int>(4)
let room = jobs.capacity()4

Channel.close()

Closes the Channel. Safe to call more than once.

impl<T> Channel<T> {
  fn close(self)
}

let jobs = Channel.buffered<int>(1)
jobs.send(7)
jobs.close()

Sender<T>

The sending half of a Channel. Equivalent to Go’s chan<- T.

let (sender, _) = Channel.buffered<int>(1).split()
sender.send(7)
sender.close()

Sender.send()

Sends a value into the Channel. Returns true if the value was sent, false if the Channel was closed.

impl<T> Sender<T> {
  fn send(self, value: T) -> bool
}

let (sender, _) = Channel.buffered<int>(1).split()
let sent = sender.send(7)

Sender.length()

Returns the number of values waiting in the Channel buffer.

impl<T> Sender<T> {
  fn length(self) -> int
}

let (sender, _) = Channel.buffered<int>(4).split()
sender.send(7)
let queued = sender.length()1

Sender.is_empty()

Returns true if the Channel buffer holds no values.

impl<T> Sender<T> {
  fn is_empty(self) -> bool
}

let (sender, _) = Channel.buffered<int>(4).split()
let idle = sender.is_empty()true

Sender.capacity()

Returns how many values the Channel buffer can hold.

impl<T> Sender<T> {
  fn capacity(self) -> int
}

let (sender, _) = Channel.buffered<int>(4).split()
let room = sender.capacity()4

Sender.close()

Closes the Channel. Safe to call more than once.

impl<T> Sender<T> {
  fn close(self)
}

let (sender, _) = Channel.buffered<int>(1).split()
sender.send(7)
sender.close()

Receiver<T>

The receiving half of a Channel. Equivalent to Go’s <-chan T.

let (sender, receiver) = Channel.new<int>().split()
task sender.send(7)
let job = receiver.receive()Some(7), once the task sends

Receiver.receive()

Receives a value from the Channel, or None once it is closed and drained.

impl<T> Receiver<T> {
  fn receive(self) -> Option<T>
}

let (sender, receiver) = Channel.buffered<int>(1).split()
sender.send(7)
let job = receiver.receive()Some(7)

Receiver.length()

Returns the number of values waiting in the Channel buffer.

impl<T> Receiver<T> {
  fn length(self) -> int
}

let (sender, receiver) = Channel.buffered<int>(4).split()
sender.send(7)
let queued = receiver.length()1

Receiver.is_empty()

Returns true if the Channel buffer holds no values.

impl<T> Receiver<T> {
  fn is_empty(self) -> bool
}

let (_, receiver) = Channel.buffered<int>(4).split()
let idle = receiver.is_empty()true

Receiver.capacity()

Returns how many values the Channel buffer can hold.

impl<T> Receiver<T> {
  fn capacity(self) -> int
}

let (_, receiver) = Channel.buffered<int>(4).split()
let room = receiver.capacity()4