Skip to content

Commit b72374f

Browse files
MorleyDevMorleyDev
committed
Added more IO variants, and a SelectMany Linq2Reactive implementation
1 parent e9593b5 commit b72374f

File tree

1 file changed

+57
-4
lines changed

1 file changed

+57
-4
lines changed

‎src/MorleyDev.Reactive.Monad/LinqExtensions.cs‎

Lines changed: 57 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -80,16 +80,20 @@ public static IObservable<T> Using<T, TDisposable>(Func<TDisposable> factory, Fu
8080
where TDisposable : IDisposable
8181
=> (Observable.Using(factory, disposable => method(disposable)));
8282

83+
public static IO<T> Throw<T>(Exception value)
84+
=> MorleyDev.Reactive.Monad.IO.From(Observable.Throw<T>(value));
85+
8386
public static IO<T> Return<T>(T value) => MorleyDev.Reactive.Monad.IO.Return(value);
8487
public static MaybeIO<T> Return<T>(Maybe<T> value) => MorleyDev.Reactive.Monad.IO.Return(value);
88+
8589
public static IO<T> Run<T>(Func<T> value) => MorleyDev.Reactive.Monad.IO.Run(value);
8690
public static IO<Unit> Run(Action value) => MorleyDev.Reactive.Monad.IO.Run(value);
91+
public static MaybeIO<T> Run<T>(Func<Maybe<T>> value) => MorleyDev.Reactive.Monad.IO.Run(value);
92+
8793
public static IO<T> Defer<T>(Func<Task<T>> value) => MorleyDev.Reactive.Monad.IO.Defer(value);
8894
public static IO<Unit> Defer(Func<Task> value) => MorleyDev.Reactive.Monad.IO.Defer(async () => { await value(); return Unit.Default; });
89-
public static MaybeIO<T> Run<T>(Func<Maybe<T>> value) => MorleyDev.Reactive.Monad.IO.Run(value);
9095
public static MaybeIO<T> Defer<T>(Func<Task<Maybe<T>>> value) => MorleyDev.Reactive.Monad.IO.Defer(value);
9196
public static MaybeIO<T> Defer<T>(Func<IO<Maybe<T>>> value) => MorleyDev.Reactive.Monad.IO.Defer(value);
92-
9397
public static IO<T> Defer<T>(Func<IO<T>> value) => MorleyDev.Reactive.Monad.IO.Defer(value);
9498
public static MaybeIO<T> Defer<T>(Func<MaybeIO<T>> value) => MorleyDev.Reactive.Monad.MaybeIO.Defer(value);
9599
public static IObservable<T> Defer<T>(Func<IObservable<T>> value) => Observable.Defer(value);
@@ -118,17 +122,28 @@ public static IObservable<T> Using<T, TDisposable>(Func<TDisposable> factory, Fu
118122
public static IObservable<U> SelectMany<U, T>(this IObservable<T> self, Func<T, IObservable<Maybe<U>>> mapper) => Observable.AsObservable(self).SelectMany(value => mapper(value).SelectMany(maybe => maybe));
119123
public static MaybeIO<T> FirstOrNone<T>(this IObservable<T> self) => MaybeIO.From(Observable.AsObservable(self).Take(1));
120124
public static IO<T> SingleIO<T>(this IObservable<T> self) => MorleyDev.Reactive.Monad.IO.From(Observable.AsObservable(self).SingleAsync());
125+
public static IO<bool> AnyIO<T>(this IObservable<T> self) => MorleyDev.Reactive.Monad.IO.From(Observable.AsObservable(self).Any());
126+
public static IO<bool> AnyIO<T>(this IObservable<T> self, Func<T, bool> predicate) => MorleyDev.Reactive.Monad.IO.From(Observable.AsObservable(self).Any(predicate));
127+
public static IO<bool> AllIO<T>(this IObservable<T> self, Func<T, bool> predicate) => MorleyDev.Reactive.Monad.IO.From(Observable.AsObservable(self).All(predicate));
128+
public static IO<bool> ContainsIO<T>(this IObservable<T> self, T value) => MorleyDev.Reactive.Monad.IO.From(Observable.AsObservable(self).Contains(value));
121129
public static IO<bool> IsEmptyIO<T>(this IObservable<T> self) => MorleyDev.Reactive.Monad.IO.From(Observable.AsObservable(self).IsEmpty());
122130
public static IO<T[]> ToArrayIO<T>(this IObservable<T> self) => MorleyDev.Reactive.Monad.IO.From(Observable.AsObservable(self).ToArray());
123131
public static IO<IList<T>> ToListIO<T>(this IObservable<T> self) => MorleyDev.Reactive.Monad.IO.From(Observable.AsObservable(self).ToList());
124132

125133
public static IO<T> Do<T>(this IO<T> self, Action<T> actor) => MorleyDev.Reactive.Monad.IO.From(self.AsObservable().Do(actor));
126134
public static MaybeIO<T> Do<T>(this MaybeIO<T> self, Action<T> actor) => MaybeIO.From(self.AsObservable().Do(actor));
127135

136+
public static IO<T> Delay<T>(this IO<T> self, TimeSpan offset) => MorleyDev.Reactive.Monad.IO.From(self.AsObservable().Delay(offset));
137+
public static MaybeIO<T> Delay<T>(this MaybeIO<T> self, TimeSpan offset) => MaybeIO.From(self.AsObservable().Delay(offset));
138+
public static IO<T> DelaySubscription<T>(this IO<T> self, TimeSpan offset) => MorleyDev.Reactive.Monad.IO.From(self.AsObservable().DelaySubscription(offset));
139+
public static MaybeIO<T> DelaySubscription<T>(this MaybeIO<T> self, TimeSpan offset) => MaybeIO.From(self.AsObservable().DelaySubscription(offset));
140+
141+
public static MaybeIO<T> Catch<T, TException>(this MaybeIO<T> self, Func<TException, Task<T>> catcher) where TException : Exception => MaybeIO.From(self.AsObservable().Catch((TException ex) => catcher(ex).ToObservable()));
128142
public static MaybeIO<T> Catch<T, TException>(this MaybeIO<T> self, Func<TException, IO<T>> catcher) where TException : Exception => MaybeIO.From(self.AsObservable().Catch((TException ex) => catcher(ex)));
129143
public static MaybeIO<T> Catch<T, TException>(this MaybeIO<T> self, Func<TException, MaybeIO<T>> catcher) where TException : Exception => MaybeIO.From(self.AsObservable().Catch((TException ex) => catcher(ex)));
130144
public static IO<T> Catch<T, TException>(this IO<T> self, Func<TException, IO<T>> catcher) where TException : Exception => MorleyDev.Reactive.Monad.IO.From(self.AsObservable().Catch((TException ex) => catcher(ex)));
131145
public static MaybeIO<T> Catch<T, TException>(this IO<T> self, Func<TException, MaybeIO<T>> catcher) where TException : Exception => MaybeIO.From(self.AsObservable().Catch((TException ex) => catcher(ex)));
146+
public static IO<T> Catch<T, TException>(this IO<T> self, Func<TException, Task<T>> catcher) where TException : Exception => MorleyDev.Reactive.Monad.IO.From(self.AsObservable().Catch((TException ex) => catcher(ex).ToObservable()));
132147

133148
public static IO<U> Zip<U, T1, T2>(this IO<T1> lhs, IO<T2> rhs, Func<T1, T2, U> mapper) => MorleyDev.Reactive.Monad.IO.From(lhs.AsObservable().Zip(rhs.AsObservable(), mapper));
134149
public static MaybeIO<U> Zip<U, T1, T2>(this IO<T1> lhs, MaybeIO<T2> rhs, Func<T1, T2, U> mapper) => MaybeIO.From(lhs.AsObservable().Zip(rhs.AsObservable(), mapper));
@@ -159,9 +174,47 @@ public static IObservable<T> Using<T, TDisposable>(Func<TDisposable> factory, Fu
159174
public static MaybeIO<(T1,T2)> CombineLatest<T1, T2>(this MaybeIO<T1> lhs, MaybeIO<T2> rhs) => CombineLatest(lhs, rhs, (l, r) => (l, r));
160175

161176
public static IO<TSource> AggregateIO<TSource>(this IObservable<TSource> self, Func<TSource, TSource, TSource> reducer)
162-
=> self.Aggregate(reducer).SingleIO();
177+
=> MorleyDev.Reactive.Monad.IO.From(self.Aggregate(reducer));
163178

164179
public static IO<TAccumulate> AggregateIO<TSource, TAccumulate>(this IObservable<TSource> self, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> reducer)
165-
=> self.Aggregate(seed, reducer).SingleIO();
180+
=> MorleyDev.Reactive.Monad.IO.From(self.Aggregate(seed, reducer));
181+
182+
public static IO<double> AverageIO(this IObservable<int> self) => MorleyDev.Reactive.Monad.IO.From(self.Average());
183+
public static IO<double> AverageIO(this IObservable<long> self) => MorleyDev.Reactive.Monad.IO.From(self.Average());
184+
public static IO<double> AverageIO(this IObservable<double> self) => MorleyDev.Reactive.Monad.IO.From(self.Average());
185+
public static IO<float> AverageIO(this IObservable<float> self) => MorleyDev.Reactive.Monad.IO.From(self.Average());
186+
public static IO<decimal> AverageIO(this IObservable<decimal> self) => MorleyDev.Reactive.Monad.IO.From(self.Average());
187+
188+
public static IO<double?> AverageIO(this IObservable<int?> self) => MorleyDev.Reactive.Monad.IO.From(self.Average());
189+
public static IO<double?> AverageIO(this IObservable<long?> self) => MorleyDev.Reactive.Monad.IO.From(self.Average());
190+
public static IO<double?> AverageIO(this IObservable<double?> self) => MorleyDev.Reactive.Monad.IO.From(self.Average());
191+
public static IO<float?> AverageIO(this IObservable<float?> self) => MorleyDev.Reactive.Monad.IO.From(self.Average());
192+
public static IO<decimal?> AverageIO(this IObservable<decimal?> self) => MorleyDev.Reactive.Monad.IO.From(self.Average());
193+
194+
public static IO<double> AverageIO<T>(this IObservable<T> self, Func<T, int> mapper) => MorleyDev.Reactive.Monad.IO.From(self.Average(mapper));
195+
public static IO<double> AverageIO<T>(this IObservable<T> self, Func<T, long> mapper) => MorleyDev.Reactive.Monad.IO.From(self.Average(mapper));
196+
public static IO<double> AverageIO<T>(this IObservable<T> self, Func<T, double> mapper) => MorleyDev.Reactive.Monad.IO.From(self.Average(mapper));
197+
public static IO<float> AverageIO<T>(this IObservable<T> self, Func<T, float> mapper) => MorleyDev.Reactive.Monad.IO.From(self.Average(mapper));
198+
public static IO<decimal> AverageIO<T>(this IObservable<T> self, Func<T, decimal> mapper) => MorleyDev.Reactive.Monad.IO.From(self.Average(mapper));
199+
200+
public static IO<double?> AverageIO<T>(this IObservable<T> self, Func<T, int?> mapper) => MorleyDev.Reactive.Monad.IO.From(self.Average(mapper));
201+
public static IO<double?> AverageIO<T>(this IObservable<T> self, Func<T, long?> mapper) => MorleyDev.Reactive.Monad.IO.From(self.Average(mapper));
202+
public static IO<double?> AverageIO<T>(this IObservable<T> self, Func<T, double?> mapper) => MorleyDev.Reactive.Monad.IO.From(self.Average(mapper));
203+
public static IO<float?> AverageIO<T>(this IObservable<T> self, Func<T, float?> mapper) => MorleyDev.Reactive.Monad.IO.From(self.Average(mapper));
204+
public static IO<decimal?> AverageIO<T>(this IObservable<T> self, Func<T, decimal?> mapper) => MorleyDev.Reactive.Monad.IO.From(self.Average(mapper));
205+
206+
public static IO<T> ElementAtIO<T>(this IObservable<T> self, int index) => MorleyDev.Reactive.Monad.IO.From(self.ElementAt(index));
207+
public static IO<T> ElementAtOrDefaultIO<T>(this IObservable<T> self, int index) => MorleyDev.Reactive.Monad.IO.From(self.ElementAtOrDefault(index));
208+
public static MaybeIO<T> ElementAtOrNone<T>(this IObservable<T> self, int index) => MorleyDev.Reactive.Monad.MaybeIO.From(self.Skip(index).Take(1));
209+
}
210+
211+
public static class Linq2Reactive
212+
{
213+
public static IObservable<U> SelectMany<T, U>(this IEnumerable<T> self, Func<T, IObservable<U>> mapper) => self.ToObservable().SelectMany(mapper);
214+
public static IO<U> SelectMany<T, U>(this LazyValue<T> self, Func<T, IO<U>> mapper) => MorleyDev.Reactive.Monad.IO.From(self).SelectMany(mapper);
215+
public static MaybeIO<U> SelectMany<T, U>(this LazyValue<T> self, Func<T, MaybeIO<U>> mapper) => MorleyDev.Reactive.Monad.IO.From(self).SelectMany(mapper);
216+
217+
public static MaybeIO<U> SelectMany<T, U>(this Maybe<T> self, Func<T, IO<U>> mapper) => MorleyDev.Reactive.Monad.MaybeIO.From(self).SelectMany(mapper);
218+
public static MaybeIO<U> SelectMany<T, U>(this Maybe<T> self, Func<T, MaybeIO<U>> mapper) => MorleyDev.Reactive.Monad.IO.From(self).SelectMany(mapper);
166219
}
167220
}

0 commit comments

Comments
 (0)