From 06bc7c9be5fecd6958fb986a0724f63cb59f9bde Mon Sep 17 00:00:00 2001
From: Aldwin Vlasblom <aldwin@avaq.it>
Date: Fri, 8 Jan 2021 14:45:43 +0100
Subject: [PATCH] Add branch awareness and tests for the type of 'alt'

---
 index.d.ts               | 36 +++++++++++++++++++++++---
 test/types/alt.test-d.ts | 56 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 88 insertions(+), 4 deletions(-)
 create mode 100644 test/types/alt.test-d.ts

diff --git a/index.d.ts b/index.d.ts
index 7b0b4f35..f7cc4a9d 100644
--- a/index.d.ts
+++ b/index.d.ts
@@ -86,10 +86,38 @@ export function after(duration: number): <R>(value: R) => Resolved<R>
 export function and<L, R>(left: FutureInstance<L, R>): (right: FutureInstance<L, any>) => FutureInstance<L, R>
 
 /** Logical or for Futures. See https://github.com/fluture-js/Fluture#alt */
-export function alt<L, R>(left: FutureInstance<L, R>): (right: FutureInstance<L, R>) => FutureInstance<L, R>
-
-/** Race two ConcurrentFutures. See https://github.com/fluture-js/Fluture#alt */
-export function alt<L, R>(left: ConcurrentFutureInstance<L, R>): (right: ConcurrentFutureInstance<L, R>) => ConcurrentFutureInstance<L, R>
+export const alt: {
+  <F extends AnyFuture, S extends AnyFuture>(second: F extends Never ? S : never): (first: F) => Never
+  <F extends AnyFuture, S extends AnyFuture>(second: F extends Rejected<unknown> ? S : never): (first: F) => S
+  <F extends AnyFuture, S extends AnyFuture>(second: F extends Resolved<unknown> ? S : never): (first: F) => F
+
+  <L>(second: Rejected<L>): {
+    (first: Never): Never
+    (first: Rejected<any>): Rejected<L>
+    <R>(first: Resolved<R>): Resolved<R>
+    <R>(first: Uncertain<any, R>): Uncertain<L, R>
+  }
+
+  <L, R>(second: Uncertain<L, R>): {
+    <T>(first: Resolved<T>): Resolved<T>
+    (first: Rejected<any>): Uncertain<L, R>
+    (first: Uncertain<any, R>): Uncertain<L, R>
+  }
+
+  (second: ConcurrentNever): <L, R>(first: ConcurrentUncertain<L, R>) => ConcurrentUncertain<L, R>
+
+  <L>(second: ConcurrentRejected<L>): {
+    <R>(first: ConcurrentResolved<R>): ConcurrentUncertain<L, R>
+    <R>(first: ConcurrentUncertain<L, R>): ConcurrentUncertain<L, R>
+  }
+
+  <R>(second: ConcurrentResolved<R>): {
+    <L>(first: ConcurrentRejected<L>): ConcurrentUncertain<L, R>
+    <L>(first: ConcurrentUncertain<L, R>): ConcurrentUncertain<L, R>
+  }
+
+  <L, R>(second: ConcurrentUncertain<L, R>): (first: ConcurrentUncertain<L, R>) => ConcurrentUncertain<L, R>
+}
 
 /** Apply the function in the right Future to the value in the left Future. See https://github.com/fluture-js/Fluture#ap */
 export function ap<L, RA>(value: FutureInstance<L, RA>): <RB>(apply: FutureInstance<L, (value: RA) => RB>) => FutureInstance<L, RB>
diff --git a/test/types/alt.test-d.ts b/test/types/alt.test-d.ts
new file mode 100644
index 00000000..c4804b7a
--- /dev/null
+++ b/test/types/alt.test-d.ts
@@ -0,0 +1,56 @@
+import {expectType, expectError} from 'tsd';
+
+import * as fl from '../../index.js';
+
+const fsn: fl.FutureInstance<string, number> = fl.resolve (42);
+const fns: fl.FutureInstance<number, string> = fl.resolve ('a');
+
+// Standard usage on Future instances.
+expectType<fl.Never> (fl.alt (fl.never) (fl.never));
+expectType<fl.Never> (fl.alt (fl.reject ('a')) (fl.never));
+expectType<fl.Never> (fl.alt (fl.resolve ('a')) (fl.never));
+expectType<fl.Never> (fl.alt (fl.never) (fl.reject ('a')));
+expectType<fl.Resolved<string>> (fl.alt (fl.never) (fl.resolve ('a')));
+expectType<fl.Resolved<number>> (fl.alt (fl.reject ('a')) (fl.resolve (42)));
+expectType<fl.Resolved<number>> (fl.alt (fl.resolve (42)) (fl.reject ('a')));
+expectType<fl.Resolved<number>> (fl.alt (fl.resolve (42)) (fl.resolve (42)));
+expectType<fl.Rejected<number>> (fl.alt (fl.reject (42)) (fl.reject (42)));
+expectType<fl.Rejected<string>> (fl.alt (fl.reject ('a')) (fl.reject (42)));
+expectType<fl.Uncertain<string, number>> (fl.alt (fsn) (fsn));
+expectType<fl.Resolved<number>> (fl.alt (fl.resolve ('a')) (fl.resolve (42)));
+expectError (fl.alt (fsn) (fns));
+
+const x = fl.alt (fl.never) (fl.never)
+
+// Usage with pipe on Future instances (https://git.io/JLx3F).
+expectType<fl.Never> ((fl.never) .pipe (fl.alt (fl.never)));
+expectType<fl.Never> ((fl.never) .pipe (fl.alt (fl.reject ('a'))));
+expectType<fl.Never> ((fl.never) .pipe (fl.alt (fl.resolve ('a'))));
+expectType<fl.Never> ((fl.reject ('a')) .pipe (fl.alt (fl.never)));
+expectType<fl.Resolved<string>> ((fl.resolve ('a')) .pipe (fl.alt (fl.never)));
+expectType<fl.Resolved<number>> ((fl.resolve (42)) .pipe (fl.alt (fl.reject ('a'))));
+expectType<fl.Resolved<number>> ((fl.reject ('a')) .pipe (fl.alt (fl.resolve (42))));
+expectType<fl.Resolved<number>> ((fl.resolve (42)) .pipe (fl.alt (fl.resolve (42))));
+expectType<fl.Rejected<number>> ((fl.reject (42)) .pipe (fl.alt (fl.reject (42))));
+expectType<fl.Rejected<string>> ((fl.reject (42)) .pipe (fl.alt (fl.reject ('a'))));
+expectType<fl.Uncertain<string, number>> ((fsn) .pipe (fl.alt (fsn)));
+expectType<fl.Resolved<number>> ((fl.resolve (42)) .pipe (fl.alt (fl.resolve ('a'))));
+expectError ((fns) .pipe (fl.alt (fsn)));
+
+const csn: fl.ConcurrentFutureInstance<string, number> = fl.Par (fl.resolve (42));
+const cns: fl.ConcurrentFutureInstance<number, string> = fl.Par (fl.resolve ('a'));
+
+// Standard usage on ConcurrentFuture instances.
+expectType<fl.ConcurrentNever> (fl.alt (fl.Par (fl.never)) (fl.Par (fl.never)));
+expectType<fl.ConcurrentRejected<string>> (fl.alt (fl.Par (fl.reject ('a'))) (fl.Par (fl.never)));
+expectType<fl.ConcurrentResolved<string>> (fl.alt (fl.Par (fl.resolve ('a'))) (fl.Par (fl.never)));
+expectType<fl.ConcurrentRejected<string>> (fl.alt (fl.Par (fl.never)) (fl.Par (fl.reject ('a'))));
+expectType<fl.ConcurrentResolved<string>> (fl.alt (fl.Par (fl.never)) (fl.Par (fl.resolve ('a'))));
+expectType<fl.ConcurrentFutureInstance<string, number>> (fl.alt (fl.Par (fl.reject ('a'))) (fl.Par (fl.resolve (42))));
+expectType<fl.ConcurrentFutureInstance<string, number>> (fl.alt (fl.Par (fl.resolve (42))) (fl.Par (fl.reject ('a'))));
+expectType<fl.ConcurrentResolved<number>> (fl.alt (fl.Par (fl.resolve (42))) (fl.Par (fl.resolve (42))));
+expectType<fl.ConcurrentRejected<number>> (fl.alt (fl.Par (fl.reject (42))) (fl.Par (fl.reject (42))));
+expectType<fl.ConcurrentUncertain<string, number>> (fl.alt (csn) (csn));
+expectError (fl.alt (fl.Par (fl.resolve ('a'))) (fl.Par (fl.resolve (42))));
+expectError (fl.alt (fl.Par (fl.reject ('a'))) (fl.Par (fl.reject (42))));
+expectError (fl.alt (csn) (cns));