Add alt for AsyncResult

Author: mlms13

__tests__/Relude_AsyncResult_test.re

@@ -1090,6 +1090,98 @@ describe("AsyncResult", () => {
     |> toEqual(13)
   );
 
+  test("alt (Init, Init)", () =>
+    AsyncResult.(alt(Init, Init) |> expect |> toEqual(init))
+  );
+
+  test("alt (Init, Loading)", () =>
+    AsyncResult.(alt(Init, Loading) |> expect |> toEqual(loading))
+  );
+
+  test("alt (Init, Reloading(Error))", () =>
+    AsyncResult.(alt(Init, Reloading(Error(0))) |> expect |> toEqual(init))
+  );
+
+  test("alt (Init, Reloading(Ok))", () =>
+    AsyncResult.(
+      alt(Init, Reloading(Ok(0))) |> expect |> toEqual(reloadingOk(0))
+    )
+  );
+
+  test("alt (Init, Complete(Error))", () =>
+    AsyncResult.(alt(Init, Complete(Error(0))) |> expect |> toEqual(init))
+  );
+
+  test("alt (Init, Complete(Ok))", () =>
+    AsyncResult.(
+      alt(Init, Complete(Ok(0))) |> expect |> toEqual(completeOk(0))
+    )
+  );
+
+  test("alt (Loading, Init)", () =>
+    AsyncResult.(alt(Loading, Init) |> expect |> toEqual(loading))
+  );
+
+  test("alt (Reloading(Error), Init)", () =>
+    AsyncResult.(alt(Reloading(Error(1)), Init) |> expect |> toEqual(init))
+  );
+
+  test("alt (Reloading(Error), Loading)", () =>
+    AsyncResult.(
+      alt(Reloading(Error(1)), Loading) |> expect |> toEqual(loading)
+    )
+  );
+
+  test("alt (Reloading(Error), Reloading(Error))", () =>
+    AsyncResult.(
+      alt(Reloading(Error(1)), Reloading(Error(2)))
+      |> expect
+      |> toEqual(reloadingError(1))
+    )
+  );
+
+  test("alt (Reloading(Error), Complete(Error))", () =>
+    AsyncResult.(
+      alt(Reloading(Error(1)), Complete(Error(2)))
+      |> expect
+      |> toEqual(completeError(2))
+    )
+  );
+
+  test("alt (Complete(Error), Init)", () =>
+    AsyncResult.(alt(Complete(Error(1)), Init) |> expect |> toEqual(init))
+  );
+
+  test("alt (Complete(Error), Loading)", () =>
+    AsyncResult.(
+      alt(Complete(Error(1)), Loading) |> expect |> toEqual(loading)
+    )
+  );
+
+  test("alt (Complete(Error), Reloading(Error))", () =>
+    AsyncResult.(
+      alt(Complete(Error(1)), Reloading(Error(2)))
+      |> expect
+      |> toEqual(completeError(1))
+    )
+  );
+
+  test("alt (Complete(Error), Reloading(Ok))", () =>
+    AsyncResult.(
+      alt(Complete(Error(1)), Reloading(Ok(2)))
+      |> expect
+      |> toEqual(reloadingOk(2))
+    )
+  );
+
+  test("alt (Complete(Error), Complete(Error))", () =>
+    AsyncResult.(
+      alt(Complete(Error(1)), Complete(Error(2)))
+      |> expect
+      |> toEqual(completeError(1))
+    )
+  );
+
   test("fromAsyncData Init", () =>
     AsyncData.init
     |> AsyncResult.fromAsyncData

src/Relude_AsyncResult.re

@@ -570,6 +570,36 @@ let toAsyncData: 'a. t('a, 'a) => Relude_AsyncData.t('a) =
   | Complete(Error(a)) => Complete(a)
   | Complete(Ok(a)) => Complete(a);
 
+/**
+[AsyncResult.alt] compares two AsyncResult values and returns the "most
+successful" of the two. In practice, this means that [Complete] is preferred
+over all else, [Reloading] is preferred over [Loading], and [Loading] is
+preferred over [Init]. The exception to this rule is the case where one of the
+provided AsyncResult values has an inner [Result] in an error state, in which
+case the other value is always preferred.
+*/
+let alt: 'a 'e. (t('a, 'e), t('a, 'e)) => t('a, 'e) =
+  (fa, fb) =>
+    switch (fa, fb) {
+    // when both are errors, prefer "complete" over "reloading"
+    | (Reloading(Error(_)), Complete(Error(_)) as b) => b
+    | (Complete(Error(_)) as a, Reloading(Error(_))) => a
+
+    // if both are the same error type, prefer the first
+    | (Reloading(Error(_)) as a, Reloading(Error(_))) => a
+    | (Complete(Error(_)) as a, Complete(Error(_))) => a
+
+    // prefer any non-error over an error
+    | (Reloading(Error(_)), b)
+    | (Complete(Error(_)), b) => b
+
+    | (a, Reloading(Error(_)))
+    | (a, Complete(Error(_))) => a
+
+    // otherwise, no errors, fall back to AsyncData.alt
+    | (a, b) => Relude_AsyncData.alt(a, b)
+    };
+
 /**
 Indicates if two AsyncResult values are in the same state, and have the same contained value.
 */
@@ -614,8 +644,15 @@ module WithError = (E: TYPE) => {
   let bind = Monad.flat_map;
   include Relude_Extensions_Monad.MonadExtensions(Monad);
 
+  module Alt: ALT with type t('a) = t('a, E.t) = {
+    include Functor;
+    let alt = alt;
+  };
+  include Relude_Extensions_Alt.AltExtensions(Alt);
+
   module Infix = {
     include Relude_Extensions_Functor.FunctorInfix(Functor);
+    include Relude_Extensions_Alt.AltInfix(Alt);
     include Relude_Extensions_Apply.ApplyInfix(Apply);
     include Relude_Extensions_Monad.MonadInfix(Monad);
   };