colibri/colibri/Observable

Observable

object Observable
Companion
class
class Object
trait Matchable
class Any

Type members

Classlikes

trait Connectable[+A] extends Observable[A]
@inline
final implicit
class ConnectableMaybeValueOperations[A](val source: ConnectableMaybeValue[A]) extends AnyVal
@inline
final implicit
class ConnectableOperations[A](val source: Connectable[A]) extends AnyVal
@inline
final implicit
class ConnectableValueOperations[A](val source: ConnectableValue[A]) extends AnyVal
object Empty extends Observable[Nothing]
@inline
final implicit
class IterableOperations[A](val source: Observable[Iterable[A]]) extends AnyVal
trait MaybeValue[+A] extends Observable[A]
@inline
final implicit
class Operations[A](val source: Observable[A]) extends AnyVal
@inline
final implicit
class ProSubjectOperations[I, O](val handler: ProSubject[I, O]) extends AnyVal
@inline
final implicit
class SubjectMaybeValueOperations[A](val handler: MaybeValue[A]) extends AnyVal
@inline
final implicit
class SubjectOperations[A](val handler: Subject[A]) extends AnyVal
@inline
final implicit
class SubjectValueOperations[A](val handler: Value[A]) extends AnyVal
trait Value[+A] extends Observable[A]
object applicative extends Applicative[Observable]
object createProSubject extends CreateProSubject[ProSubject]
object createSubject extends CreateSubject[Subject]
object functorFilter extends FunctorFilter[Observable]
object liftSource extends LiftSource[Observable]
object monoidK extends MonoidK[Observable]
object semigroupal extends Semigroupal[Observable]
object source extends Source[Observable]

Types

type ConnectableValue[+A] = Connectable[A] & Value[A]
type Hot[+A] = Observable[A] & Cancelable
type HotValue[+A] = Value[A] & Cancelable

Value members

Concrete methods

def apply[T](value: T): Observable[T]
def concatAsync[F[_] : Effect, T](effects: F[T]*): Observable[T]
def concatAsync[F[_] : Effect, T](effect: F[T], source: Observable[T]): Observable[T]
def concatFuture[T](values: Future[T]*)(implicit ec: ExecutionContext): Observable[T]
def concatFuture[T](value: Future[T], source: Observable[T])(implicit ec: ExecutionContext): Observable[T]
def concatSync[F[_] : RunSyncEffect, T](effects: F[T]*): Observable[T]
def concatSync[F[_] : RunSyncEffect, T](effect: F[T], source: Observable[T]): Observable[T]
@inline
def create[A](produce: Observer[A] => Cancelable): Observable[A]
@inline
def empty: Empty
def failure[T](error: Throwable): Observable[T]
def fromAsync[F[_] : Effect, A](effect: F[A]): Observable[A]
def fromEither[A](value: Either[Throwable, A]): Observable[A]
def fromFuture[A](future: Future[A])(implicit ec: ExecutionContext): Observable[A]
def fromIterable[T](values: Iterable[T]): Observable[T]
def fromSync[F[_] : RunSyncEffect, A](effect: F[A]): Observable[A]
@inline
def interval(delay: FiniteDuration): Observable[Long]
def intervalMillis(delay: Int): Observable[Long]
def lift[H[_] : Source, A](source: H[A]): Observable[A]
def merge[A](sources: Observable[A]*): Observable[A]
def mergeSeq[A](sources: Seq[Observable[A]]): Observable[A]
def resource[F[_] : RunSyncEffect, R, S](acquire: F[R], use: R => S, release: R => F[Unit]): Observable[S]
def resourceFunction[R, S](acquire: () => R, use: R => S, release: R => Unit): Observable[S]
def switch[A](sources: Observable[A]*): Observable[A]
def switchSeq[A](sources: Seq[Observable[A]]): Observable[A]

Implicits

Implicits

final implicit
def ConnectableOperations[A](source: Connectable[A]): ConnectableOperations[A]
final implicit
def IterableOperations[A](source: Observable[Iterable[A]]): IterableOperations[A]
final implicit
def Operations[A](source: Observable[A]): Operations[A]
final implicit
def ProSubjectOperations[I, O](handler: ProSubject[I, O]): ProSubjectOperations[I, O]
final implicit
def SubjectOperations[A](handler: Subject[A]): SubjectOperations[A]
final implicit
def SubjectValueOperations[A](handler: Value[A]): SubjectValueOperations[A]