Skip to content

Instantly share code, notes, and snippets.

@rebcabin

rebcabin/gist:5657986

Last active January 8, 2016 14:40
Show Gist options
  • Star 5 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save rebcabin/5657986 to your computer and use it in GitHub Desktop.
Save rebcabin/5657986 to your computer and use it in GitHub Desktop.
Download ZIP
Rx LINQ Operator Precis
Raw
gistfile1.txt
Rx LINQ Operator Precis
Brian Beckman, May 2013
================================================================================
Introduction
================================================================================
This is a highly abbreviated "cheat-sheet" for the LINQ operators over Rx, the
Reactive Extensions. Its purpose is to TEACH by laying bare the regular and
tasteful structure of the API. This structure can be difficult to perceive from
ordinary documentation and source code because comparable and contrastable
information is spread out over a large area or many pages. By collapsing and
arranging the elements of the API, putting like near like and removing
extraneity, we aim to make the big-picture structure bloom. It is our hope to
foster such clarity that reading the documentation and source will become easy.
Perhaps it will even be easy to create your own implementation.
This precis approximates the .NET version, including coverage for .NET types
such as Events and IAsyncResults not relevant to non-.NET ecosystems. It began
as a scrape of the on-line MSDN documentation, to have maximum chance to be
authoritative. For those working with Rx in non-.NET ecosystems, the .NET
designs over Events and IAsyncResults serve as examples of how to "fit" Rx to a
pre-existing or underlying asynchronous programming model.
Another reason to choose the .NET design as a study point is that it requires
explicit types to be written. Explicit types help with understanding the API.
Once we understand the types of an operator, the implementation is often obvious
or even forced. There are many run-time advantages to dynamically typed
implementations of Rx, but there are unique intellectual advantages to a
type-ful description. Knowing the kinds of things functions take in and the
kinds of things they produce is the crux of any API design. Even when writing
applications in a dynamically typed language like JavaScript or Clojure, this
knowledge guides every step. The types are there, whether they are written down
or not. A presentation that makes type-knowledge explicit is a preferred
teaching vehicle.
However, .NET type notation is very verbose ("prolix," "voluble," opposite of
"concise"). The prolixity of the notation makes it again unnecessarily difficult
to "see the forest for the trees," that is, to perceive the clean and regular
structure of the Rx API.
The primary approaches to reducing prolixity in this document are as follows:
(1) to abbreviate the names of types
(2) replace angle brackets (which often give a distracting suggestion of motion
to the reading eye) surrounding type parameters with square brackets
(3) collapse long lists of overloads that have no important semantic differences
(4) shorten the English descriptions and resolve some ambiguities inherited from
the source documentation
(5) explicitly write the "receiver" types as the first arguments to methods,
thus removing any difference between methods, functions, and extension methods.
These distinctions are important and helpful in C#, but definitely "in-the-way"
when it comes to understanding the overall structure of the API. Everything is
denoted as a function.
(6) collect documentation from multiple different web pages in one spot
Other versions of this document render the Rx API precisely in various
languages.
================================================================================
Example of Abbreviated Type Notation
================================================================================
Here is an example of this abbreviated type notation from a familiar but very
rich and complex type, IDictionary
(http://msdn.microsoft.com/en-us/library/s4ys34ea.aspx). We show the original
interface definition and a handful of the most important operators.
The original looks like the following, scraped from six different web pages, and
not including the prose documentation, which would take up much space here:
public interface IDictionary<TKey, TValue> : ICollection<KeyValuePair<TKey, TValue>>,
IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable
int Count { get; }
TValue this[
TKey key
] { get; set; }
void Add(
TKey key,
TValue value
)
bool ContainsKey(
TKey key
)
bool Remove(
TKey key
)
The abbreviated version looks like the following:
IDi[K, V] : IC[KVp[K, V], IEn[KVp[K, V]], IEn
h Count [K, V](IDi[K, V]) produces an int (h) reporting the number of KV pairs in the dictionary
V getThis[K, V](IDi[K, V], K) produces a value of type V from a key of type K; throws if not found
v Add [K, V](IDi[K, V], K, V) adds the given KV pair; produces void; throws if key already present
b ContainsKey[K](IDi[K, V], K) produces boolean reporting whether key is present
b Remove [K](IDi[K, V], K) produces boolean reporting whether key is present; removes KV pair
The features of this abbreviated notation include the following:
* each function symbol has type parameters in square brackets and regular
parameters in round parentheses, with the type of the value produced by the
function to the left of its symbol (all functions produce a single value; that
value may be of collection type)
* only the types of the regular parameters are reported (the names of parameters
are seldom important)
* the implicit, first "this" parameter, namely the dictionary itself, is always
written explicitly; this practice, while apparently noisy in this example, is
very helpful in the Rx API below)
================================================================================
Sources
================================================================================
http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable(v=vs.103).aspx
http://www.clipcode.net/mentoring/RxReferenceLibrary.pdf
http://www.introtorx.com/
http://go.microsoft.com/fwlink/?LinkID=205219
http://msdn.microsoft.com/en-us/data/gg577609.aspx
https://rx.codeplex.com/
http://msdn.microsoft.com/en-us/data/gg577611.aspx
http://www.colourcoding.net
http://leecampbell.blogspot.com/2011/03/rx-part-9join-window-buffer-and-group.html
Other blogs and ad-hoc internet sources too numerous
to list.
================================================================================
Notation
================================================================================
Miscellaneous
~~> Produces, Returns, Propagates
(\) Disjoint, non-overlapping
(+) Non-disjoint, potentially overlapping
A :: B A Has type B
Concrete Types
b Boolean
d Double double-precision floating-point number
dt DateTimeOffset
e Decimal
h int machine int (often Int64)
i Int32
j Int64
l long (often same as j)
n numerical type one of {b d e h i j l} and their Nullable variations
o Object
s Single single-precision floating-point number
t TimeSpan
u unit sometimes (ambiguously) denoted (); a concrete type for "void"
v void sometimes denoted (), especially in type annotations
AC AsyncCallback
Ea TEventArgs specific to .NET events
Eh[T] EventHandler[T] specific to .NET events
Ep[T] EventPattern[T] specific to .NET events
N[T] Nullable
Not[S] Notification wraps values, exceptions, completions into values
Pat[S,T] Join Pattern
Pat[S,T,U] Join Pattern
Pl[S] Plan part of the join-pattern operators And, Then, When
SC SynchronizationContext
Ti[T] TimeInterval[T]
Ts[T] TimeStamped[T]
Function Types
A -> B Function from (elements of) type A to (elements of) type B
Ac[.*] Action[.*] Ac[A, B, ...] :: A x B x ... -> u (unit, nothing, void)
F[.*] Func[.*] F[A, B, ..., R] :: A x B x ... -> R
P[T] Func[T, b] Predicate
Type Parameters
A TAggregate, TAccumulate
B TBuffer
Bc TBufferClosing
Bo TBufferOpening
C TCollection
D TDelegate
E TElement
K TKey
L TLeft
M TIntermediate
R TResult, TRight
S TSource
T any type
T1 TFirst
Tn TNth
T1..Tn finite sequence of type parameters (syntax)
Ts TSample
U TDuration for controlling GroupByUntil, GroupJoin, TakeUntil, SkipUntil
Ul TLeftDuration for controlling GroupByUntil, GroupJoin, TakeUntil, SkipUntil
Ur TRightDuration for controlling GroupByUntil, GroupJoin, TakeUntil, SkipUntil
V TValue
Wc TWindowClosing
Wo TWindowOpening
X TException
Y TOther
Z TState
Interfaces
IAR IAsyncResult
IC[T] ICollection Count, GetEnumerator, IsSynchronized (thread-safe), etc.
ICm[T] IComparer H Compare[T](T, T)
ICO IConnectableObservable separates observable start from subscription
IDi[K, V] IDictionary[K,V] Count, b Contains[K](IDi[K,V], K), v Add[K,V](IDi[K,V],K,V), etc.
IDp IDisposable unsubscribes
IEn[T] IEnumerable IEr[T] GetEnumerator[T](IEn[T])
IEr[T] IEnumerator T Current[T](IEr[T]), b MoveNext[T](IEr[T])
IEC[T] IEqualityComparer b Equals[T](T, T)
IEP IEventPatternSource part of .NET event ecosystem; raises standard event
IES IEventSource part of .NET event ecosystem; raises unstructured event
IG[K, R] IGroupedObservable[K, R] has additional property "Key" of type K
IL[T] IList v Insert[T](IL[T], h, T)
ILu ILookup[K, V] generalization of IDictionary
IOb[T] IObservable IDp Subscribe(IOb[T], IOr[T]), overloads, ...
IOr[T] IObserver v OnNext(IOr[T], T), v OnError(IOr[T],X), v OnCompleted()
ISb[T] ISubject implements both IOb[T] and IOr[T]
ISc IScheduler
Other
* unfinished, unreviewed, needs checking
& optional parameter, e.g., IScheduler (collapses overloads)
[] Array of instances of the preceding type, e.g. S[] means "Array of S's"
oseq an observable sequence
eseq an enumerable sequence
================================================================================
Alphabetic List transcribed from current MSDN offering (May 2013)
in which every operator is expressed by its type signature. Its output type is
to the left, and the types of its inputs are to its right enclosed in round
parentheses. Only the types of parameters are written, not extraneous names for
parameters. When necessary to distinguish parameters of the same time, a
numerical suffix is used.
Many APIs have overloads that take an ISc (IScheduler) as a last argument. These
APIs are not substantially different from the ones that don't have an ISc, so
the IScheduler is listed as an optional type parameter.
Several APIs have overloads that differ only by the presence of a customized
IEqualityComparer (IEC) or IComparer (ICm) interface. These are also denoted
with optional type parameters.
Several APIs have multiple convenience overloads allowing anonymous and defaulted
observers. For example
IOb[S] Do[S](IOb[S], IOr[S]) explicit observer
IOb[S] Do[S](IOb[S], Ac[S]) onNext only; defaults for others
IOb[S] Do[S](IOb[S], Ac[S], Ac) onNext and onCompleted; default onError
IOb[S] Do[S](IOb[S], Ac[S], Ac[X]) onNext and onError; default onCompleted
IOb[S] Do[S](IOb[S], Ac[S], Ac[X], Ac) all callbacks anonymous
We collapse this prolixity by writing the IOr[S] with a plus sign, as follows
IOb[S] Do[S](IOb[S], +IOr[S]) explicit or defaulted observer
That notation stands for the existence of all the convenience overloads.
================================================================================
IOb[S] Aggregate[S](IOb[S], F[S, S, S]) Applies accumulator func; a.k.a. "reduce", "foldl"
IOb[A] Aggregate[S, A](IOb[S], A, F[A, S, A]) Applies accumulator func with init value.
IOb[b] All[S](IOb[S], P[S]) Reports whether all elements satisfy P (finite obs only)
IOb[S] Amb[S](IEn[IOb[S]]) ~~> the oseq that reacts first.
IOb[S] Amb[S](IOb[S], IOb[S]) ~~> the oseq that reacts first.
* Pat[S, R] And[L, R] Matches when both oseqs have an available value.
IOb[b] Any[S](IOb[S]) Reports whether oseq contains any elements.
IOb[b] Any[S](IOb[S], P[S]) Reports whether any element satisfies P.
IOb[S] AsObservable[S](IOb[S]) Hides the identity of an oseq.
IOb[n] Average(IOb[n]) ~~> average value of type n.
IOb[IL[S]] Buffer[S](IOb[S], h) ~~> consecutive (\) buffers of count h.
IOb[IL[S]] Buffer[S](IOb[S], t, &ISc) ~~> consecutive (\) buffers based on timing.
IOb[IL[S]] Buffer[S](IOb[S], t, h, &ISc) ~~> consecutive (\) buffers sent when full or t expires.
IOb[IL[S]] Buffer[S](IOb[S], h1, h2) ~~> consecutive (+) buffers of count h1 (see intro2rx).
IOb[IL[S]] Buffer[S](IOb[S], t1, t2, &ISc) ~~> consecutive (+) buffers of time t and skipping time t between
IOb[IL[S]] Buffer[S, Bc](IOb[S], F[IOb[Bc]]) ~~> consecutive (+) buffers, closing when indicated
IOb[IL[S]] Buffer[S, Bo, Bc](IOb[S], IOb[Bo], F[Bo, IOb[Bc]]) ~~> consecutive (+) buffers, closing when indicated
IOb[R] Cast[R](IOb[o]) Converts elements to the specified type.
IOb[S] Catch[S](IEn[IOb[S]]) Continues after exception with next oseq.
IOb[S] Catch[S](IOb[S], IOb[S]) Continues after exception with next oseq.
IOb[S] Catch[S, X](IOb[S], F[X, IOb[S]]) Continues after exception with oseq produced by X handler.
IOb[R] CombineLatest[S, T, R](IOb[S], IOb[T], F[S, T, R]) Merges two oseqs whenever one oseq produces an element
IOb[S] Concat[S](IEn[IOb[S]]) Concatenates eseq of oseqs.
IOb[S] Concat[S](IOb[IOb[S]]) Concatenates an oseq of oseqs.
IOb[S] Concat[S](IOb[S], IOb[S]) Concatenates two oseqs.
IOb[b] Contains[S](IOb[S], S, &IEC[S]) Reports presence of element
IOb[h] Count[S](IOb[S]) ~~> total number of elements in an oseq.
IOb[S] Create[S](F[IOr[S], Ac]) ~~> oseq from subscribe function
IOb[S] Create[S](F[IOr[S], IDp]) ~~> oseq from subscribe function
IOb[S] DefaultIfEmpty[S](IOb[S]) ~~> specified oseq or S's default value in singleton.
IOb[S] DefaultIfEmpty[S](IOb[S], S) ~~> specified oseq or specified default value in singleton.
IOb[S] Defer[S](F[IOb[S]]) ~~> oseq that invokes factory whenever observer subscribes.
IOb[S] Delay[S](IOb[S], dt, &ISc) Delays the oseq by the specified time.
IOb[S] Delay[S](IOb[S], t, &ISc) Delays the oseq by the specified time.
IOb[S] Dematerialize[S](IOb[Not[S]]) Dematerializes explicit notifications as implicit.
IOb[S] Distinct[S](IOb[S], &IEC[S]) ~~> oseq with only distinct elements via comparer.
IOb[S] Distinct[S, K](IOb[S], F[S, K], & IEC[K]) ~~> oseq with only distinct elements via transform S->K.
IOb[S] DistinctUntilChanged[S](IOb[S], &IEC[S]) ~~> oseq with only distinct contiguous elements.
IOb[S] DistinctUntilChanged[S, K](IOb[S], F[S, K], &IEC[K]) ~~> oseq with only distinct contiguous elements via S->K.
IOb[S] Do[S](IOb[S], Ac[S]) Invokes action for each element.
IOb[S] Do[S](IOb[S], +IOr[S]) Invokes action for each element.
IOb[S] ElementAt[S](h) ~~> element at a specified index.
IOb[S] ElementAtOrDefault[S](h) ~~> element at a specified index or default value.
IOb[R] Empty[R](&ISc) ~~> empty oseq.
IOb[S] Finally[S](IOb[S], Ac) Invokes action after termination.
IOb[S] First[S](IOb[S]) ~~> first element wrapped in a singleton.
IOb[S] First[S](IOb[S], P[S]) ~~> first element that satisfies predicate.
IOb[S] FirstOrDefault[S](IOb[S]) ~~> first element or default.
IOb[S] FirstOrDefault[S](IOb[S], P[S]) ~~> first element that satisfies predicate or default.
v ForEach[S](IOb[S]) Invokes action for each element; blocks until termination.
v ForEach[S](IOb[S], +IOr[S]) Invokes action for each element; blocks until termination.
F[IOb[u]] FromAsyncPattern(F[AC, o, IAR], Ac[IAR]) Converts Begin/End pair into async function.
F[IOb[R]] FromAsyncPattern[R](F[AC, o, IAR], F[IAR, R]) Converts Begin/End pair into async function.
F[IOb[u]] FromAsyncPattern[T1..Tn](F[T1..Tn, AC, o, IAR], Ac[IAR]) Converts Begin/End pair into async function.
F[IOb[R]] FromAsyncPattern[T1..Tn, R](F[T1..Tn, AC, o, IAR], F[IAR, R]) Converts Begin/End pair into async function.
IOb[u] FromEvent(Ac[Ac], Ac[Ac]) Converts .NET event to oseq.
IOb[Ea] FromEvent[Ea](Ac[Ac[Ea]], Ac[Ac[Ea]]) Converts .NET event to oseq.
IOb[Ea] FromEvent[D, Ea](Ac[D], Ac[D]) Converts .NET event to oseq.
IOb[Ea] FromEvent[D, Ea](F[Ac[Ea], D], Ac[D], Ac[D]) Converts .NET event to oseq.
IOb[Ep[Ea]] FromEventPattern(Ac[Eh], Ac[Eh]) Converts .NET event to oseq with add and remove handlers.
IOb[Ep[Ea]] FromEventPattern(o, String) Converts .NET event to oseq using reflection.
IOb[Ep[Ea]] FromEventPattern(Type, String) Converts .NET event to oseq using reflection.
IOb[Ep[Ea]] FromEventPattern[Ea](Ac[Eh[Ea]], Ac[Eh[Ea]]) Converts .NET event to oseq with add and remove handlers.
IOb[Ep[Ea]] FromEventPattern[Ea](o, String) Converts .NET event to oseq using reflection.
IOb[Ep[Ea]] FromEventPattern[Ea](Type, String) Converts .NET event to oseq using reflection.
IOb[Ep[Ea]] FromEventPattern[D, Ea](Ac[D], Ac[D]) Converts .NET event to oseq with add and remove handlers.
IOb[Ep[Ea]] FromEventPattern[D, Ea](F[Eh[Ea], D], Ac[D], Ac[D]) Converts .NET event to oseq with conversion and handlers.
IOb[R] Generate[Z, R](Z, P[Z], F[Z, Z], F[Z, R], &ISc) ~~> oseq by iterating state until condition fails.
IOb[R] Generate[Z, R](Z, P[Z], F[Z, Z], F[Z, R], F[Z, dt], &ISc) ~~> oseq by iterating state until condition fails.
IOb[R] Generate[Z, R](Z, P[Z], F[Z, Z], F[Z, R], F[Z, t], &ISc) ~~> oseq by iterating state until condition fails.
IEn[S] GetEnumerator[S](IOb[S]) ~~> enumerator over all values of oseq.
IG[K, S] GroupBy[S, K](IOb[S], F[S, K], &IEC[K]) Groups elements according to key-selector function.
IG[K, E] GroupBy[S, K, E](IOb[S], F[S, K], F[S, E], &IEC[K]) Groups & transforms according to given functions.
IG[K, E] GroupByUntil[S, K, U](IOb[S], F[S, K], F[IG[K, S], IOb[U]], &IEC[K]) see http://bit.ly/10XPxC8, 17gqnrD
IG[K, E] GroupByUntil[S, K, E, U](IOb[S], F[S, K], F[S, E], F[IG[K, E], IOb[U]], &IEC[K]) see http://bit.ly/10XPxC8
IOb[E] GroupJoin[L, R, Ul, Ur, E](IOb[L], IOb[R], F[L, IOb[Ul]], F[R, Ur], F[L, IOb[Ur], E]]) see http://bit.ly/11kTUXM
IOb[S] IgnoreElements[S](IOb[S]) Ignores all values leaving only termination messages.
IOb[j] Interval(t, &ISc) ~~> oseq that produces a value after each period.
IOb[R] Join[L, R, Ul, Ur, E](IOb[L], IOb[R], F[L, Ul], F[R, Ur], F[L, R, E]]) see http://bit.ly/11kTUXM
S Last[S](IOb[S]) ~~> last element.
S Last[S](IOb[S], P[S]) ~~> last element that satisfies predicate.
S LastOrDefault[S](IOb[S]) ~~> last element, or default.
S LastOrDefault[S](IOb[S], P[S]) ~~> last element that satisfies predicate, or default.
IEn[S] Latest[S](IOb[S]) Samples most recent value in oseq.
IOb[j] LongCount[S](IOb[S]) ~~> total number of elements.
Not[S] Materialize[S](IOb[S]) Materializes implicit notifications of oseq as explicit.
IOb[n] Max(IOb[n]) ~~> maximum value.
IOb[S] Max[S](IOb[S], ICm[S]) ~~> maximum value in oseq according to comparer.
IOb[S] MaxBy[S, K](IOb[S], F[S, K], &ICm[K]) ~~> elements with maximum key value.
IOb[S] Merge[S](&ISc, IOb[S][]) Merges params array of oseqs.
IOb[S] Merge[S](IEn[IOb[S]], &ISc) Merges eseq of oseqs.
IOb[S] Merge[S](IOb[IOb[S]]) Merges oseq of oseqs.
IOb[S] Merge[S](IOb[IOb[S]], h) Merges eseq of oseqs, limiting # of concurrent subscriptions.
IOb[S] Merge[S](IEn[IOb[S]], h, &ISc) Merges eseq of oseqs, limiting # of concurrent subscriptions.
IOb[S] Merge[S](IOb[S], IOb[S], &ISc) Merges two oseqs into a single oseq.
IOb[n] Min(IOb[n]) ~~> minimum value in oseq.
IOb[S] Min[S](IOb[S], ICm[S]) ~~> minimum value in oseq according to comparer.
IOb[S] MinBy[S, K](IOb[S], F[S, K], &ICm[K]) ~~> elements with minimum key value.
IEn[S] MostRecent[S](IOb[S], S) Samples most recent value in oseq.
ICO[R] Multicast[S, R](IOb[S], ISb[S, R]) ~~> connectable oseq; see http://bit.ly/11kWr4r, 12J34jn
IOb[R] Multicast[S, M, R](IOb[S], F[ISb[S, M]], F[IOb[M], IOb[R]]) see http://bit.ly/11kWr4r, 12J34jn
IOb[S] Never[S]() ~~> non-terminating oseq.
IEn[S] Next[S](IOb[S]) Samples next value (blocking without buffering).
IOb[S] ObserveOn[S](IOb[S], ISc) notify observers on specified scheduler.
IOb[S] ObserveOn[S](IOb[S], SC) notify observers on the specified sync context.
IOb[R] OfType[R](IOb[S]) Filters elements based on the specified subtype.
IOb[S] OnErrorResumeNext[S](IOb[S], IOb[S]) Continues oseq after termination.
IOb[S] OnErrorResumeNext[S](IOb[S][]) Continues oseq after termination.
IOb[S] OnErrorResumeNext[S](IEn[IOb[S]]) Continues oseq after termination.
ICO[S] Publish[S](IOb[S]) http://bit.ly/12Yvub1
ICO[S] Publish[S](IOb[S], S) http://bit.ly/12Yvub1
ICO[R] Publish[S, R](IOb[S], F[IOb[S], IOb[R]]) http://bit.ly/12Yvub1
ICO[R] Publish[S, R](IOb[S], F[IOb[S], IOb[R]], S) http://bit.ly/12Yvub1
ICO[R] PublishLast[S](IOb[S]) http://bit.ly/12Yvub1
ICO[R] PublishLast[S, R](IOb[S], F[IOb[S], IOb[R]]) http://bit.ly/12Yvub1
IOb[i] Range(h, h, &ISc) numbers within a specified range.
IOb[S] RefCount[S](ICO[S]) stays connected so long as there is a subscription.
IOb[S] Repeat[S](IOb[S]) Repeats the oseq indefinitely.
IOb[R] Repeat[R](R, &ISc) Repeats the given element infinitely.
IOb[R] Repeat[S](IOb[S], h) Repeats the oseq indefinitely.
IOb[R] Repeat[R](R, h, &ISc) Repeats the given element the specified number of times.
ICO[S] Replay[S](IOb[S], &ISc) http://bit.ly/12J47Qm
ICO[S] Replay[S](IOb[S], h, &ISc) http://bit.ly/12J47Qm
ICO[S] Replay[S](IOb[S], t, &ISc) http://bit.ly/12J47Qm
ICO[S] Replay[S](IOb[S], h, t, &ISc) http://bit.ly/12J47Qm
ICO[R] Replay[S, R](IOb[S], F[IOb[S], IOb[R]], &ISc) http://bit.ly/12J47Qm
ICO[R] Replay[S, R](IOb[S], F[IOb[S], IOb[R]], h, &ISc) http://bit.ly/12J47Qm
ICO[R] Replay[S, R](IOb[S], F[IOb[S], IOb[R]], t, &ISc) http://bit.ly/12J47Qm
ICO[R] Replay[S, R](IOb[S], F[IOb[S], IOb[R]], h, t, &ISc) http://bit.ly/12J47Qm
IOb[S] Retry[S](IOb[S]) Repeats source oseq until it successfully terminates.
IOb[S] Retry[S](IOb[S], h) Repeats source oseq until it successfully terminates.
IOb[R] Return[R](R, &ISc) ~~> oseq with a single value with a specified value.
IOb[S] Sample[S](IOb[S], t, &ISc) Samples oseq at each interval
IOb[S] Sample[S, Ts](IOb[S], IOb[Ts]) Samples the oseq at sampling ticks with the specified source and sampler.
IOb[S] Scan[S](IOb[S], F[S, S, S]) Applies accumulator and returns intermediate results.
IOb[A] Scan[S, A](IOb[S], A, F[A, S, A]) Applies accumulator and returns intermediate results.
IOb[R] Select[S, R](IOb[S], F[S, R]) Transforms elements.
IOb[R] Select[S, R](IOb[S], F[S, h, R]) Transforms elements and indices.
IOb[R] SelectMany[S, R](IOb[S], F[S, IEn[R]]) Transforms elements and flattens exactly once.
IOb[R] SelectMany[S, R](IOb[S], F[S, IOb[R]]) Transforms elements and flattens exactly once.
IOb[Y] SelectMany[S, Y](IOb[S], IOb[Y]) Transforms elements and flattens exactly once.
IOb[R] SelectMany[S, R](IOb[S], F[S, IOb[R]], F[X, IOb[R]], F[IOb[R]]) Transforms elements and flattens exactly once.
IOb[R] SelectMany[S, C, R](IOb[S], F[S, IEn[C]], F[S, C, R]) Transforms elements and flattens exactly once.
IOb[R] SelectMany[S, C, R](IOb[S], F[S, IOb[C]], F[S, C, R]) Transforms elements and flattens exactly once.
IOb[b] SequenceEqual[S](IOb[S], IOb[S], &IEC[S]) Determines whether two sequences are equal.
S Single[S](IOb[S]) ~~> only element and throws if there is not exactly one element.
S Single[S](IOb[S], P[S]) ~~> only element that satisfies predicate and throws.
S SingleOrDefault[S](IOb[S]) ~~> only element, or default if oseq is empty.
S SingleOrDefault[S](IOb[S], P[S]) ~~> only element that satisfies predicate, or default.
IOb[S] Skip[S](IOb[S], h) Bypasses specified number of elements.
IOb[S] SkipLast[S](IOb[S], h) Bypasses specified number of elements at the end.
IOb[S] SkipUntil[S, Y](IOb[S], IOb[Y]) ~~> values from source oseq only after other oseq produces.
IOb[S] SkipWhile[S](IOb[S], P[S]) Bypasses values so long as specified predicate is true.
IOb[S] SkipWhile[S](IOb[S], F[S, h, b]) Bypasses values so long as specified indexed predicate is true.
IOb[u] Start(Ac, &ISc) Invokes the action asynchronously.
IOb[S] Start[S](F[S], &ISc) Invokes the function asynchronously.
IOb[S] StartWith[S](IOb[S], &ISc, S[]) Prepends elements.
IDp Subscribe[S](IEn[S], +IOr[S], &ISc) Subscribes to eseq.
IOb[S] SubscribeOn[S](IOb[S], ISc) Asynchronously subscribes on specified scheduler.
IOb[S] SubscribeOn[S](IOb[S], SC) Asynchronously subscribes on specified sync
IOb[n] Sum(IOb[n]) Computes sum.
IOb[S] Switch[S](IOb[S]) oseq of oseqs -> oseq producing only from most recent.
IOb[S] Synchronize[S](IOb[S]) Surrounds observers with thread-safe locks: http://bit.ly/ZoD7ZK
IOb[S] Synchronize[S](IOb[S], o) Surrounds observers with thread-safe locks: http://bit.ly/ZoD7ZK
IOb[S] Take[S](IOb[S], h) ~~> specified number of contiguous elements from start.
IOb[S] TakeLast[S](IOb[S], h) ~~> specified number of contiguous elements from end.
IOb[S] TakeUntil[S, Y](IOb[S], IOb[Y]) ~~> values source until other oseq produces a value.
IOb[S] TakeWhile[S](IOb[S], P[S]) ~~> values from oseq so long as predicate is true.
IOb[S] TakeWhile[S](IOb[S], F[S, h, b]) ~~> values from oseq so long as specified condition is true.
Pl[R] Then[S, R](IOb[S], F[S, R]) Matches when oseq has available value and projects the value.
IOb[S] Throttle[S](IOb[S], t, &ISc) Ignores values following faster than specified duration.
IOb[R] Throw[R](X, &ISc) ~~> oseq that terminates with exception.
IOb[Ti[S]] TimeInterval[S](IOb[S], &ISc) Records the time interval between consecutive values.
IOb[S] Timeout[S](IOb[S], dt, &ISc) ~~> either oseq or TimeoutException if dueTime elapses.
IOb[S] Timeout[S](IOb[S], t, &ISc) ~~> either oseq or TimeoutException if dueTime elapses.
IOb[S] Timeout[S](IOb[S], dt, IOb[S], &ISc) ~~> source or other oseq if dueTime elapses.
IOb[S] Timeout[S](IOb[S], t, IOb[S], &ISc) ~~> source or other oseq if dueTime elapses.
IOb[l] Timer(dt, &ISc) produces a value after due time.
IOb[l] Timer(t, &ISc) produces a value after due time.
IOb[l] Timer(dt, t, &ISc) produces a value after due time then periodically.
IOb[l] Timer(t, t, &ISc) produces a value after due time then periodically.
IOb[Ts[S]] Timestamp[S](IOb[S], &ISc) Records timestamp for each value.
IOb[S[]] ToArray[S](IOb[S]) ~~> array from oseq.
F[IOb[u]] ToAsync(Ac) Converts the function into async function.
F[T1..Tn, IOb[u]] ToAsync[T1..Tn](Ac[T1..Tn]) Converts the function into async function.
F[IOb[R]] ToAsync[R](F[R]) Converts the function into async function.
F[T1..Tn, IOb[R]] ToAsync[T1..Tn, R](F[T1..Tn, R]) Converts the function into async function.
F[IOb[u]] ToAsync(Ac, ISc) Converts the function into async function.
F[T1..Tn, IOb[u]] ToAsync[T1..Tn](Ac[T1..Tn], ISc) Converts the function into async function.
F[IOb[R]] ToAsync[R](F[R], ISc) Converts the function into async function.
F[T1..Tn, IOb[R]] ToAsync[T1..Tn, R](F[T1..Tn, R], ISc) Converts the function into async function.
IOb[IDi[K, S]] ToDictionary[S, K](IOb[S], F[S, K], &IEC[K]) ~~> dictionary according to key selector.
IOb[IDi[K, E]] ToDictionary[S, K, E](IOb[S], F[S, K], F[S, E], &IEC[K]) ~~> dictionary according to key & elt selectors.
IEn[S] ToEnumerable[S](IOb[S]) Converts oseq to eseq.
IES[S] ToEvent(IOb[u]) Exposes oseq as .NET event.
IES[S] ToEvent[S](IOb[S]) Exposes oseq as .NET event.
IEP[S] ToEventPattern[Ea](IOb[Ep[Ea]]) Exposes oseq as .NET event.
IOb[IL[S]] ToList[S](IOb[S]) ~~> list from oseq.
ILu[S, K] ToLookup[S, K](IOb[S], F[S, K], &IEC[K]) ~~> lookup from oseq according to key selector function.
ILu[S, E] ToLookup[S, K, E](IOb[S], F[S, K], F[S, E], IEC[K]) ~~> lookup from oseq according to key & elt selectors.
IOb[S] ToObservable[S](IEn[S], &ISc) Converts eseq to oseq.
IOb[S] Using[S, IDp](F[IDp], F[IDp, IOb[S]]) ~~> oseq that depends on disposable resource object.
IOb[R] When[R](IEn[Plan[R]]) Joins results from several patterns.
IOb[R] When[R](Plan[R][]) Joins results from several patterns.
IOb[S] Where[S](IOb[S], P[S]) Filters elements based on predicate.
IOb[S] Where[S](IOb[S], F[S, h, b]) Filters elements based on indexed predicate.
IOb[IOb[S]] Window[S](IOb[S], h) ~~> consecutive (\) windows based on count.
IOb[IOb[S]] Window[S](IOb[S], h, h) ~~> (+) windows based on count & skip.
IOb[IOb[S]] Window[S](IOb[S], t, &ISc) ~~> consecutive (\) windows based on timing.
IOb[IOb[S]] Window[S](IOb[S], t, h, &ISc) ~~> windows completed when either full or time has elapsed.
IOb[IOb[S]] Window[S](IOb[S], t, t, &ISc) ~~> (+) windows based on time & skip time.
IOb[IOb[S]] Window[S, Wc](IOb[S], F[IOb[Wc]]) ~~> consecutive (\) windows.
IOb[IOb[S]] Window[S, Wo, Wc](IOb[S], IOb[Wo], F[Wo, IOb[Wc]]) http://bit.ly/11l5pP8
IOb[R] Zip[T1, T2, R](IOb[T1], IEn[T2], F[T1, T2, R]) Merges oseq and eseq via binary function.
IOb[R] Zip[T1, T2, R](IOb[T1], IOb[T2], F[T1, T2, R]) Merges oseqs pairwise.
========================================================================================================================
A Minimum-Noise List
========================================================================================================================
IOb[S] Aggregate[S](IOb[S], F[S, S, S])
IOb[A] Aggregate[S, A](IOb[S], A, F[A, S, A])
IOb[b] All[S](IOb[S], P[S])
IOb[S] Amb[S](IEn[IOb[S]])
IOb[S] Amb[S](IOb[S], IOb[S])
* Pat[S, R] And[L, R]
IOb[b] Any[S](IOb[S])
IOb[b] Any[S](IOb[S], P[S])
IOb[S] AsObservable[S](IOb[S])
IOb[n] Average(IOb[n])
IOb[IL[S]] Buffer[S](IOb[S], h)
IOb[IL[S]] Buffer[S](IOb[S], t, &ISc)
IOb[IL[S]] Buffer[S](IOb[S], t, h, &ISc)
IOb[IL[S]] Buffer[S](IOb[S], h1, h2)
IOb[IL[S]] Buffer[S](IOb[S], t1, t2, &ISc)
IOb[IL[S]] Buffer[S, Bc](IOb[S], F[IOb[Bc]])
IOb[IL[S]] Buffer[S, Bo, Bc](IOb[S], IOb[Bo], F[Bo, IOb[Bc]])
IOb[R] Cast[R](IOb[o])
IOb[S] Catch[S](IEn[IOb[S]])
IOb[S] Catch[S](IOb[S], IOb[S])
IOb[S] Catch[S, X](IOb[S], F[X, IOb[S]])
IOb[R] CombineLatest[S, T, R](IOb[S], IOb[T], F[S, T, R])
IOb[S] Concat[S](IEn[IOb[S]])
IOb[S] Concat[S](IOb[IOb[S]])
IOb[S] Concat[S](IOb[S], IOb[S])
IOb[b] Contains[S](IOb[S], S, &IEC[S])
IOb[h] Count[S](IOb[S])
IOb[S] Create[S](F[IOr[S], Ac])
IOb[S] Create[S](F[IOr[S], IDp])
IOb[S] DefaultIfEmpty[S](IOb[S])
IOb[S] DefaultIfEmpty[S](IOb[S], S)
IOb[S] Defer[S](F[IOb[S]])
IOb[S] Delay[S](IOb[S], dt, &ISc)
IOb[S] Delay[S](IOb[S], t, &ISc)
IOb[S] Dematerialize[S](IOb[Not[S]])
IOb[S] Distinct[S](IOb[S], &IEC[S])
IOb[S] Distinct[S, K](IOb[S], F[S, K], & IEC[K])
IOb[S] DistinctUntilChanged[S](IOb[S], &IEC[S])
IOb[S] DistinctUntilChanged[S, K](IOb[S], F[S, K], &IEC[K])
IOb[S] Do[S](IOb[S], Ac[S])
IOb[S] Do[S](IOb[S], +IOr[S])
IOb[S] ElementAt[S](h)
IOb[S] ElementAtOrDefault[S](h)
IOb[R] Empty[R](&ISc)
IOb[S] Finally[S](IOb[S], Ac)
IOb[S] First[S](IOb[S])
IOb[S] First[S](IOb[S], P[S])
IOb[S] FirstOrDefault[S](IOb[S])
IOb[S] FirstOrDefault[S](IOb[S], P[S])
v ForEach[S](IOb[S])
v ForEach[S](IOb[S], +IOr[S])
F[IOb[u]] FromAsyncPattern(F[AC, o, IAR], Ac[IAR])
F[IOb[R]] FromAsyncPattern[R](F[AC, o, IAR], F[IAR, R])
F[IOb[u]] FromAsyncPattern[T1..Tn](F[T1..Tn, AC, o, IAR], Ac[IAR])
F[IOb[R]] FromAsyncPattern[T1..Tn, R](F[T1..Tn, AC, o, IAR], F[IAR, R])
IOb[u] FromEvent(Ac[Ac], Ac[Ac])
IOb[Ea] FromEvent[Ea](Ac[Ac[Ea]], Ac[Ac[Ea]])
IOb[Ea] FromEvent[D, Ea](Ac[D], Ac[D])
IOb[Ea] FromEvent[D, Ea](F[Ac[Ea], D], Ac[D], Ac[D])
IOb[Ep[Ea]] FromEventPattern(Ac[Eh], Ac[Eh])
IOb[Ep[Ea]] FromEventPattern(o, String)
IOb[Ep[Ea]] FromEventPattern(Type, String)
IOb[Ep[Ea]] FromEventPattern[Ea](Ac[Eh[Ea]], Ac[Eh[Ea]])
IOb[Ep[Ea]] FromEventPattern[Ea](o, String)
IOb[Ep[Ea]] FromEventPattern[Ea](Type, String)
IOb[Ep[Ea]] FromEventPattern[D, Ea](Ac[D], Ac[D])
IOb[Ep[Ea]] FromEventPattern[D, Ea](F[Eh[Ea], D], Ac[D], Ac[D])
IOb[R] Generate[Z, R](Z, P[Z], F[Z, Z], F[Z, R], &ISc)
IOb[R] Generate[Z, R](Z, P[Z], F[Z, Z], F[Z, R], F[Z, dt], &ISc)
IOb[R] Generate[Z, R](Z, P[Z], F[Z, Z], F[Z, R], F[Z, t], &ISc)
IEn[S] GetEnumerator[S](IOb[S])
IG[K, S] GroupBy[S, K](IOb[S], F[S, K], &IEC[K])
IG[K, E] GroupBy[S, K, E](IOb[S], F[S, K], F[S, E], &IEC[K])
IG[K, E] GroupByUntil[S, K, U](IOb[S], F[S, K], F[IG[K, S], IOb[U]], &IEC[K])
IG[K, E] GroupByUntil[S, K, E, U](IOb[S], F[S, K], F[S, E], F[IG[K, E], IOb[U]], &IEC[K])
IOb[E] GroupJoin[L, R, Ul, Ur, E](IOb[L], IOb[R], F[L, IOb[Ul]], F[R, Ur], F[L, IOb[Ur], E]])
IOb[S] IgnoreElements[S](IOb[S])
IOb[j] Interval(t, &ISc)
IOb[R] Join[L, R, Ul, Ur, E](IOb[L], IOb[R], F[L, Ul], F[R, Ur], F[L, R, E]])
S Last[S](IOb[S])
S Last[S](IOb[S], P[S])
S LastOrDefault[S](IOb[S])
S LastOrDefault[S](IOb[S], P[S])
IEn[S] Latest[S](IOb[S])
IOb[j] LongCount[S](IOb[S])
Not[S] Materialize[S](IOb[S])
IOb[n] Max(IOb[n])
IOb[S] Max[S](IOb[S], ICm[S])
IOb[S] MaxBy[S, K](IOb[S], F[S, K], &ICm[K])
IOb[S] Merge[S](&ISc, IOb[S][])
IOb[S] Merge[S](IEn[IOb[S]], &ISc)
IOb[S] Merge[S](IOb[IOb[S]])
IOb[S] Merge[S](IOb[IOb[S]], h)
IOb[S] Merge[S](IEn[IOb[S]], h, &ISc)
IOb[S] Merge[S](IOb[S], IOb[S], &ISc)
IOb[n] Min(IOb[n])
IOb[S] Min[S](IOb[S], ICm[S])
IOb[S] MinBy[S, K](IOb[S], F[S, K], &ICm[K])
IEn[S] MostRecent[S](IOb[S], S)
ICO[R] Multicast[S, R](IOb[S], ISb[S, R])
IOb[R] Multicast[S, M, R](IOb[S], F[ISb[S, M]], F[IOb[M], IOb[R]])
IOb[S] Never[S]()
IEn[S] Next[S](IOb[S])
IOb[S] ObserveOn[S](IOb[S], ISc)
IOb[S] ObserveOn[S](IOb[S], SC)
IOb[R] OfType[R](IOb[S])
IOb[S] OnErrorResumeNext[S](IOb[S], IOb[S])
IOb[S] OnErrorResumeNext[S](IOb[S][])
IOb[S] OnErrorResumeNext[S](IEn[IOb[S]])
ICO[S] Publish[S](IOb[S])
ICO[S] Publish[S](IOb[S], S)
ICO[R] Publish[S, R](IOb[S], F[IOb[S], IOb[R]])
ICO[R] Publish[S, R](IOb[S], F[IOb[S], IOb[R]], S)
ICO[R] PublishLast[S](IOb[S])
ICO[R] PublishLast[S, R](IOb[S], F[IOb[S], IOb[R]])
IOb[i] Range(h, h, &ISc)
IOb[S] RefCount[S](ICO[S])
IOb[S] Repeat[S](IOb[S])
IOb[R] Repeat[R](R, &ISc)
IOb[R] Repeat[S](IOb[S], h)
IOb[R] Repeat[R](R, h, &ISc)
ICO[S] Replay[S](IOb[S], &ISc)
ICO[S] Replay[S](IOb[S], h, &ISc)
ICO[S] Replay[S](IOb[S], t, &ISc)
ICO[S] Replay[S](IOb[S], h, t, &ISc)
ICO[R] Replay[S, R](IOb[S], F[IOb[S], IOb[R]], &ISc)
ICO[R] Replay[S, R](IOb[S], F[IOb[S], IOb[R]], h, &ISc)
ICO[R] Replay[S, R](IOb[S], F[IOb[S], IOb[R]], t, &ISc)
ICO[R] Replay[S, R](IOb[S], F[IOb[S], IOb[R]], h, t, &ISc)
IOb[S] Retry[S](IOb[S])
IOb[S] Retry[S](IOb[S], h)
IOb[R] Return[R](R, &ISc)
IOb[S] Sample[S](IOb[S], t, &ISc)
IOb[S] Sample[S, Ts](IOb[S], IOb[Ts])
IOb[S] Scan[S](IOb[S], F[S, S, S])
IOb[A] Scan[S, A](IOb[S], A, F[A, S, A])
IOb[R] Select[S, R](IOb[S], F[S, R])
IOb[R] Select[S, R](IOb[S], F[S, h, R])
IOb[R] SelectMany[S, R](IOb[S], F[S, IEn[R]])
IOb[R] SelectMany[S, R](IOb[S], F[S, IOb[R]])
IOb[Y] SelectMany[S, Y](IOb[S], IOb[Y])
IOb[R] SelectMany[S, R](IOb[S], F[S, IOb[R]], F[X, IOb[R]], F[IOb[R]])
IOb[R] SelectMany[S, C, R](IOb[S], F[S, IEn[C]], F[S, C, R])
IOb[R] SelectMany[S, C, R](IOb[S], F[S, IOb[C]], F[S, C, R])
IOb[b] SequenceEqual[S](IOb[S], IOb[S], &IEC[S])
S Single[S](IOb[S])
S Single[S](IOb[S], P[S])
S SingleOrDefault[S](IOb[S])
S SingleOrDefault[S](IOb[S], P[S])
IOb[S] Skip[S](IOb[S], h)
IOb[S] SkipLast[S](IOb[S], h)
IOb[S] SkipUntil[S, Y](IOb[S], IOb[Y])
IOb[S] SkipWhile[S](IOb[S], P[S])
IOb[S] SkipWhile[S](IOb[S], F[S, h, b])
IOb[u] Start(Ac, &ISc)
IOb[S] Start[S](F[S], &ISc)
IOb[S] StartWith[S](IOb[S], &ISc, S[])
IDp Subscribe[S](IEn[S], +IOr[S], &ISc)
IOb[S] SubscribeOn[S](IOb[S], ISc)
IOb[S] SubscribeOn[S](IOb[S], SC)
IOb[n] Sum(IOb[n])
IOb[S] Switch[S](IOb[S])
IOb[S] Synchronize[S](IOb[S])
IOb[S] Synchronize[S](IOb[S], o)
IOb[S] Take[S](IOb[S], h)
IOb[S] TakeLast[S](IOb[S], h)
IOb[S] TakeUntil[S, Y](IOb[S], IOb[Y])
IOb[S] TakeWhile[S](IOb[S], P[S])
IOb[S] TakeWhile[S](IOb[S], F[S, h, b])
Pl[R] Then[S, R](IOb[S], F[S, R])
IOb[S] Throttle[S](IOb[S], t, &ISc)
IOb[R] Throw[R](X, &ISc)
IOb[Ti[S]] TimeInterval[S](IOb[S], &ISc)
IOb[S] Timeout[S](IOb[S], dt, &ISc)
IOb[S] Timeout[S](IOb[S], t, &ISc)
IOb[S] Timeout[S](IOb[S], dt, IOb[S], &ISc)
IOb[S] Timeout[S](IOb[S], t, IOb[S], &ISc)
IOb[l] Timer(dt, &ISc)
IOb[l] Timer(t, &ISc)
IOb[l] Timer(dt, t, &ISc)
IOb[l] Timer(t, t, &ISc)
IOb[Ts[S]] Timestamp[S](IOb[S], &ISc)
IOb[S[]] ToArray[S](IOb[S])
F[IOb[u]] ToAsync(Ac)
F[T1..Tn, IOb[u]] ToAsync[T1..Tn](Ac[T1..Tn])
F[IOb[R]] ToAsync[R](F[R])
F[T1..Tn, IOb[R]] ToAsync[T1..Tn, R](F[T1..Tn, R])
F[IOb[u]] ToAsync(Ac, ISc)
F[T1..Tn, IOb[u]] ToAsync[T1..Tn](Ac[T1..Tn], ISc)
F[IOb[R]] ToAsync[R](F[R], ISc)
F[T1..Tn, IOb[R]] ToAsync[T1..Tn, R](F[T1..Tn, R], ISc)
IOb[IDi[K, S]] ToDictionary[S, K](IOb[S], F[S, K], &IEC[K])
IOb[IDi[K, E]] ToDictionary[S, K, E](IOb[S], F[S, K], F[S, E], &IEC[K])
IEn[S] ToEnumerable[S](IOb[S])
IES[S] ToEvent(IOb[u])
IES[S] ToEvent[S](IOb[S])
IEP[S] ToEventPattern[Ea](IOb[Ep[Ea]])
IOb[IL[S]] ToList[S](IOb[S])
ILu[S, K] ToLookup[S, K](IOb[S], F[S, K], &IEC[K])
ILu[S, E] ToLookup[S, K, E](IOb[S], F[S, K], F[S, E], IEC[K])
IOb[S] ToObservable[S](IEn[S], &ISc)
IOb[S] Using[S, IDp](F[IDp], F[IDp, IOb[S]])
IOb[R] When[R](IEn[Plan[R]])
IOb[R] When[R](Plan[R][])
IOb[S] Where[S](IOb[S], P[S])
IOb[S] Where[S](IOb[S], F[S, h, b])
IOb[IOb[S]] Window[S](IOb[S], h)
IOb[IOb[S]] Window[S](IOb[S], h, h)
IOb[IOb[S]] Window[S](IOb[S], t, &ISc)
IOb[IOb[S]] Window[S](IOb[S], t, h, &ISc)
IOb[IOb[S]] Window[S](IOb[S], t, t, &ISc)
IOb[IOb[S]] Window[S, Wc](IOb[S], F[IOb[Wc]])
IOb[IOb[S]] Window[S, Wo, Wc](IOb[S], IOb[Wo], F[Wo, IOb[Wc]])
IOb[R] Zip[T1, T2, R](IOb[T1], IEn[T2], F[T1, T2, R])
IOb[R] Zip[T1, T2, R](IOb[T1], IOb[T2], F[T1, T2, R])
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment