colibri-reactive
API
Generated with
colibri-reactive/colibri.reactive/RxSourceSelf

RxSourceSelf

colibri.reactive.RxSourceSelf
See theRxSourceSelf companion object
trait RxSourceSelf[+Self <: (RxSource), +SelfSync <: (RxSource), +A]

Attributes

Companion
object
Graph
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait Rx[A]
trait Var[A]
trait RxEvent[A]
trait VarEvent[A]
trait RxLater[A]
trait VarLater[A]
trait RxSource[A]
trait RxState[A]
trait VarState[A]
trait VarSource[A]
Show all

Members list

Value members

Abstract methods

def observable: Observable[A]
def selfRxSync: SelfSync[A]
def transformRx[B](f: Observable[A] => Observable[B]): Self[B]
def transformRxSync[B](f: Observable[A] => Observable[B]): SelfSync[B]

Concrete methods

final def as[B](value: B): SelfSync[B]
final def asEffect[F[_] : RunEffect, B](value: F[B]): Self[B]
final def asEval[B](value: => B): SelfSync[B]
final def asFuture[B](value: => Future[B]): Self[B]
final def asSyncEffect[F[_] : RunSyncEffect, B](value: F[B]): SelfSync[B]
final def collect[B](f: PartialFunction[A, B]): Self[B]
final def combineLatest[B](sourceB: RxSource[B]): Self[(A, B)]
final def combineLatestMap[B, R](sourceB: RxSource[B])(f: (A, B) => R): Self[R]
final def concatMap[B](f: A => RxSource[B]): Self[B]
final def drop(n: Int): Self[A]
def filter(f: A => Boolean): Self[A]
Implicitly added by RxSourceOps
final def hot: SyncIO[SelfSync[A]]
final def map[B](f: A => B): SelfSync[B]
final def mapEffect[F[_] : RunEffect, B](f: A => F[B]): Self[B]
final def mapEither[B](f: A => Either[Throwable, B]): Self[B]
final def mapFuture[B](f: A => Future[B]): Self[B]
final def mapSyncEffect[F[_] : RunSyncEffect, B](f: A => F[B]): SelfSync[B]
final def mergeMap[B](f: A => RxSource[B]): Self[B]
def negated: SelfSync[Boolean]
Implicitly added by RxSourceBooleanOps
def scan[B](seed: => B)(f: (B, A) => B): SelfSync[B]
Implicitly added by RxSourceOps
final def subscribe: SyncIO[Cancelable]
final def switchMap[B](f: A => RxSource[B]): Self[B]
final def tap(f: A => Unit): SelfSync[A]
final def to(writer: RxWriter[A]): SelfSync[Unit]
def toggle[A](ifTrue: => A, ifFalse: => A): SelfSync[A]
Implicitly added by RxSourceBooleanOps
def toggle[A : Monoid](ifTrue: => A): SelfSync[A]
Implicitly added by RxSourceBooleanOps
final def unsafeForeach(f: A => Unit): Cancelable
final def unsafeHot(): SelfSync[A]
final def unsafeSubscribe(): Cancelable
final def unsafeSubscribe(writer: RxWriter[A]): Cancelable
final def via(writer: RxWriter[A]): SelfSync[A]
final def void: SelfSync[Unit]
final def withLatest[B](sourceB: RxSource[B]): Self[(A, B)]
final def withLatestMap[B, R](sourceB: RxSource[B])(f: (A, B) => R): Self[R]

Concrete fields

val self: RxSourceSelf[Self, SelfSync, A]
Implicitly added by RxSourceOps
Generated with