Added extra Or functions

Author: MorleyDev

src/MorleyDev.Reactive.Monad/Extensions/MaybeExtensions.cs

@@ -1,15 +1,19 @@
-using System.Reactive.Linq;
+using System.Linq;
 
 namespace MorleyDev.Reactive.Monad.Extensions
 {
 	public static class MaybeExtensions
 	{
+		public static LazyValue<T> Or<T>(this Maybe<T> self, T rhs) => LazyValue.Defer(Maybe<T>.Or(self, Maybe.Just(rhs)).Single);
+
+		public static LazyValue<T> Or<T>(this Maybe<T> self, LazyValue<T> rhs) => LazyValue.Defer(Maybe<T>.Or(self, Maybe.Defer(() => Maybe.Just(rhs.Single()))).Single);
+
 		public static Maybe<T> Or<T>(this Maybe<T> self, Maybe<T> rhs) => Maybe<T>.Or(self, rhs);
 
 		public static MaybeIO<T> Or<T>(this Maybe<T> self, MaybeIO<T> rhs) => MaybeIO<T>.Or(self, rhs);
 
-		public static MaybeIO<T> Or<T>(this Maybe<T> self, IO<T> rhs) => MaybeIO<T>.Or(self, rhs);
+		public static IO<T> Or<T>(this Maybe<T> self, IO<T> rhs) => MaybeIO<T>.Or(self, rhs);
 
-		public static MaybeIO<T> ToMaybeIO<T>(this Maybe<IO<T>> self) => self.ToObservable().SelectMany(io => io.AsObservable()).ToMaybeIO();
+		public static MaybeIO<T> ToMaybeIO<T>(this Maybe<T> self) => MaybeIO.From(self);
 	}
 }

src/MorleyDev.Reactive.Monad/Extensions/MaybeIOExtensions.cs

@@ -6,6 +6,10 @@ public static class MaybeIOExtensions
 
 		public static MaybeIO<T> Or<T>(this MaybeIO<T> self, Maybe<T> rhs) => MaybeIO<T>.Or(self, rhs);
 
-		public static MaybeIO<T> Or<T>(this MaybeIO<T> self, IO<T> rhs) => MaybeIO<T>.Or(self, rhs);
+		public static IO<T> Or<T>(this MaybeIO<T> self, IO<T> rhs) => MaybeIO<T>.Or(self, rhs);
+
+		public static IO<T> Or<T>(this MaybeIO<T> self, LazyValue<T> rhs) => MaybeIO<T>.Or(self, IO.From(rhs));
+
+		public static IO<T> Or<T>(this MaybeIO<T> self, T rhs) => MaybeIO<T>.Or(self, IO.Return(rhs));
 	}
 }

src/MorleyDev.Reactive.Monad/IO.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Reactive;
 using System.Reactive.Linq;
 using System.Reactive.Threading.Tasks;
@@ -43,6 +44,13 @@ public static class IO
 		/// <returns></returns>
 		public static IO<T> From<T>(IObservable<T> unsafeIO) => IO<T>.From(unsafeIO);
 
+		/// <summary>
+		/// Wraps an Asynchronous observable into an asynchronous IO
+		/// </summary>
+		/// <param name="unsafeIO"></param>
+		/// <returns></returns>
+		public static IO<T> From<T>(IEnumerable<T> unsafeIO) => IO<T>.From(unsafeIO.ToObservable());
+
 		/// <summary>
 		/// Returns an IO that contains the specified value
 		/// </summary>

src/MorleyDev.Reactive.Monad/Maybe.cs

@@ -60,12 +60,25 @@ public class Maybe<T> : IEnumerable<T>
 		/// <returns></returns>
 		public static Maybe<T> Or(Maybe<T> lhs, Maybe<T> rhs) => new Maybe<T>(lhs.Concat(rhs).Take(1));
 
+		/// <summary>Retrieve the option on the left if it has a value, the otherwise the option on the right (None if both are empty)</summary>
+		/// <param name="lhs"></param>
+		/// <param name="rhs"></param>
+		/// <returns></returns>
+		public static LazyValue<T> Or(Maybe<T> lhs, T rhs) => LazyValue.Defer(lhs.Concat(new[] { rhs }).Take(1).Single);
+
+		/// <summary>Retrieve the option on the left if it has a value, the otherwise the option on the right (None if both are empty)</summary>
+		/// <param name="lhs"></param>
+		/// <param name="rhs"></param>
+		/// <returns></returns>
+		public static LazyValue<T> Or(Maybe<T> lhs, LazyValue<T> rhs) => LazyValue.Defer(lhs.Concat(rhs).Take(1).Single);
+
+		/// <summary></summary>
+		/// <param name="self"></param>
+		/// <returns></returns>
 		public static Maybe<T> From(IEnumerable<T> self) => new Maybe<T>(self);
 
 		public LazyValue<U> Match<U>(Func<T, U> some, Func<U> none)
-		{
-			return LazyValue<U>.From(MatchInner(some, none).First);
-		}
+			=> LazyValue<U>.From(MatchInner(some, none).First);
 
 		private IEnumerable<U> MatchInner<U>(Func<T, U> some, Func<U> none)
 		{

src/MorleyDev.Reactive.Monad/MaybeIO.cs

@@ -89,14 +89,13 @@ public IDisposable Subscribe(IObserver<T> observer)
 		/// <param name="lhs"></param>
 		/// <param name="rhs"></param>
 		/// <returns></returns>
-		public static MaybeIO<T> Or(Maybe<T> lhs, IO<T> rhs) => IO.From(lhs.ToObservable().Concat(rhs).Take(1).Select(Maybe.Just).DefaultIfEmpty(Maybe.None));
-
+		public static IO<T> Or(Maybe<T> lhs, IO<T> rhs) => IO.From(lhs.ToObservable().Concat(rhs).Take(1));
 
 		/// <summary>Retrieve the option on the left if it has a value, the otherwise the option on the right (None if both are empty)</summary>
 		/// <param name="lhs"></param>
 		/// <param name="rhs"></param>
 		/// <returns></returns>
-		public static MaybeIO<T> Or(MaybeIO<T> lhs, IO<T> rhs) => IO.From(lhs.Concat(rhs).Take(1).Select(Maybe.Just).DefaultIfEmpty(Maybe.None));
+		public static IO<T> Or(MaybeIO<T> lhs, IO<T> rhs) => IO.From(lhs.Concat(rhs).Take(1));
 
 		public IO<U> Match<U>(Func<T, U> some, Func<U> none)
 			=> IO.From(