From 72450c5452d0abf01c1e62124e91ce82463e20fb Mon Sep 17 00:00:00 2001
From: Kevin Li <jiawei.h.li@gmail.com>
Date: Tue, 4 Jul 2017 19:53:53 -0700
Subject: [PATCH] fix: use generic self-types

getOrElse and orElse use self-types in order to support typed upper bounds.[0]

In TypeScript 2.4, generic functions were checked more strictly[1].
This causes the implicit downward type cast to fail, so we explicitly invoke the cast in the method body.
This workaround is backwards-compatible with TypeScript 2.3.

Bounded polymorphism has been implemented[2], but true F-bounded polymorphism hasn't been.
This means a type like interface Option<A, B = Option<A, B>> is invalid.

Alternatively, we can solve this with a lower type bound, but these don't work against concrete classes[3].

---

We should also upgrade monapt's TypeScript dependency to 2.4, but there are unrelated errors compiling the tests.

[0] https://github.com/Microsoft/TypeScript/issues/13337
[1] https://github.com/Microsoft/TypeScript/wiki/What%27s-new-in-TypeScript#stricter-checking-for-generic-functions
[2] https://github.com/Microsoft/TypeScript/wiki/What%27s-new-in-TypeScript#type-parameters-as-constraints
[3] https://github.com/Microsoft/TypeScript/issues/14520
---
 src/option/none.ts |  4 ++--
 src/option/some.ts | 12 ++++++++----
 src/try/failure.ts |  4 ++--
 src/try/success.ts | 12 ++++++++----
 4 files changed, 20 insertions(+), 12 deletions(-)

diff --git a/src/option/none.ts b/src/option/none.ts
index 415bff7..18e5f4c 100644
--- a/src/option/none.ts
+++ b/src/option/none.ts
@@ -47,7 +47,7 @@ class None_<A> implements Option<A> {
     throw new Option.NoSuchElementError();
   }
 
-  getOrElse<B, A extends B>(this: None_<A>, defaultValue: () => B): B {
+  getOrElse<B, A extends B>(this: Option<A>, defaultValue: () => B): B {
     return defaultValue();
   }
 
@@ -59,7 +59,7 @@ class None_<A> implements Option<A> {
     return matcher.None();
   }
 
-  orElse<B, A extends B>(this: None_<A>, alternative: () => Option<B>): Option<B> {
+  orElse<B, A extends B>(this: Option<A>, alternative: () => Option<B>): Option<B> {
     return alternative();
   }
 }
diff --git a/src/option/some.ts b/src/option/some.ts
index 67b8c88..7b5180b 100644
--- a/src/option/some.ts
+++ b/src/option/some.ts
@@ -53,8 +53,10 @@ class Some<A> implements Option<A> {
     return this.value;
   }
 
-  getOrElse<B, A extends B>(this: Some<A>, defaultValue: () => B): B {
-    return this.value;
+  getOrElse<B, A extends B>(this: Option<A>, defaultValue: () => B): B {
+    const self: Some<A> = this as Some<A>;
+
+    return self.value;
   }
 
   map<B>(mapper: (value: A) => B): Option<B> {
@@ -65,8 +67,10 @@ class Some<A> implements Option<A> {
     return matcher.Some(this.value);
   }
 
-  orElse<B, A extends B>(this: Some<A>, alternative: () => Option<B>): Option<B> {
-    return this;
+  orElse<B, A extends B>(this: Option<A>, alternative: () => Option<B>): Option<B> {
+    const self: Some<A> = this as Some<A>;
+
+    return self;
   }
 }
 
diff --git a/src/try/failure.ts b/src/try/failure.ts
index 39937aa..da5e78d 100644
--- a/src/try/failure.ts
+++ b/src/try/failure.ts
@@ -45,7 +45,7 @@ class Failure<A> implements Try<A> {
     throw this.error;
   }
 
-  getOrElse<B, A extends B>(this: Failure<A>, defaultValue: () => B): B {
+  getOrElse<B, A extends B>(this: Try<A>, defaultValue: () => B): B {
     return defaultValue();
   }
 
@@ -57,7 +57,7 @@ class Failure<A> implements Try<A> {
     return matcher.Failure(this.error);
   }
 
-  orElse<B, A extends B>(this: Failure<A>, alternative: () => Try<B>): Try<B> {
+  orElse<B, A extends B>(this: Try<A>, alternative: () => Try<B>): Try<B> {
     return alternative();
   }
 
diff --git a/src/try/success.ts b/src/try/success.ts
index 68b91e1..95dd3c2 100644
--- a/src/try/success.ts
+++ b/src/try/success.ts
@@ -46,8 +46,10 @@ class Success<A> implements Try<A> {
     return this.value;
   }
 
-  getOrElse<B, A extends B>(this: Success<A>, defaultValue: () => B): B {
-    return this.value;
+  getOrElse<B, A extends B>(this: Try<A>, defaultValue: () => B): B {
+    const self: Success<A> = this as Success<A>;
+
+    return self.value;
   }
 
   map<B>(f: (value: A) => B): Try<B> {
@@ -58,8 +60,10 @@ class Success<A> implements Try<A> {
     return matcher.Success(this.value);
   }
 
-  orElse<B, A extends B>(this: Success<A>, alternative: () => Try<B>): Try<B> {
-    return this;
+  orElse<B, A extends B>(this: Try<A>, alternative: () => Try<B>): Try<B> {
+    const self: Success<A> = this as Success<A>;
+
+    return self;
   }
 
   recover(fn: (error: Error) => A): Try<A> {