@epikodelabs/streamix / src/public-api / pipe
Function: pipe()
Call Signature
pipe<
T>(sources):Atom<T>
Defined in: projects/libraries/streamix/src/lib/atoms/pipe.ts:139
Builds an atom pipeline from a supported source.
Applies a chain of operators to a single PipeInput and lands the result back into an atom.
const evens = pipe(
range(1, 20),
filter(n => n % 2 === 0),
map(n => n * 10)
);You can also pass a tuple of atoms to combine them into a single atom whose values are tuples:
const combined = pipe([atom(1), atom('hello')]); // Atom<[number, string]>Up to 16 operators are fully typed via overloads. Beyond 16 operators, TypeScript falls back to the generic signature and the result type becomes Atom<any>.
Type Parameters
T
T extends readonly unknown[]
Parameters
sources
[...{ [K in string | number | symbol]: Atom<T[K]> }[]]
Returns
Atom<T>
A new Atom that emits the transformed values.
Call Signature
pipe<
T>(source):Atom<T>
Defined in: projects/libraries/streamix/src/lib/atoms/pipe.ts:140
Builds an atom pipeline from a supported source.
Applies a chain of operators to a single PipeInput and lands the result back into an atom.
const evens = pipe(
range(1, 20),
filter(n => n % 2 === 0),
map(n => n * 10)
);You can also pass a tuple of atoms to combine them into a single atom whose values are tuples:
const combined = pipe([atom(1), atom('hello')]); // Atom<[number, string]>Up to 16 operators are fully typed via overloads. Beyond 16 operators, TypeScript falls back to the generic signature and the result type becomes Atom<any>.
Type Parameters
T
T
Parameters
source
PipeInput<T>
Returns
Atom<T>
A new Atom that emits the transformed values.
Call Signature
pipe<
T,A>(source,op1):Atom<A>
Defined in: projects/libraries/streamix/src/lib/atoms/pipe.ts:141
Builds an atom pipeline from a supported source.
Applies a chain of operators to a single PipeInput and lands the result back into an atom.
const evens = pipe(
range(1, 20),
filter(n => n % 2 === 0),
map(n => n * 10)
);You can also pass a tuple of atoms to combine them into a single atom whose values are tuples:
const combined = pipe([atom(1), atom('hello')]); // Atom<[number, string]>Up to 16 operators are fully typed via overloads. Beyond 16 operators, TypeScript falls back to the generic signature and the result type becomes Atom<any>.
Type Parameters
T
T
A
A
Parameters
source
PipeInput<T>
op1
Operator<T, A>
Returns
Atom<A>
A new Atom that emits the transformed values.
Call Signature
pipe<
T,A,B>(source,op1,op2):Atom<B>
Defined in: projects/libraries/streamix/src/lib/atoms/pipe.ts:142
Builds an atom pipeline from a supported source.
Applies a chain of operators to a single PipeInput and lands the result back into an atom.
const evens = pipe(
range(1, 20),
filter(n => n % 2 === 0),
map(n => n * 10)
);You can also pass a tuple of atoms to combine them into a single atom whose values are tuples:
const combined = pipe([atom(1), atom('hello')]); // Atom<[number, string]>Up to 16 operators are fully typed via overloads. Beyond 16 operators, TypeScript falls back to the generic signature and the result type becomes Atom<any>.
Type Parameters
T
T
A
A
B
B
Parameters
source
PipeInput<T>
op1
Operator<T, A>
op2
Operator<A, B>
Returns
Atom<B>
A new Atom that emits the transformed values.
Call Signature
pipe<
T,A,B,C>(source,op1,op2,op3):Atom<C>
Defined in: projects/libraries/streamix/src/lib/atoms/pipe.ts:143
Builds an atom pipeline from a supported source.
Applies a chain of operators to a single PipeInput and lands the result back into an atom.
const evens = pipe(
range(1, 20),
filter(n => n % 2 === 0),
map(n => n * 10)
);You can also pass a tuple of atoms to combine them into a single atom whose values are tuples:
const combined = pipe([atom(1), atom('hello')]); // Atom<[number, string]>Up to 16 operators are fully typed via overloads. Beyond 16 operators, TypeScript falls back to the generic signature and the result type becomes Atom<any>.
Type Parameters
T
T
A
A
B
B
C
C
Parameters
source
PipeInput<T>
op1
Operator<T, A>
op2
Operator<A, B>
op3
Operator<B, C>
Returns
Atom<C>
A new Atom that emits the transformed values.
Call Signature
pipe<
T,A,B,C,D>(source,op1,op2,op3,op4):Atom<D>
Defined in: projects/libraries/streamix/src/lib/atoms/pipe.ts:144
Builds an atom pipeline from a supported source.
Applies a chain of operators to a single PipeInput and lands the result back into an atom.
const evens = pipe(
range(1, 20),
filter(n => n % 2 === 0),
map(n => n * 10)
);You can also pass a tuple of atoms to combine them into a single atom whose values are tuples:
const combined = pipe([atom(1), atom('hello')]); // Atom<[number, string]>Up to 16 operators are fully typed via overloads. Beyond 16 operators, TypeScript falls back to the generic signature and the result type becomes Atom<any>.
Type Parameters
T
T
A
A
B
B
C
C
D
D
Parameters
source
PipeInput<T>
op1
Operator<T, A>
op2
Operator<A, B>
op3
Operator<B, C>
op4
Operator<C, D>
Returns
Atom<D>
A new Atom that emits the transformed values.
Call Signature
pipe<
T,A,B,C,D,E>(source,op1,op2,op3,op4,op5):Atom<E>
Defined in: projects/libraries/streamix/src/lib/atoms/pipe.ts:145
Builds an atom pipeline from a supported source.
Applies a chain of operators to a single PipeInput and lands the result back into an atom.
const evens = pipe(
range(1, 20),
filter(n => n % 2 === 0),
map(n => n * 10)
);You can also pass a tuple of atoms to combine them into a single atom whose values are tuples:
const combined = pipe([atom(1), atom('hello')]); // Atom<[number, string]>Up to 16 operators are fully typed via overloads. Beyond 16 operators, TypeScript falls back to the generic signature and the result type becomes Atom<any>.
Type Parameters
T
T
A
A
B
B
C
C
D
D
E
E
Parameters
source
PipeInput<T>
op1
Operator<T, A>
op2
Operator<A, B>
op3
Operator<B, C>
op4
Operator<C, D>
op5
Operator<D, E>
Returns
Atom<E>
A new Atom that emits the transformed values.
Call Signature
pipe<
T,A,B,C,D,E,F>(source,op1,op2,op3,op4,op5,op6):Atom<F>
Defined in: projects/libraries/streamix/src/lib/atoms/pipe.ts:146
Builds an atom pipeline from a supported source.
Applies a chain of operators to a single PipeInput and lands the result back into an atom.
const evens = pipe(
range(1, 20),
filter(n => n % 2 === 0),
map(n => n * 10)
);You can also pass a tuple of atoms to combine them into a single atom whose values are tuples:
const combined = pipe([atom(1), atom('hello')]); // Atom<[number, string]>Up to 16 operators are fully typed via overloads. Beyond 16 operators, TypeScript falls back to the generic signature and the result type becomes Atom<any>.
Type Parameters
T
T
A
A
B
B
C
C
D
D
E
E
F
F
Parameters
source
PipeInput<T>
op1
Operator<T, A>
op2
Operator<A, B>
op3
Operator<B, C>
op4
Operator<C, D>
op5
Operator<D, E>
op6
Operator<E, F>
Returns
Atom<F>
A new Atom that emits the transformed values.
Call Signature
pipe<
T,A,B,C,D,E,F,G>(source,op1,op2,op3,op4,op5,op6,op7):Atom<G>
Defined in: projects/libraries/streamix/src/lib/atoms/pipe.ts:147
Builds an atom pipeline from a supported source.
Applies a chain of operators to a single PipeInput and lands the result back into an atom.
const evens = pipe(
range(1, 20),
filter(n => n % 2 === 0),
map(n => n * 10)
);You can also pass a tuple of atoms to combine them into a single atom whose values are tuples:
const combined = pipe([atom(1), atom('hello')]); // Atom<[number, string]>Up to 16 operators are fully typed via overloads. Beyond 16 operators, TypeScript falls back to the generic signature and the result type becomes Atom<any>.
Type Parameters
T
T
A
A
B
B
C
C
D
D
E
E
F
F
G
G
Parameters
source
PipeInput<T>
op1
Operator<T, A>
op2
Operator<A, B>
op3
Operator<B, C>
op4
Operator<C, D>
op5
Operator<D, E>
op6
Operator<E, F>
op7
Operator<F, G>
Returns
Atom<G>
A new Atom that emits the transformed values.
Call Signature
pipe<
T,A,B,C,D,E,F,G,H>(source,op1,op2,op3,op4,op5,op6,op7,op8):Atom<H>
Defined in: projects/libraries/streamix/src/lib/atoms/pipe.ts:148
Builds an atom pipeline from a supported source.
Applies a chain of operators to a single PipeInput and lands the result back into an atom.
const evens = pipe(
range(1, 20),
filter(n => n % 2 === 0),
map(n => n * 10)
);You can also pass a tuple of atoms to combine them into a single atom whose values are tuples:
const combined = pipe([atom(1), atom('hello')]); // Atom<[number, string]>Up to 16 operators are fully typed via overloads. Beyond 16 operators, TypeScript falls back to the generic signature and the result type becomes Atom<any>.
Type Parameters
T
T
A
A
B
B
C
C
D
D
E
E
F
F
G
G
H
H
Parameters
source
PipeInput<T>
op1
Operator<T, A>
op2
Operator<A, B>
op3
Operator<B, C>
op4
Operator<C, D>
op5
Operator<D, E>
op6
Operator<E, F>
op7
Operator<F, G>
op8
Operator<G, H>
Returns
Atom<H>
A new Atom that emits the transformed values.
Call Signature
pipe<
T,A,B,C,D,E,F,G,H,I>(source,op1,op2,op3,op4,op5,op6,op7,op8,op9):Atom<I>
Defined in: projects/libraries/streamix/src/lib/atoms/pipe.ts:149
Builds an atom pipeline from a supported source.
Applies a chain of operators to a single PipeInput and lands the result back into an atom.
const evens = pipe(
range(1, 20),
filter(n => n % 2 === 0),
map(n => n * 10)
);You can also pass a tuple of atoms to combine them into a single atom whose values are tuples:
const combined = pipe([atom(1), atom('hello')]); // Atom<[number, string]>Up to 16 operators are fully typed via overloads. Beyond 16 operators, TypeScript falls back to the generic signature and the result type becomes Atom<any>.
Type Parameters
T
T
A
A
B
B
C
C
D
D
E
E
F
F
G
G
H
H
I
I
Parameters
source
PipeInput<T>
op1
Operator<T, A>
op2
Operator<A, B>
op3
Operator<B, C>
op4
Operator<C, D>
op5
Operator<D, E>
op6
Operator<E, F>
op7
Operator<F, G>
op8
Operator<G, H>
op9
Operator<H, I>
Returns
Atom<I>
A new Atom that emits the transformed values.
Call Signature
pipe<
T,A,B,C,D,E,F,G,H,I,J>(source,op1,op2,op3,op4,op5,op6,op7,op8,op9,op10):Atom<J>
Defined in: projects/libraries/streamix/src/lib/atoms/pipe.ts:150
Builds an atom pipeline from a supported source.
Applies a chain of operators to a single PipeInput and lands the result back into an atom.
const evens = pipe(
range(1, 20),
filter(n => n % 2 === 0),
map(n => n * 10)
);You can also pass a tuple of atoms to combine them into a single atom whose values are tuples:
const combined = pipe([atom(1), atom('hello')]); // Atom<[number, string]>Up to 16 operators are fully typed via overloads. Beyond 16 operators, TypeScript falls back to the generic signature and the result type becomes Atom<any>.
Type Parameters
T
T
A
A
B
B
C
C
D
D
E
E
F
F
G
G
H
H
I
I
J
J
Parameters
source
PipeInput<T>
op1
Operator<T, A>
op2
Operator<A, B>
op3
Operator<B, C>
op4
Operator<C, D>
op5
Operator<D, E>
op6
Operator<E, F>
op7
Operator<F, G>
op8
Operator<G, H>
op9
Operator<H, I>
op10
Operator<I, J>
Returns
Atom<J>
A new Atom that emits the transformed values.
Call Signature
pipe<
T,A,B,C,D,E,F,G,H,I,J,K>(source,op1,op2,op3,op4,op5,op6,op7,op8,op9,op10,op11):Atom<K>
Defined in: projects/libraries/streamix/src/lib/atoms/pipe.ts:151
Builds an atom pipeline from a supported source.
Applies a chain of operators to a single PipeInput and lands the result back into an atom.
const evens = pipe(
range(1, 20),
filter(n => n % 2 === 0),
map(n => n * 10)
);You can also pass a tuple of atoms to combine them into a single atom whose values are tuples:
const combined = pipe([atom(1), atom('hello')]); // Atom<[number, string]>Up to 16 operators are fully typed via overloads. Beyond 16 operators, TypeScript falls back to the generic signature and the result type becomes Atom<any>.
Type Parameters
T
T
A
A
B
B
C
C
D
D
E
E
F
F
G
G
H
H
I
I
J
J
K
K
Parameters
source
PipeInput<T>
op1
Operator<T, A>
op2
Operator<A, B>
op3
Operator<B, C>
op4
Operator<C, D>
op5
Operator<D, E>
op6
Operator<E, F>
op7
Operator<F, G>
op8
Operator<G, H>
op9
Operator<H, I>
op10
Operator<I, J>
op11
Operator<J, K>
Returns
Atom<K>
A new Atom that emits the transformed values.
Call Signature
pipe<
T,A,B,C,D,E,F,G,H,I,J,K,L>(source,op1,op2,op3,op4,op5,op6,op7,op8,op9,op10,op11,op12):Atom<L>
Defined in: projects/libraries/streamix/src/lib/atoms/pipe.ts:152
Builds an atom pipeline from a supported source.
Applies a chain of operators to a single PipeInput and lands the result back into an atom.
const evens = pipe(
range(1, 20),
filter(n => n % 2 === 0),
map(n => n * 10)
);You can also pass a tuple of atoms to combine them into a single atom whose values are tuples:
const combined = pipe([atom(1), atom('hello')]); // Atom<[number, string]>Up to 16 operators are fully typed via overloads. Beyond 16 operators, TypeScript falls back to the generic signature and the result type becomes Atom<any>.
Type Parameters
T
T
A
A
B
B
C
C
D
D
E
E
F
F
G
G
H
H
I
I
J
J
K
K
L
L
Parameters
source
PipeInput<T>
op1
Operator<T, A>
op2
Operator<A, B>
op3
Operator<B, C>
op4
Operator<C, D>
op5
Operator<D, E>
op6
Operator<E, F>
op7
Operator<F, G>
op8
Operator<G, H>
op9
Operator<H, I>
op10
Operator<I, J>
op11
Operator<J, K>
op12
Operator<K, L>
Returns
Atom<L>
A new Atom that emits the transformed values.
Call Signature
pipe<
T,A,B,C,D,E,F,G,H,I,J,K,L,M>(source,op1,op2,op3,op4,op5,op6,op7,op8,op9,op10,op11,op12,op13):Atom<M>
Defined in: projects/libraries/streamix/src/lib/atoms/pipe.ts:153
Builds an atom pipeline from a supported source.
Applies a chain of operators to a single PipeInput and lands the result back into an atom.
const evens = pipe(
range(1, 20),
filter(n => n % 2 === 0),
map(n => n * 10)
);You can also pass a tuple of atoms to combine them into a single atom whose values are tuples:
const combined = pipe([atom(1), atom('hello')]); // Atom<[number, string]>Up to 16 operators are fully typed via overloads. Beyond 16 operators, TypeScript falls back to the generic signature and the result type becomes Atom<any>.
Type Parameters
T
T
A
A
B
B
C
C
D
D
E
E
F
F
G
G
H
H
I
I
J
J
K
K
L
L
M
M
Parameters
source
PipeInput<T>
op1
Operator<T, A>
op2
Operator<A, B>
op3
Operator<B, C>
op4
Operator<C, D>
op5
Operator<D, E>
op6
Operator<E, F>
op7
Operator<F, G>
op8
Operator<G, H>
op9
Operator<H, I>
op10
Operator<I, J>
op11
Operator<J, K>
op12
Operator<K, L>
op13
Operator<L, M>
Returns
Atom<M>
A new Atom that emits the transformed values.
Call Signature
pipe<
T,A,B,C,D,E,F,G,H,I,J,K,L,M,N>(source,op1,op2,op3,op4,op5,op6,op7,op8,op9,op10,op11,op12,op13,op14):Atom<N>
Defined in: projects/libraries/streamix/src/lib/atoms/pipe.ts:154
Builds an atom pipeline from a supported source.
Applies a chain of operators to a single PipeInput and lands the result back into an atom.
const evens = pipe(
range(1, 20),
filter(n => n % 2 === 0),
map(n => n * 10)
);You can also pass a tuple of atoms to combine them into a single atom whose values are tuples:
const combined = pipe([atom(1), atom('hello')]); // Atom<[number, string]>Up to 16 operators are fully typed via overloads. Beyond 16 operators, TypeScript falls back to the generic signature and the result type becomes Atom<any>.
Type Parameters
T
T
A
A
B
B
C
C
D
D
E
E
F
F
G
G
H
H
I
I
J
J
K
K
L
L
M
M
N
N
Parameters
source
PipeInput<T>
op1
Operator<T, A>
op2
Operator<A, B>
op3
Operator<B, C>
op4
Operator<C, D>
op5
Operator<D, E>
op6
Operator<E, F>
op7
Operator<F, G>
op8
Operator<G, H>
op9
Operator<H, I>
op10
Operator<I, J>
op11
Operator<J, K>
op12
Operator<K, L>
op13
Operator<L, M>
op14
Operator<M, N>
Returns
Atom<N>
A new Atom that emits the transformed values.
Call Signature
pipe<
T,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O>(source,op1,op2,op3,op4,op5,op6,op7,op8,op9,op10,op11,op12,op13,op14,op15):Atom<O>
Defined in: projects/libraries/streamix/src/lib/atoms/pipe.ts:155
Builds an atom pipeline from a supported source.
Applies a chain of operators to a single PipeInput and lands the result back into an atom.
const evens = pipe(
range(1, 20),
filter(n => n % 2 === 0),
map(n => n * 10)
);You can also pass a tuple of atoms to combine them into a single atom whose values are tuples:
const combined = pipe([atom(1), atom('hello')]); // Atom<[number, string]>Up to 16 operators are fully typed via overloads. Beyond 16 operators, TypeScript falls back to the generic signature and the result type becomes Atom<any>.
Type Parameters
T
T
A
A
B
B
C
C
D
D
E
E
F
F
G
G
H
H
I
I
J
J
K
K
L
L
M
M
N
N
O
O
Parameters
source
PipeInput<T>
op1
Operator<T, A>
op2
Operator<A, B>
op3
Operator<B, C>
op4
Operator<C, D>
op5
Operator<D, E>
op6
Operator<E, F>
op7
Operator<F, G>
op8
Operator<G, H>
op9
Operator<H, I>
op10
Operator<I, J>
op11
Operator<J, K>
op12
Operator<K, L>
op13
Operator<L, M>
op14
Operator<M, N>
op15
Operator<N, O>
Returns
Atom<O>
A new Atom that emits the transformed values.
Call Signature
pipe<
T,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P>(source,op1,op2,op3,op4,op5,op6,op7,op8,op9,op10,op11,op12,op13,op14,op15,op16):Atom<P>
Defined in: projects/libraries/streamix/src/lib/atoms/pipe.ts:156
Builds an atom pipeline from a supported source.
Applies a chain of operators to a single PipeInput and lands the result back into an atom.
const evens = pipe(
range(1, 20),
filter(n => n % 2 === 0),
map(n => n * 10)
);You can also pass a tuple of atoms to combine them into a single atom whose values are tuples:
const combined = pipe([atom(1), atom('hello')]); // Atom<[number, string]>Up to 16 operators are fully typed via overloads. Beyond 16 operators, TypeScript falls back to the generic signature and the result type becomes Atom<any>.
Type Parameters
T
T
A
A
B
B
C
C
D
D
E
E
F
F
G
G
H
H
I
I
J
J
K
K
L
L
M
M
N
N
O
O
P
P
Parameters
source
PipeInput<T>
op1
Operator<T, A>
op2
Operator<A, B>
op3
Operator<B, C>
op4
Operator<C, D>
op5
Operator<D, E>
op6
Operator<E, F>
op7
Operator<F, G>
op8
Operator<G, H>
op9
Operator<H, I>
op10
Operator<I, J>
op11
Operator<J, K>
op12
Operator<K, L>
op13
Operator<L, M>
op14
Operator<M, N>
op15
Operator<N, O>
op16
Operator<O, P>
Returns
Atom<P>
A new Atom that emits the transformed values.
Call Signature
pipe<
T>(source, ...ops):Atom<any>
Defined in: projects/libraries/streamix/src/lib/atoms/pipe.ts:157
Builds an atom pipeline from a supported source.
Applies a chain of operators to a single PipeInput and lands the result back into an atom.
const evens = pipe(
range(1, 20),
filter(n => n % 2 === 0),
map(n => n * 10)
);You can also pass a tuple of atoms to combine them into a single atom whose values are tuples:
const combined = pipe([atom(1), atom('hello')]); // Atom<[number, string]>Up to 16 operators are fully typed via overloads. Beyond 16 operators, TypeScript falls back to the generic signature and the result type becomes Atom<any>.
Type Parameters
T
T
Parameters
source
PipeInput<T>
ops
...Operator[]
Returns
Atom<any>
A new Atom that emits the transformed values.