From ef878d45d7262dd763cbd1132099c4eef0051df5 Mon Sep 17 00:00:00 2001
From: Aldwin Vlasblom <aldwin@avaq.it>
Date: Sun, 19 Jul 2020 13:14:24 +0200
Subject: [PATCH 1/7] Add type aliases for "certain" Futures

A certain Future is a Future whose branch is certain. In TypeScript,
this is represented by having 'never' as the type for one of the
branches.

This change also applies to ConcurrentFutures.
---
 index.d.ts | 22 +++++++++++++++-------
 1 file changed, 15 insertions(+), 7 deletions(-)

diff --git a/index.d.ts b/index.d.ts
index e940dd4d..00502691 100644
--- a/index.d.ts
+++ b/index.d.ts
@@ -30,6 +30,10 @@ export interface Functor<A> {
 
 type Mapped<F extends Functor<unknown>, B> = ReturnType<(F & { [$T]: B })['fantasy-land/map']>
 
+export type ConcurrentRejected<T> = ConcurrentFutureInstance<T, never>;
+
+export type ConcurrentResolved<T> = ConcurrentFutureInstance<never, T>;
+
 export interface ConcurrentFutureInstance<L, R> extends Functor<R> {
   sequential: FutureInstance<L, R>
   'fantasy-land/ap'<A, B>(this: ConcurrentFutureInstance<L, (value: A) => B>, right: ConcurrentFutureInstance<L, A>): ConcurrentFutureInstance<L, B>
@@ -37,6 +41,10 @@ export interface ConcurrentFutureInstance<L, R> extends Functor<R> {
   'fantasy-land/alt'(right: ConcurrentFutureInstance<L, R>): ConcurrentFutureInstance<L, R>
 }
 
+export type Rejected<T> = FutureInstance<T, never>;
+
+export type Resolved<T> = FutureInstance<never, T>;
+
 export interface FutureInstance<L, R> extends Functor<R> {
 
   /** The Future constructor */
@@ -60,7 +68,7 @@ export interface FutureInstance<L, R> extends Functor<R> {
 }
 
 /** Creates a Future which resolves after the given duration with the given value. See https://github.com/fluture-js/Fluture#after */
-export function after(duration: number): <R>(value: R) => FutureInstance<never, R>
+export function after(duration: number): <R>(value: R) => Resolved<R>
 
 /** Logical and for Futures. See https://github.com/fluture-js/Fluture#and */
 export function and<L, R>(left: FutureInstance<L, R>): (right: FutureInstance<L, any>) => FutureInstance<L, R>
@@ -120,7 +128,7 @@ export function extractLeft<L, R>(source: FutureInstance<L, R>): Array<L>
 export function extractRight<L, R>(source: FutureInstance<L, R>): Array<R>
 
 /** Coalesce both branches into the resolution branch. See https://github.com/fluture-js/Fluture#coalesce */
-export function coalesce<LA, R>(lmapper: (left: LA) => R): <RA>(rmapper: (right: RA) => R) => (source: FutureInstance<LA, RA>) => FutureInstance<never, R>
+export function coalesce<LA, R>(lmapper: (left: LA) => R): <RA>(rmapper: (right: RA) => R) => (source: FutureInstance<LA, RA>) => Resolved<R>
 
 /** Fork the given Future into the given continuations. See https://github.com/fluture-js/Fluture#fork */
 export function fork<L>(reject: RejectFunction<L>): <R>(resolve: ResolveFunction<R>) => (source: FutureInstance<L, R>) => Cancel
@@ -153,13 +161,13 @@ export const map: {
 export function mapRej<LA, LB>(mapper: (reason: LA) => LB): <R>(source: FutureInstance<LA, R>) => FutureInstance<LB, R>
 
 /** A Future that never settles. See https://github.com/fluture-js/Fluture#never */
-export var never: FutureInstance<never, never>
+export var never: Resolved<never>
 
 /** Create a Future using a provided Node-style callback. See https://github.com/fluture-js/Fluture#node */
 export function node<L, R>(fn: (done: Nodeback<L, R>) => void): FutureInstance<L, R>
 
 /** Create a Future with the given resolution value. See https://github.com/fluture-js/Fluture#of */
-export function resolve<R>(value: R): FutureInstance<never, R>
+export function resolve<R>(value: R): Resolved<R>
 
 /** Run an Array of Futures in parallel, under the given concurrency limit. See https://github.com/fluture-js/Fluture#parallel */
 export function parallel(concurrency: number): <L, R>(futures: Array<FutureInstance<L, R>>) => FutureInstance<L, Array<R>>
@@ -171,10 +179,10 @@ export function promise<R>(source: FutureInstance<Error, R>): Promise<R>
 export function race<L, R>(left: FutureInstance<L, R>): (right: FutureInstance<L, R>) => FutureInstance<L, R>
 
 /** Create a Future with the given rejection reason. See https://github.com/fluture-js/Fluture#reject */
-export function reject<L>(reason: L): FutureInstance<L, never>
+export function reject<L>(reason: L): Rejected<L>
 
 /** Creates a Future which rejects after the given duration with the given reason. See https://github.com/fluture-js/Fluture#rejectafter */
-export function rejectAfter(duration: number): <L>(reason: L) => FutureInstance<L, never>
+export function rejectAfter(duration: number): <L>(reason: L) => Rejected<L>
 
 /** Convert a ConcurrentFuture to a regular Future. See https://github.com/fluture-js/Fluture#concurrentfuture */
 export function seq<L, R>(source: ConcurrentFutureInstance<L, R>): FutureInstance<L, R>
@@ -183,7 +191,7 @@ export function seq<L, R>(source: ConcurrentFutureInstance<L, R>): FutureInstanc
 export function swap<L, R>(source: FutureInstance<L, R>): FutureInstance<R, L>
 
 /** Fork the Future into the given continuation. See https://github.com/fluture-js/Fluture#value */
-export function value<R>(resolve: ResolveFunction<R>): (source: FutureInstance<never, R>) => Cancel
+export function value<R>(resolve: ResolveFunction<R>): (source: Resolved<R>) => Cancel
 
 /** Enable or disable debug mode. See https://github.com/fluture-js/Fluture#debugmode */
 export function debugMode(debug: boolean): void;

From 5022c16a68ba906bf4e89443a9f04b374115f812 Mon Sep 17 00:00:00 2001
From: Aldwin Vlasblom <aldwin@avaq.it>
Date: Sun, 19 Jul 2020 13:55:43 +0200
Subject: [PATCH 2/7] Add a type alias for "uncertain" Futures and
 ConcurrentFutures

An uncertain Future is one that might reject or resolve.
---
 index.d.ts | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/index.d.ts b/index.d.ts
index 00502691..bb69aa5f 100644
--- a/index.d.ts
+++ b/index.d.ts
@@ -34,6 +34,8 @@ export type ConcurrentRejected<T> = ConcurrentFutureInstance<T, never>;
 
 export type ConcurrentResolved<T> = ConcurrentFutureInstance<never, T>;
 
+export type ConcurrentUncertain<L, R> = ConcurrentFutureInstance<L, R>;
+
 export interface ConcurrentFutureInstance<L, R> extends Functor<R> {
   sequential: FutureInstance<L, R>
   'fantasy-land/ap'<A, B>(this: ConcurrentFutureInstance<L, (value: A) => B>, right: ConcurrentFutureInstance<L, A>): ConcurrentFutureInstance<L, B>
@@ -45,6 +47,8 @@ export type Rejected<T> = FutureInstance<T, never>;
 
 export type Resolved<T> = FutureInstance<never, T>;
 
+export type Uncertain<L, R> = FutureInstance<L, R>;
+
 export interface FutureInstance<L, R> extends Functor<R> {
 
   /** The Future constructor */

From c55b9dd8b364c2cbd879c2de85d512ccbc8b987d Mon Sep 17 00:00:00 2001
From: Aldwin Vlasblom <aldwin@avaq.it>
Date: Sun, 19 Jul 2020 13:37:39 +0200
Subject: [PATCH 3/7] Add a type alias for never settling Futures and
 ConcurrentFutures

---
 index.d.ts | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/index.d.ts b/index.d.ts
index bb69aa5f..d2f396cb 100644
--- a/index.d.ts
+++ b/index.d.ts
@@ -30,6 +30,8 @@ export interface Functor<A> {
 
 type Mapped<F extends Functor<unknown>, B> = ReturnType<(F & { [$T]: B })['fantasy-land/map']>
 
+export type ConcurrentNever = ConcurrentFutureInstance<never, never>;
+
 export type ConcurrentRejected<T> = ConcurrentFutureInstance<T, never>;
 
 export type ConcurrentResolved<T> = ConcurrentFutureInstance<never, T>;
@@ -43,6 +45,8 @@ export interface ConcurrentFutureInstance<L, R> extends Functor<R> {
   'fantasy-land/alt'(right: ConcurrentFutureInstance<L, R>): ConcurrentFutureInstance<L, R>
 }
 
+export type Never = FutureInstance<never, never>;
+
 export type Rejected<T> = FutureInstance<T, never>;
 
 export type Resolved<T> = FutureInstance<never, T>;
@@ -165,7 +169,7 @@ export const map: {
 export function mapRej<LA, LB>(mapper: (reason: LA) => LB): <R>(source: FutureInstance<LA, R>) => FutureInstance<LB, R>
 
 /** A Future that never settles. See https://github.com/fluture-js/Fluture#never */
-export var never: Resolved<never>
+export var never: Never
 
 /** Create a Future using a provided Node-style callback. See https://github.com/fluture-js/Fluture#node */
 export function node<L, R>(fn: (done: Nodeback<L, R>) => void): FutureInstance<L, R>

From 4fb3569e9ab2b5e67025fbaf5f1e3f09783b4dc7 Mon Sep 17 00:00:00 2001
From: Aldwin Vlasblom <aldwin@avaq.it>
Date: Fri, 19 Jun 2020 16:28:04 +0200
Subject: [PATCH 4/7] Add typescript type tests for 'after'

---
 test/types/after.test-d.ts | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 test/types/after.test-d.ts

diff --git a/test/types/after.test-d.ts b/test/types/after.test-d.ts
new file mode 100644
index 00000000..63b69040
--- /dev/null
+++ b/test/types/after.test-d.ts
@@ -0,0 +1,9 @@
+import {expectType} from 'tsd';
+
+import * as fl from '../../index.js';
+
+expectType<fl.Resolved<number>> (fl.after (1) (42));
+expectType<fl.Resolved<string>> (fl.after (1) ('a'));
+
+// https://github.com/microsoft/TypeScript/issues/32277
+// expectType<fl.Never> (fl.after (Infinity) ('Finally!'));

From 5dc33cd1a3d287daeef92b06cab8b8faa690f2c4 Mon Sep 17 00:00:00 2001
From: Aldwin Vlasblom <aldwin@avaq.it>
Date: Fri, 8 Jan 2021 14:43:34 +0100
Subject: [PATCH 5/7] Add a type alias for Futures and ConcurrentFutures of any
 values

---
 index.d.ts | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/index.d.ts b/index.d.ts
index d2f396cb..553274a8 100644
--- a/index.d.ts
+++ b/index.d.ts
@@ -38,6 +38,8 @@ export type ConcurrentResolved<T> = ConcurrentFutureInstance<never, T>;
 
 export type ConcurrentUncertain<L, R> = ConcurrentFutureInstance<L, R>;
 
+export type AnyConcurrent = ConcurrentFutureInstance<unknown, unknown>;
+
 export interface ConcurrentFutureInstance<L, R> extends Functor<R> {
   sequential: FutureInstance<L, R>
   'fantasy-land/ap'<A, B>(this: ConcurrentFutureInstance<L, (value: A) => B>, right: ConcurrentFutureInstance<L, A>): ConcurrentFutureInstance<L, B>
@@ -53,6 +55,8 @@ export type Resolved<T> = FutureInstance<never, T>;
 
 export type Uncertain<L, R> = FutureInstance<L, R>;
 
+export type AnyFuture = FutureInstance<unknown, unknown>;
+
 export interface FutureInstance<L, R> extends Functor<R> {
 
   /** The Future constructor */

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

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

diff --git a/index.d.ts b/index.d.ts
index 553274a8..5a64d376 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..a8f9028a
--- /dev/null
+++ b/test/types/alt.test-d.ts
@@ -0,0 +1,54 @@
+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));
+
+// 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));

From 6e1afabfd9e884d5860ecfbfec25f80fb808401e Mon Sep 17 00:00:00 2001
From: Aldwin Vlasblom <aldwin@avaq.it>
Date: Sat, 24 Apr 2021 20:37:57 +0200
Subject: [PATCH 7/7] Add branch awareness and tests for the type of 'and'

---
 index.d.ts               | 12 +++++++++++-
 test/types/and.test-d.ts | 34 ++++++++++++++++++++++++++++++++++
 2 files changed, 45 insertions(+), 1 deletion(-)
 create mode 100644 test/types/and.test-d.ts

diff --git a/index.d.ts b/index.d.ts
index 5a64d376..f631e5ed 100644
--- a/index.d.ts
+++ b/index.d.ts
@@ -83,7 +83,17 @@ export interface FutureInstance<L, R> extends Functor<R> {
 export function after(duration: number): <R>(value: R) => Resolved<R>
 
 /** Logical and for Futures. See https://github.com/fluture-js/Fluture#and */
-export function and<L, R>(left: FutureInstance<L, R>): (right: FutureInstance<L, any>) => FutureInstance<L, R>
+export const and: {
+  <F extends AnyFuture, S extends AnyFuture>(second: F extends Never ? S : never): (first: F) => Never
+  <F extends AnyFuture, S extends AnyFuture>(second: F extends Resolved<unknown> ? S : never): (first: F) => S
+  <F extends AnyFuture, S extends AnyFuture>(second: F extends Rejected<unknown> ? S : never): (first: F) => F
+
+  <L, R>(second: Uncertain<L, R>): {
+    <T>(first: Rejected<T>): Rejected<T>
+    (first: Resolved<any>): Uncertain<L, R>
+    (first: Uncertain<L, any>): Uncertain<L, R>
+  }
+}
 
 /** Logical or for Futures. See https://github.com/fluture-js/Fluture#alt */
 export const alt: {
diff --git a/test/types/and.test-d.ts b/test/types/and.test-d.ts
new file mode 100644
index 00000000..33665ad4
--- /dev/null
+++ b/test/types/and.test-d.ts
@@ -0,0 +1,34 @@
+import {expectType, expectError} from 'tsd';
+
+import * as fl from '../../index.js';
+
+const fsn: fl.Uncertain<string, number> = fl.resolve (42);
+const fns: fl.Uncertain<number, string> = fl.resolve ('a');
+
+// Standard usage on Future instances.
+expectType<fl.Never> (fl.and (fl.never) (fl.never));
+expectType<fl.Never> (fl.and (fl.never) (fl.resolve ('a')));
+expectType<fl.Never> (fl.and (fl.reject ('a')) (fl.never));
+expectType<fl.Never> (fl.and (fl.resolve ('a')) (fl.never));
+expectType<fl.Rejected<string>> (fl.and (fl.reject ('a')) (fl.resolve (42)));
+expectType<fl.Resolved<number>> (fl.and (fl.resolve (42)) (fl.resolve (42)));
+expectType<fl.Rejected<number>> (fl.and (fl.reject (42)) (fl.reject (42)));
+expectType<fl.Uncertain<string, number>> (fl.and (fsn) (fsn));
+expectType<fl.Rejected<string>> (fl.and (fl.never) (fl.reject ('a')));
+expectType<fl.Rejected<string>> (fl.and (fl.resolve (42)) (fl.reject ('a')));
+expectType<fl.Rejected<number>> (fl.and (fl.reject ('a')) (fl.reject (42)));
+expectError (fl.and (fsn) (fns));
+
+// Usage with pipe on Future instances (https://git.io/JLx3F).
+expectType<fl.Never> ((fl.never) .pipe (fl.and (fl.never)));
+const workaround = (fl.resolve ('a')) .pipe (fl.and (fl.never)); expectType<fl.Never> (workaround);
+expectType<fl.Never> ((fl.never) .pipe (fl.and (fl.reject ('a'))));
+expectType<fl.Never> ((fl.never) .pipe (fl.and (fl.resolve ('a'))));
+expectType<fl.Rejected<string>> ((fl.resolve (42)) .pipe (fl.and (fl.reject ('a'))));
+expectType<fl.Resolved<number>> ((fl.resolve (42)) .pipe (fl.and (fl.resolve (42))));
+expectType<fl.Rejected<number>> ((fl.reject (42)) .pipe (fl.and (fl.reject (42))));
+expectType<fl.Uncertain<string, number>> ((fsn) .pipe (fl.and (fsn)));
+expectType<fl.Rejected<string>> ((fl.reject ('a')) .pipe (fl.and (fl.never)));
+expectType<fl.Rejected<string>> ((fl.reject ('a')) .pipe (fl.and (fl.resolve (42))));
+expectType<fl.Rejected<number>> ((fl.reject (42)) .pipe (fl.and (fl.reject ('a'))));
+expectError ((fns) .pipe (fl.and (fsn)));