colibri/colibri/Observable

Observable

object Observable
Companion:
class
class Object
trait Matchable
class Any

Type members

Classlikes

final implicit class BooleanOperations(source: Observable[Boolean]) extends AnyVal
final implicit class EitherOperations[A](source: Observable[Either[Throwable, A]]) extends AnyVal
object Empty extends Observable[Nothing]
trait HasCancelable
trait Hot[+A] extends Observable[A] with HasCancelable
trait HotMaybeValue[+A] extends MaybeValue[A] with HasCancelable
trait HotValue[+A] extends Value[A] with HasCancelable
final implicit class IterableOperations[A](source: Observable[Iterable[A]]) extends AnyVal
final implicit class ListSubjectOperations[A](val handler: Subject[Seq[A]]) extends AnyVal
trait MaybeValue[+A] extends Observable[A]
implicit class ObservableLikeOperations[F[_], A](val source: Observable[F[A]])(implicit evidence$14: ObservableLike[F])
final implicit class Operations[A](source: Observable[A]) extends AnyVal
final implicit class OptionOperations[A](source: Observable[Option[A]]) extends AnyVal
final implicit class ProSubjectOperations[I, O](val handler: ProSubject[I, O]) extends AnyVal
final implicit class SubjectMaybeValueOperations[A](val handler: MaybeValue[A]) extends AnyVal
final implicit class SubjectOperations[A](val handler: Subject[A]) extends AnyVal
final implicit class SubjectValueOperations[A](val handler: Value[A]) extends AnyVal
final implicit class ThrowableOperations(source: Observable[Throwable]) extends AnyVal
trait Value[+A] extends Observable[A]
object catsInstances extends MonadError[Observable, Throwable] with FunctorFilter[Observable] with Alternative[Observable] with CoflatMap[Observable]
object catsInstancesProSubject extends Profunctor[ProSubject]
object catsInstancesSubject extends Invariant[Subject]
object catsParallelCombine extends Parallel[Observable]
object liftSource extends LiftSource[Observable]
object source extends Source[Observable]

Value members

Concrete methods

def apply[T](value: T): Observable[T]
def apply[T](value: T, value2: T, values: T*): Observable[T]
def concat[A](sources: Observable[A]*): Observable[A]
def concatEffect[F[_] : RunEffect, T](effects: F[T]*): Observable[T]
def concatEffect[F[_] : RunEffect, T](effect: F[T], source: Observable[T]): Observable[T]
def concatFuture[T](value1: => Future[T]): Observable[T]
def concatFuture[T](value1: => Future[T], value2: => Future[T]): Observable[T]
def concatFuture[T](value1: => Future[T], value2: => Future[T], value3: => Future[T]): Observable[T]
def concatFuture[T](value1: => Future[T], value2: => Future[T], value3: => Future[T], value4: => Future[T]): Observable[T]
def concatFuture[T](value1: => Future[T], value2: => Future[T], value3: => Future[T], value4: => Future[T], value5: => Future[T]): Observable[T]
def concatFuture[T](value: => Future[T], source: Observable[T]): Observable[T]
def concatIterable[A](sources: Iterable[Observable[A]]): Observable[A]
def create[A](produce: Observer[A] => Cancelable): Observable[A]
def createEmpty(subscription: () => Cancelable): Observable[Nothing]
def empty[A]: Observable[A]
def eval[T](value: => T): Observable[T]
def evalObservable[T](value: => Observable[T]): Observable[T]
def fromEffect[F[_] : RunEffect, A](effect: F[A]): Observable[A]
def fromEither[A](value: Either[Throwable, A]): Observable[A]
def fromEval[A](evalA: Eval[A]): Observable[A]
def fromFuture[A](future: => Future[A]): Observable[A]
def fromIterable[T](values: Iterable[T]): Observable[T]
def fromResource[F[_] : Sync, A](resource: Resource[F, A]): Observable[A]
def fromTry[A](value: Try[A]): Observable[A]
def interval(delay: FiniteDuration): Observable[Long]
def intervalMillis(delay: Int): Observable[Long]
def lift[H[_] : Source, A](source: H[A]): Observable[A]
def like[H[_] : ObservableLike, A](observableLike: H[A]): Observable[A]
def merge[A](sources: Observable[A]*): Observable[A]
def mergeIterable[A](sources: Iterable[Observable[A]]): Observable[A]
def pure[T](value: T): Observable[T]
def raiseError[T](error: Throwable): Observable[T]
def switch[A](sources: Observable[A]*): Observable[A]
def switchIterable[A](sources: Iterable[Observable[A]]): Observable[A]
def tailRecM[A, B](a: A)(f: A => Observable[Either[A, B]]): Observable[B]

Deprecated methods

def concatAsync[F[_] : RunEffect, T](effects: F[T]*): Observable[T]
Deprecated
def concatAsync[F[_] : RunEffect, T](effect: F[T], source: Observable[T]): Observable[T]
Deprecated
def concatSeq[A](sources: Seq[Observable[A]]): Observable[A]
Deprecated
def concatSync[F[_] : RunSyncEffect, T](effects: F[T]*): Observable[T]
Deprecated
def concatSync[F[_] : RunSyncEffect, T](effect: F[T], source: Observable[T]): Observable[T]
Deprecated
def failure[T](error: Throwable): Observable[T]
Deprecated
def fromAsync[F[_] : RunEffect, A](effect: F[A]): Observable[A]
Deprecated
def fromSync[F[_] : RunSyncEffect, A](effect: F[A]): Observable[A]
Deprecated
def mergeSeq[A](sources: Seq[Observable[A]]): Observable[A]
Deprecated
def switchSeq[A](sources: Seq[Observable[A]]): Observable[A]
Deprecated

Concrete fields

val unit: Observable[Unit]

Implicits

Implicits

final implicit def BooleanOperations(source: Observable[Boolean]): BooleanOperations
final implicit def EitherOperations[A](source: Observable[Either[Throwable, A]]): EitherOperations[A]
final implicit def IterableOperations[A](source: Observable[Iterable[A]]): IterableOperations[A]
final implicit def ListSubjectOperations[A](handler: Subject[Seq[A]]): ListSubjectOperations[A]
final implicit def ObservableLikeOperations[F[_] : ObservableLike, A](source: Observable[F[A]]): ObservableLikeOperations[F, A]
final implicit def Operations[A](source: Observable[A]): Operations[A]
final implicit def OptionOperations[A](source: Observable[Option[A]]): OptionOperations[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]
final implicit def ThrowableOperations(source: Observable[Throwable]): ThrowableOperations