Use Nothing<Present<T>> as the nothing()/nil() return type

Fix TypeScript 5.3 compatibility.

@perfective/common build fails since the TypeScript v5.3.0-dev.20230824. Type inference for the `nothing()` and `nil()` function has changed (probably caused by microsoft/TypeScript#54448).

The code like:

```
const maybe: Maybe<number> = nothing();
```

started to fail, as the `nothing()` return type is inferenced as `number | null | undefined` instead of just `number`.

One solution is to explicitly set the type:

```
const maybe: Maybe<number> = nothing<number>();
```

This solution may require significant amount of code updates across users' codebase.

The applied alternative solution was to change the `nothing()` and `nil()` return types to `Nothing<Present<T>>`.

In this case, the calls of `nothing()`/`nil()` remain as is, but `Maybe` and `Match` had to use additional type casts internally.

This approach is chosen for the v0.10.0, so the code is compatible with TypeScript v5.3. It may be reconsidered in v0.11.0 if the root cause of the different type inference will be located.

Author: amikheychik

src/match/match/match.ts

@@ -41,7 +41,7 @@ export class Match<T> {
                 return maybe(caseValue.statement(value));
             }
         }
-        return nothing();
+        return nothing() as Maybe<U>;
     }
 }
 

src/maybe/index.adoc

@@ -269,9 +269,9 @@ A _unit_ (_return_) function for the `Maybe` monad.
 * `justFrom<T, U>(map: Unary<T | null | undefined, Present<U>>): Unary<T | null | undefined, Just<U>>`
 — creates a function that applies a given `map` to a value
 and returns the result wrapped into a `Just`.
-* `nothing<T>(): Nothing<T>`
+* `nothing<T>(): Nothing<Present<T>>`
 — returns a memoized instance of `Nothing` with an `undefined` value.
-* `nil<T>(): Nothing<T>`
+* `nil<T>(): Nothing<Present<T>>`
 — returns a memoized instance of `Nothing` with a `null` value.
 
 

src/maybe/maybe/maybe.ts

@@ -287,7 +287,7 @@ export class Just<T> extends Maybe<T> {
         if (filter(this.value)) {
             return this;
         }
-        return nothing<T>();
+        return nothing<T>() as Maybe<T>;
     }
 
     /**
@@ -305,7 +305,7 @@ export class Just<T> extends Maybe<T> {
             // Return it as is instead of passing it through just(this.value).
             return this as unknown as Just<U>;
         }
-        return nothing<U>();
+        return nothing<U>() as Maybe<U>;
     }
 
     /**
@@ -321,7 +321,7 @@ export class Just<T> extends Maybe<T> {
         if (isTrue(condition)) {
             return this;
         }
-        return nothing<T>();
+        return nothing() as Maybe<T>;
     }
 
     /**
@@ -566,9 +566,9 @@ export function maybe<T>(value: T | null | undefined): Maybe<T> {
         return just(value);
     }
     if (isNull(value)) {
-        return nil();
+        return nil() as Maybe<T>;
     }
-    return nothing();
+    return nothing() as Maybe<T>;
 }
 
 /**
@@ -661,16 +661,16 @@ const memo: Memo = {
  *
  * @since v0.1.0
  */
-export function nothing<T>(): Nothing<T> {
-    return memo.nothing as Nothing<T>;
+export function nothing<T>(): Nothing<Present<T>> {
+    return memo.nothing as Nothing<Present<T>>;
 }
 
 /**
  * Returns a memoized instance of {@linkcode Nothing} with a `null` value.
  *
  * @since v0.10.0
  */
-export function nil<T>(): Nothing<T> {
+export function nil<T>(): Nothing<Present<T>> {
     // eslint-disable-next-line deprecation/deprecation -- TODO(https://github.com/perfective/ts.common/issues/31)
     return naught();
 }
@@ -681,8 +681,8 @@ export function nil<T>(): Nothing<T> {
  * @deprecated Since v0.10.0. Use `nil` instead.
  * TODO(https://github.com/perfective/ts.common/issues/31).
  */
-export function naught<T>(): Nothing<T> {
-    return memo.nil as Nothing<T>;
+export function naught<T>(): Nothing<Present<T>> {
+    return memo.nil as Nothing<Present<T>>;
 }
 
 /**