colibri/colibri/Observable

Observable

object Observable
Companion:
class
class Object
trait Matchable
class Any

Type members

Classlikes

@inline
final implicit implicit class EitherOperations[A](val source: Observable[Either[Throwable, A]]) extends AnyVal
object Empty extends Observable[Nothing]
@inline
final implicit implicit class IterableOperations[A](val source: Observable[Iterable[A]]) extends AnyVal
@inline
final implicit implicit class ListSubjectOperations[A](val handler: Subject[Seq[A]]) extends AnyVal
trait MaybeValue[+A] extends Observable[A]
@inline
final implicit implicit class Operations[A](val source: Observable[A]) extends AnyVal
@inline
final implicit implicit class ProSubjectOperations[I, O](val handler: ProSubject[I, O]) extends AnyVal
@inline
final implicit implicit class SubjectMaybeValueOperations[A](val handler: MaybeValue[A]) extends AnyVal
@inline
final implicit implicit class SubjectOperations[A](val handler: Subject[A]) extends AnyVal
@inline
final implicit implicit class SubjectValueOperations[A](val handler: Value[A]) extends AnyVal
trait Value[+A] extends Observable[A]
object applicative extends Applicative[Observable]
object flatMapError extends FlatMapError[Observable, Throwable]
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 Hot[+A] = Observable[A] & Cancelable
type HotValue[+A] = Value[A] & Cancelable

Value members

Concrete methods

@inline
def apply[T](value: T): Observable[T]
@inline
def apply[T](value: T, value2: T, values: T*): Observable[T]
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](values: Future[T]*): Observable[T]
def concatFuture[T](value: => Future[T], source: Observable[T]): Observable[T]
@inline
def create[A](produce: Observer[A] => Cancelable): Observable[A]
def delay[T](value: => T): Observable[T]
@inline
def empty: Empty.type
def fromEffect[F[_] : RunEffect, A](effect: F[A]): Observable[A]
def fromEither[A](value: Either[Throwable, 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]
@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 pure[T](value: T): Observable[T]
def raiseError[T](error: Throwable): Observable[T]
def switch[A](sources: Observable[A]*): Observable[A]
def switchSeq[A](sources: Seq[Observable[A]]): Observable[A]

Deprecated methods

@deprecated("Use concatEffect instead", "0.3.0")
def concatAsync[F[_] : RunEffect, T](effects: F[T]*): Observable[T]
Deprecated
@deprecated("Use concatEffect instead", "0.3.0")
def concatAsync[F[_] : RunEffect, T](effect: F[T], source: Observable[T]): Observable[T]
Deprecated
@deprecated("Use concatEffect instead", "0.3.0")
def concatSync[F[_] : RunSyncEffect, T](effects: F[T]*): Observable[T]
Deprecated
@deprecated("Use concatEffect instead", "0.3.0")
def concatSync[F[_] : RunSyncEffect, T](effect: F[T], source: Observable[T]): Observable[T]
Deprecated
@deprecated("Use Observable.raiseError instead", "0.3.0")
def failure[T](error: Throwable): Observable[T]
Deprecated
@deprecated("Use fromEffect instead", "0.3.0")
def fromAsync[F[_] : RunEffect, A](effect: F[A]): Observable[A]
Deprecated
@deprecated("Use fromEffect instead", "0.3.0")
def fromSync[F[_] : RunSyncEffect, A](effect: F[A]): Observable[A]
Deprecated

Implicits

Implicits

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 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]