fix: use single type parameter in match methods of Async and Maybe

src/async.spec.ts

@@ -24,6 +24,10 @@ describe('Async', () => {
   });
 
   it('#mapReady', () => {
+    expectTypeOf(Async.Pending.mapReady(() => 42)).toEqualTypeOf<
+      Async<number>
+    >();
+
     const matched = Async.Pending.mapReady(() => 42).match({
       Pending: () => 0,
       Ready: value => value,
@@ -34,6 +38,12 @@ describe('Async', () => {
   });
 
   it('#flatMapReady', () => {
+    expectTypeOf(
+      Async.Ready('anything').flatMapReady(s =>
+        s === 'something' ? Async.Ready(s) : Async.Pending,
+      ),
+    ).toEqualTypeOf<Async<string>>();
+
     const matched = Async.Ready('anything')
       .flatMapReady(s => (s === 'something' ? Async.Ready(s) : Async.Pending))
       .match({

src/async.ts

@@ -56,7 +56,7 @@ export class Async<T> {
    * values.
    * This is used to implement most of the operations
    */
-  match<U, P>(arms: { Pending: () => P; Ready: (value: T) => U }) {
+  match<U>(arms: { Pending: () => U; Ready: (value: T) => U }) {
     return this.#state.isReady ? arms.Ready(this.#state.value) : arms.Pending();
   }
 

src/maybe.spec.ts

@@ -24,6 +24,8 @@ describe('Maybe', () => {
   });
 
   it('#mapSome', () => {
+    expectTypeOf(Maybe.None.mapSome(() => 42)).toEqualTypeOf<Maybe<number>>();
+
     const matched = Maybe.None.mapSome(() => 42).match({
       None: () => 0,
       Some: value => value,
@@ -34,6 +36,12 @@ describe('Maybe', () => {
   });
 
   it('#flatMapSome', () => {
+    expectTypeOf(
+      Maybe.None.flatMapSome(s =>
+        s === 'something' ? Maybe.None : Maybe.Some('asdfasdf'),
+      ),
+    ).toEqualTypeOf<Maybe<string>>();
+
     const matched = Maybe.Some('anything')
       .flatMapSome(s => (s === 'something' ? Maybe.Some(s) : Maybe.None))
       .match({

src/maybe.ts

@@ -47,7 +47,7 @@ export class Maybe<T> {
    * value.
    * This is used to implement most of the operations
    */
-  match<U, N>(arms: { None: () => N; Some: (value: T) => U }) {
+  match<U>(arms: { None: () => U; Some: (value: T) => U }) {
     return this.#state.isSome ? arms.Some(this.#state.value) : arms.None();
   }
 

src/result.spec.ts

@@ -65,11 +65,11 @@ describe('Result', () => {
     const matchedSuccess = Result.Ok(42)
       .getOk()
       .match({
-        None: () => 'nothing',
+        None: () => null,
         Some: value => value,
       });
 
-    expectTypeOf(matchedSuccess).toEqualTypeOf<number | string>();
+    expectTypeOf(matchedSuccess).toEqualTypeOf<number | null>();
     expect(matchedSuccess).toBe(42);
 
     const matchedFailure = Result.Err('Something went wrong')