Index

Modules: reactiveCrown, reactiveCrown/core, reactiveCrown/operators, reactiveCrown/subjects, reactiveCrown/unitUtils.

API symbols

`<>`:

• operators: `<>`[T](self: ConnectableObservable[T]): Observable[T]
• subjects: `<>`[T](this: Subject[T]): Observable[T]

buffer:

• operators: buffer[T](upstream: Observable[T]; timeSpan: Natural; skip: Natural = 0): Observable[ seq[T]]

complete:

• core: complete[T](observer: Observer[T])

concat:

• operators: concat[T](upstream: Observable[T]; targets: varargs[Observable[T]]): Observable[ T]

connect:

• operators: connect[T](self: ConnectableObservable[T]): Disposable

construct_whenSubscribed:

• operators: construct_whenSubscribed[T](mkObservable: untyped): untyped

defineBasicSubjectConverters:

• subjects: defineBasicSubjectConverters(Type: typedesc): untyped

Disposable:

• core: Disposable

doThat:

• operators: doThat[T](upstream: Observable[T]; op: (T) -> void): Observable[T]

dump:

• operators: dump[T](upstream: Observable[T]): Observable[T]

error:

• core: error[T](observer: Observer[T]; e: ref Exception)

filter:

• operators: filter[T](upstream: Observable[T]; op: (T) -> bool): Observable[T]

getLastError:

• subjects: getLastError[T](this: Subject[T]): ref Exception

hasAnyObservers:

• core: hasAnyObservers[T](this: Observable[T]): bool

isCompleted:

• subjects: isCompleted[T](this: Subject[T]): bool

just:

• operators: just[T](v: T): Observable[T]

map:

• operators: map[T, S](upstream: Observable[T]; op: (T) -> S): Observable[S]

newObservable:

• core: newObservable[T](onSubscribe: (Observer[T]) -> Disposable): Observable[T]

newObserver:

• core: newObserver[T](onNext: T -> void; onError = default(proc (i0: ref Exception): void); onComplete = default(proc (): void)): Observer[T]

newOperatorSubject:

• subjects: newOperatorSubject[T](): OperatorSubject[T]

newPublishSubject:

• subjects: newPublishSubject[T](): PublishSubject[T]

newReplaySubject:

• subjects: newReplaySubject[T](bufferSize: Natural = Natural.high): ReplaySubject[T]

newSubscription:

• core: newSubscription[T](oble: Observable[T]; ober: Observer[T]): Subscription[T]

next:

• core: next[T](observer: Observer[T]; x: T; xs: varargs[T])
• unitUtils: next(subject: Subject[Unit])

Observable:

• core: Observable

Observer:

• core: Observer

OperatorSubject:

• subjects: OperatorSubject

publish:

• operators: publish[T](upstream: Observable[T]): ConnectableObservable[T]

PublishSubject:

• subjects: PublishSubject

range:

• operators: range[T: Ordinal](start: T; count: Natural): Observable[T]

refCount:

• operators: refCount[T](upstream: ConnectableObservable[T]): Observable[T]

repeat:

• operators: repeat[T](upstream: Observable[T]): Observable[T]
• operators: repeat[T](upstream: Observable[T]; times: Natural): Observable[T]

ReplaySubject:

• subjects: ReplaySubject

retry:

• operators: retry[T](upstream: Observable[T]): Observable[T]

share:

• operators: share[T](upstream: Observable[T]): Observable[T]

Subject:

• subjects: Subject

subscribe:

• core: subscribe[T](self: Observable[T]; observer: Observer[T]): Disposable
• core: subscribe[T](self: Observable[T]; onNext: T -> void; onError = default(proc (i0: ref Exception): void); onComplete = default(proc (): void)): Disposable

subscribeBlock:

• unitUtils: subscribeBlock[T](upstream: Observable[T]; body: untyped): Disposable
• unitUtils: subscribeBlock(upstream: Observable[Unit]; body: untyped): Disposable

toDisposable:

• core: toDisposable[T](subscription: Subscription[T]): lent Disposable

toObservable:

• operators: toObservable[T](self: ConnectableObservable[T]): Observable[T]
• subjects: toObservable[T](sbj`gensym2: PublishSubject[T]): Observable[T]
• subjects: toObservable[T](this: Subject[T]): Observable[T]
• subjects: toObservable[T](sbj`gensym4: ReplaySubject[T]): Observable[T]
• subjects: toObservable[T](sbj`gensym7: OperatorSubject[T]): Observable[T]

toObserver:

• subjects: toObserver[T](sbj`gensym2: PublishSubject[T]): Observer[T]
• subjects: toObserver[T](this: Subject[T]): Observer[T]
• subjects: toObserver[T](sbj`gensym4: ReplaySubject[T]): Observer[T]
• subjects: toObserver[T](sbj`gensym7: OperatorSubject[T]): Observer[T]

toSubject:

• subjects: toSubject[T](sbj`gensym2: PublishSubject[T]): Subject[T]
• subjects: toSubject[T](sbj`gensym4: ReplaySubject[T]): Subject[T]
• subjects: toSubject[T](sbj`gensym7: OperatorSubject[T]): Subject[T]

Unit:

• unitUtils: Unit

unitDefault:

• unitUtils: unitDefault(): Unit

unitfy:

• unitUtils: unitfy[T](upstream: Observable[T]): Observable[Unit]

zip:

• operators: zip[T](upstream: Observable[T]; targets: varargs[Observable[T]]): Observable[ seq[T]]
• operators: zip[Tl, Tr](tl: Observable[Tl]; tr: Observable[Tr]): Observable[(Tl, Tr)]