public static IRxVal <Tpl <A, A1, A2, A3, A4, A5> > zip <A, A1, A2, A3, A4, A5>(
this IRxVal <A> ref1, IRxVal <A1> ref2, IRxVal <A2> ref3, IRxVal <A3> ref4, IRxVal <A4> ref5,
IRxVal <A5> ref6
) => RxVal.a(
() => F.t(ref1.value, ref2.value, ref3.value, ref4.value, ref5.value, ref6.value),
ObservableOpImpls.zip(ref1, ref2, ref3, ref4, ref5, ref6)
);
public IRxVal <Tpl <A, B, C, D> > zip <B, C, D>(
IRxVal <B> ref2, IRxVal <C> ref3, IRxVal <D> ref4
)
{
return(zipImpl(
ref2, ref3, ref4, RxVal.builder(() => F.t(currentValue, ref2.value, ref3.value, ref4.value))
));
}
public static IRxVal <Option <B> > optFlatMap <A, B>(
this IRxVal <Option <A> > source, Fn <A, IRxVal <Option <B> > > extractor
) =>
source.flatMap(aOpt =>
aOpt.fold(
() => RxVal.cached(F.none <B>()),
extractor
)
);
public IRxVal <Tpl <A, A1, A2, A3, A4, A5> > zip <A1, A2, A3, A4, A5>(
IRxVal <A1> ref2, IRxVal <A2> ref3, IRxVal <A3> ref4, IRxVal <A4> ref5, IRxVal <A5> ref6
)
{
return(zipImpl(
ref2, ref3, ref4, ref5, ref6,
RxVal.builder(() => F.t(currentValue, ref2.value, ref3.value, ref4.value, ref5.value, ref6.value))
));
}
public void ctor() => describe(() => {
var mapperInvocations = 0;
var actionInvocations = 0;
var lastActionResult = 0;
IRxRef <Tpl <int, int> > src = null;
IRxVal <int> rx = null;
beforeEach += () => {
mapperInvocations = 0;
actionInvocations = 0;
src = RxRef.a(F.t(10, 0));
rx = new RxVal <int>(
-11,
setValue => src.subscribeWithoutEmit(tracker, t => {
mapperInvocations++;
setValue(t._1 + t._2 + 1);
})
);
rx.subscribe(tracker, i => {
actionInvocations++;
lastActionResult = i;
});
};
on["creation"] = () => {
it["should create a subscription to source"] = () => src.subscribers.shouldEqual(1);
it["should not invoke mapper"] = () => mapperInvocations.shouldEqual(0);
it["should have specified value"] = () => rx.value.shouldEqual(-11);
it["should invoke action"] = () => actionInvocations.shouldEqual(1);
it["should invoke action with current value"] = () => lastActionResult.shouldEqual(-11);
when["source changes"] = () => {
beforeEach += () => src.value = F.t(2, 3);
it["should invoke mapper"] = () => mapperInvocations.shouldEqual(1);
it["should update value"] = () => rx.value.shouldEqual(6);
it["should invoke action"] = () => actionInvocations.shouldEqual(2);
it["should invoke action with recomputed value"] = () => lastActionResult.shouldEqual(6);
when["source changes, but transformation result is the same"] = () => {
beforeEach += () => src.value = F.t(3, 2);
it["should invoke mapper"] = () => mapperInvocations.shouldEqual(2);
it["should keep the value same"] = () => rx.value.shouldEqual(6);
it["should not invoke action"] = () => actionInvocations.shouldEqual(2);
};
};
};
});
public static IRxVal <B> map <A, B>(this IRxVal <A> rx, Fn <A, B> mapper) => RxVal.a(() => mapper(rx.value), ObservableOpImpls.map(rx, mapper));
public static IRxVal <Tpl <A, B, C, D, E> > zip <A, B, C, D, E>(
this IRxVal <A> ref1, IRxVal <B> ref2, IRxVal <C> ref3, IRxVal <D> ref4, IRxVal <E> ref5
) => RxVal.a(
() => F.t(ref1.value, ref2.value, ref3.value, ref4.value, ref5.value),
ObservableOpImpls.zip(ref1, ref2, ref3, ref4, ref5)
);
public static IRxVal <Tpl <A, B, C> > zip <A, B, C>(
this IRxVal <A> rx, IRxVal <B> rx2, IRxVal <C> rx3
) => RxVal.a(
() => F.t(rx.value, rx2.value, rx3.value),
ObservableOpImpls.zip(rx, rx2, rx3)
);
public static IRxVal <A> filter <A>(this IRxVal <A> rx, Fn <A, bool> predicate, A onFiltered) => rx.map(RxVal.filterMapper(predicate, onFiltered));
// Convert this observable to reactive value with given initial value. public static IRxVal <A> toRxVal <A>(this IObservable <A> o, A initial) => RxVal.a(initial, o.subscribe);
public static IRxVal <Option <A> > extract <A>(this Option <IRxVal <A> > rxOpt) => rxOpt.fold(RxVal.cached(F.none <A>()), val => val.map(a => a.some()));
public static IRxVal <Option <B> > optFlatMap <A, B>(
this IRxVal <Option <A> > source, Fn <A, Option <IRxVal <Option <B> > > > extractor
) =>
source.flatMap(aOpt =>
aOpt.flatMap(extractor).getOrElse(RxVal.cached(F.none <B>()))
);
public IRxVal <Tpl <A, B> > zip <B>(IRxVal <B> ref2)
{
return(zipImpl(ref2, RxVal.builder(() => F.t(currentValue, ref2.value))));
}
public IRxVal <A> filter(Fn <A, bool> predicate, A onFiltered)
{
return(map(RxVal.filterMapper(predicate, onFiltered)));
}
public IRxVal <B> flatMap <B>(Fn <A, IRxVal <B> > mapper)
{
return(flatMapImpl(mapper, RxVal.builder(() => mapper(currentValue).value)));
}
public new IRxVal <B> map <B>(Fn <A, B> mapper)
{
return(mapImpl(mapper, RxVal.builder(() => mapper(currentValue))));
}