IChan

Type Members

case class Nil(signal: Signal) extends IChan[Nothing] with Product with Serializable

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def apply(r: Range): IChan[Int]
def apply[A](a: A, as: A*)(implicit arg0: Message[A]): IChan[A]

Creates a stream with the specified elements.
Creates a stream with the specified elements.
A
the type of the stream's elements
a
the first elements of the created stream
as
the remaining elements of the created stream
returns
a new stream with the elements passed as parameters
def apply[A](seg: Seg[A], signal: Signal)(implicit arg0: Message[A]): IChan[A]

Create a channel that returns a single segment.
Create a channel that returns a single segment.
A
the type of the messages carried by the input channel.
seg
the segment read on the channel.
signal
the termination signal.
returns
an input channel that contains a single segment.
def apply[A](a: A, tail: ⇒ IChan[A])(implicit arg0: Message[A]): IChan[A]

Create an input channel that generates data lazily out of main memory.
Create an input channel that generates data lazily out of main memory.
A
the type of the messages carried by the input channel.
a
the first message read on the channel.
tail
the remainder of the channel.
returns
an input channel with a segment prepended.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def bind[A](first: IChan[A], next: (A, Signal) ⇒ IChan[A])(implicit arg0: Message[A]): IChan[A]
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def cons[A](seg: Seg[A], tail: ⇒ IChan[A])(implicit arg0: Message[A]): IChan[A]

Create a, input channel that generates data lazily out of main memory.
Create a, input channel that generates data lazily out of main memory.
A
the type of the messages carried by the input channel.
seg
the segment to prepend to the channel.
tail
the original input channel.
returns
an input channel with a segment prepended.
def cons_![A](seg: Seg[A], tail: IChan[A])(implicit arg0: Message[A]): IChan[A]

Prepend a segment in front of an existing input channel.
Prepend a segment in front of an existing input channel.
A
the type of the messages carried by the input channel.
seg
the segment to prepend to the channel.
tail
the original input channel.
returns
an input channel with a segment prepended.
def continually[A](elem: ⇒ A)(implicit arg0: Message[A]): IChan[A]

Create an infinite stream containing the given element expression (which is computed for each occurrence)
Create an infinite stream containing the given element expression (which is computed for each occurrence)
elem
the element composing the resulting stream
returns
the stream containing an infinite number of elem // TODO add iterator seg
def empty[A]: IChan[A]

Construct a input channel that terminates immediately with EOS
Construct a input channel that terminates immediately with EOS
A
the type of the messages carried by the input channel.
returns
An input channel that terminates immediately.
def empty[A](signal: Signal): IChan[A]

Construct a input channel that terminates immediately with a signal
Construct a input channel that terminates immediately with a signal
A
the type of the messages carried by the input channel.
signal
the termination signal.
returns
An input channel that terminates immediately.
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def fill[A](n: Int)(elem: ⇒ A)(implicit arg0: Message[A]): IChan[A]

Create an stream of fixed size containing the given element expression which is computed at the time the channel is read
Create an stream of fixed size containing the given element expression which is computed at the time the channel is read
elem
the element composing the resulting stream
returns
the stream containing an infinite number of elem
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def from(start: Int): IChan[Int]

Create an infinite stream starting at start and incrementing by 1.
Create an infinite stream starting at start and incrementing by 1.
start
the start value of the stream
returns
the stream starting at value start.
def from(start: Int, step: Int): IChan[Int]

Create an infinite stream starting at start and incrementing by step step
Create an infinite stream starting at start and incrementing by step step
start
the start value of the stream
step
the increment value of the stream
returns
the stream starting at value start.
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
implicit def ichanIsMessage[A]: Message[IChan[A]]
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def iterate[A](start: A)(f: (A) ⇒ A)(implicit arg0: Message[A]): IChan[A]

An infinite stream that repeatedly applies a given function to a start value.
An infinite stream that repeatedly applies a given function to a start value.
start
the start value of the stream
f
the function that's repeatedly applied
returns
the stream returning the infinite sequence of values start, f(start), f(f(start)), ...
def lazily[A](elem: ⇒ A): IChan[A]

Create an infinite stream containing the given element expression which is computed at the time the channel is read.
Create an infinite stream containing the given element expression which is computed at the time the channel is read. Contrarily to continually, this channels emits one message at a time.
elem
the element composing the resulting stream
returns
the stream containing an infinite number of elem
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def source[A](as: Traversable[A], sst: Int = SST)(implicit arg0: Message[A]): IChan[A]
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tabulate[A](n: Int)(f: (Int) ⇒ A)(implicit arg0: Message[A]): IChan[A]

Produces a stream containing values of a given function over a range of integer values starting from 0.
Produces a stream containing values of a given function over a range of integer values starting from 0.
n
The number of elements to generate.
f
The function computing element values
returns
A new stream consisting of elements f(0), ..., f(n -1)
def toString(): String

Definition Classes
AnyRef → Any
def unapply(ichan: IChan[_]): Option[Signal]
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Docs: trait IChan | package channel

object IChan

Type Members

case class Nil(signal: Signal) extends IChan[Nothing] with Product with Serializable

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def apply(r: Range): IChan[Int]

def apply[A](a: A, as: A*)(implicit arg0: Message[A]): IChan[A]

def apply[A](seg: Seg[A], signal: Signal)(implicit arg0: Message[A]): IChan[A]

def apply[A](a: A, tail: ⇒ IChan[A])(implicit arg0: Message[A]): IChan[A]

final def asInstanceOf[T0]: T0

def bind[A](first: IChan[A], next: (A, Signal) ⇒ IChan[A])(implicit arg0: Message[A]): IChan[A]

def clone(): AnyRef

def cons[A](seg: Seg[A], tail: ⇒ IChan[A])(implicit arg0: Message[A]): IChan[A]

def cons_![A](seg: Seg[A], tail: IChan[A])(implicit arg0: Message[A]): IChan[A]

def continually[A](elem: ⇒ A)(implicit arg0: Message[A]): IChan[A]

def empty[A]: IChan[A]

def empty[A](signal: Signal): IChan[A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def fill[A](n: Int)(elem: ⇒ A)(implicit arg0: Message[A]): IChan[A]

def finalize(): Unit

def from(start: Int): IChan[Int]

def from(start: Int, step: Int): IChan[Int]

final def getClass(): Class[_]

def hashCode(): Int

implicit def ichanIsMessage[A]: Message[IChan[A]]

final def isInstanceOf[T0]: Boolean

def iterate[A](start: A)(f: (A) ⇒ A)(implicit arg0: Message[A]): IChan[A]

def lazily[A](elem: ⇒ A): IChan[A]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def source[A](as: Traversable[A], sst: Int = SST)(implicit arg0: Message[A]): IChan[A]

final def synchronized[T0](arg0: ⇒ T0): T0

def tabulate[A](n: Int)(f: (Int) ⇒ A)(implicit arg0: Message[A]): IChan[A]

def toString(): String

def unapply(ichan: IChan[_]): Option[Signal]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from AnyRef

Inherited from Any

Ungrouped