fix: require Maybe#getOr callback to return the same type

src/maybe.spec.ts

@@ -58,17 +58,12 @@ describe('Maybe', () => {
     expectTypeOf(someValue).toEqualTypeOf<number>();
     expect(someValue).toBe(42);
 
-    const someValueWithDifferentFallbackType = Maybe.Some(42).getOr(
-      () => 'nothing',
+    const someObject = Maybe.Some<{ foo?: 'bar' }>({ foo: 'bar' }).getOr(
+      () => ({}),
     );
-    expectTypeOf(someValueWithDifferentFallbackType).toEqualTypeOf<
-      number | string
-    >();
-    expect(someValueWithDifferentFallbackType).toBe(42);
-
-    const noneValue = Maybe.None.getOr(() => 42);
-    expectTypeOf(noneValue).toEqualTypeOf<number>();
-    expect(noneValue).toBe(42);
+
+    expectTypeOf(someObject).toEqualTypeOf<{ foo?: 'bar' }>();
+    expect(someObject).toBe(42);
   });
 
   it('#toNullable', () => {

src/maybe.ts

@@ -82,7 +82,7 @@ export class Maybe<T> {
   /**
    * Return either a boxed value or a value return by `d` if there is none
    */
-  getOr<U>(d: () => T | U) {
+  getOr(d: () => T) {
     return this.match({
       Some: value => value,
       None: d,
@@ -93,14 +93,20 @@ export class Maybe<T> {
    * Return either a boxed value or `null` if there is none
    */
   toNullable() {
-    return this.getOr(() => null);
+    return this.match({
+      None: () => null,
+      Some: value => value,
+    });
   }
 
   /**
    * Return either a boxed value or `undefined` if there is none
    */
   toOptional() {
-    return this.getOr(() => undefined);
+    return this.match({
+      None: () => null,
+      Some: value => value,
+    });
   }
 
   /**