Add branch awareness and tests for the type of 'alt'

Author: Avaq

index.d.ts

@@ -84,10 +84,37 @@ export function and<L, R>(second: Uncertain<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>
+export function alt<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>
+}
+
+/** Logical or for Futures. See https://github.com/fluture-js/Fluture#alt */
+export function alt<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>
+}
+
+/** Race two ConcurrentFutures. See https://github.com/fluture-js/Fluture#alt */
+export function alt(second: ConcurrentNever): <L, R>(first: ConcurrentUncertain<L, R>) => ConcurrentUncertain<L, R>
+
+/** Race two ConcurrentFutures. See https://github.com/fluture-js/Fluture#alt */
+export function alt<L>(second: ConcurrentRejected<L>): {
+  <R>(first: ConcurrentResolved<R>): ConcurrentUncertain<L, R>
+  <R>(first: ConcurrentUncertain<L, R>): ConcurrentUncertain<L, R>
+}
+
+/** Race two ConcurrentFutures. See https://github.com/fluture-js/Fluture#alt */
+export function alt<R>(second: ConcurrentResolved<R>): {
+  <L>(first: ConcurrentRejected<L>): ConcurrentUncertain<L, R>
+  <L>(first: ConcurrentUncertain<L, R>): ConcurrentUncertain<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 function alt<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>

test/types/alt.test-d.ts

@@ -0,0 +1,39 @@
+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');
+
+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 csn: fl.ConcurrentFutureInstance<string, number> = fl.Par (fl.resolve (42));
+const cns: fl.ConcurrentFutureInstance<number, string> = fl.Par (fl.resolve ('a'));
+
+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));