EDIT:
这是一个 F# 解决方案:
type DU =
| A
| B
type State = { AValue : int; BValue : int }
let solution2 (aObservable:IObservable<_>, bObservable:IObservable<_>) =
let union = aObservable.Select(fun _ -> A).Merge(bObservable.Select(fun _ -> B))
let result = union.Scan({AValue = 0; BValue = 1}, fun state du -> match du with
| A -> { state with AValue = state.AValue + state.BValue }
| B -> { state with BValue = state.AValue }
)
result
得益于内置的可区分联合和记录,F# 实际上是一种很棒的语言。这是用 C# 编写的答案,带有自定义的受歧视联盟;我的 F# 已经生锈了。
诀窍是使用可区分联合将两个可观察量转变为一个可观察量。所以基本上将 a 和 b 联合成一个受歧视联合的可观察值:
a : *---*---*---**
b : -*-*--*---*---
du: ab-ba-b-a-b-aa
完成后,您就可以对该项目是“A”推送还是“B”推送做出反应。
只是为了确认,我认为没有办法明确set嵌入在 Button/Button 中的值。如果有的话,这些变化应该被建模为可观察的,并且也被纳入受歧视的联盟中。
var a = new Subject<Unit>();
var b = new Subject<Unit>();
var observable = a.DiscriminatedUnion(b)
.Scan(new State(0, 1), (state, du) => du.Unify(
/* A clicked case */_ => new State(state.A + state.B, state.B),
/* B clicked case */_ => new State(state.A, state.A)
)
);
observable.Subscribe(state => Console.WriteLine($"a = {state.A}, b = {state.B}"));
a.OnNext(Unit.Default);
a.OnNext(Unit.Default);
a.OnNext(Unit.Default);
a.OnNext(Unit.Default);
b.OnNext(Unit.Default);
a.OnNext(Unit.Default);
a.OnNext(Unit.Default);
a.OnNext(Unit.Default);
a.OnNext(Unit.Default);
b.OnNext(Unit.Default);
这是 C# 中依赖的类。其中大部分可以轻松转换为内置 F# 类型。
public class State /*easily replaced with an F# record */
{
public State(int a, int b)
{
A = a;
B = b;
}
public int A { get; }
public int B { get; }
}
/* easily replaced with built-in discriminated unions and pattern matching */
public static class DiscriminatedUnionExtensions
{
public static IObservable<DiscriminatedUnionClass<T1, T2>> DiscriminatedUnion<T1, T2>(this IObservable<T1> a, IObservable<T2> b)
{
return Observable.Merge(
a.Select(t1 => DiscriminatedUnionClass<T1, T2>.Create(t1)),
b.Select(t2 => DiscriminatedUnionClass<T1, T2>.Create(t2))
);
}
public static IObservable<TResult> Unify<T1, T2, TResult>(this IObservable<DiscriminatedUnionClass<T1, T2>> source,
Func<T1, TResult> f1, Func<T2, TResult> f2)
{
return source.Select(union => Unify(union, f1, f2));
}
public static TResult Unify<T1, T2, TResult>(this DiscriminatedUnionClass<T1, T2> union, Func<T1, TResult> f1, Func<T2, TResult> f2)
{
return union.Item == 1
? f1(union.Item1)
: f2(union.Item2)
;
}
}
public class DiscriminatedUnionClass<T1, T2>
{
private readonly T1 _t1;
private readonly T2 _t2;
private readonly int _item;
private DiscriminatedUnionClass(T1 t1, T2 t2, int item)
{
_t1 = t1;
_t2 = t2;
_item = item;
}
public int Item
{
get { return _item; }
}
public T1 Item1
{
get { return _t1; }
}
public T2 Item2
{
get { return _t2; }
}
public static DiscriminatedUnionClass<T1, T2> Create(T1 t1)
{
return new DiscriminatedUnionClass<T1, T2>(t1, default(T2), 1);
}
public static DiscriminatedUnionClass<T1, T2> Create(T2 t2)
{
return new DiscriminatedUnionClass<T1, T2>(default(T1), t2, 2);
}
}