A class that represents the fulfilled state for `Schrodinger`. It is equivalent to Success for Result types. It implements `Schrodinger` class.

A class that represents the rejected state for `Schrodinger`. This class contains an exception for the operation that
occurred. It implements `Schrodinger` interface.

A class that represents the fulfilled state for `Schrodinger`, but with an intended error of type `D`. It is equivalent
to Failure for Result types and it implements `Schrodinger` interface.

A class that represents the pending state for `Schrodinger`. It implements `Schrodinger` interface.

Takes an `Iterable>` and returns a single `Schrodinger, D>`. Returns `Alive, D>`
when all `schrodingers` are in the `Alive` state, returns `Dead, D>` when at least one of `schrodingers` is in
the `Dead` state, and returns `Contradiction, D>` when at least one of `schrodingers` is in the `Contradiction`
state. If there are both `Dead` and `Contradiction` states present in the `schrodingers`, the return value will
be `Contradiction, D>` (prioritized).

### `Schrodinger.prototype.get(): A`

Returns the retained value.

Retrieves the retained value. If this instance is `Alive`, the returned value will be a non-error value of type `A`. If
this instance is `Dead`, the retained error will be thrown. If this instance is `Contradiction`, the retained `cause`
will be thrown. If this instance is `Still`, `SchrodingerError` will be thrown.

### `Schrodinger.prototype.getState(): SchrodingerState`

Returns the current state. The state can be one of the following statuses: `'ALIVE'`, `'CONTRADICTION'`, `'DEAD'`
or `'STILL'`.

Executes the given `consumer` with the non-error value of `A` type if this class instance is in the `Alive` state.

### `Schrodinger.prototype.ifContradiction(consumer: Consumer): this`

Executes the given `consumer` with the internal `cause` value of `unknown` type if this class instance is in
the `Contradiction` state.

### `Schrodinger.prototype.ifDead(consumer: Consumer): this`

Executes the given `consumer` with the error value of `D` type if this class instance is in the `Dead` state.

Returns `true` if this class instance is in the `Alive` state, `false` otherwise.

Returns `true` if this class instance is in the `Contradiction` state, `false` otherwise.

Returns `true` if this class instance is in the `Dead` state, `false` otherwise.

# Superposition classes

## (interface) Chrono\

### `Chrono.prototype.accept(valye: M>): unknown`

### `Chrono.prototype.decline(value: R): unknown`

### `Chrono.prototype.throw(cause: unknown): unknown`

A class that handles Result of Monad programming asynchronously. This class wraps a `Schrodinger` instance, which
represents the outcome of an asynchronous operation, and can change its state based on the outcome of that operation.

Like `Promise`, the Superposition class can handle multiple states, but it is more finely divided than `Promise`. The
possible states are:

- Successfully fulfilled: corresponds to a fulfilled state of `Promise`.
- Unsuccessfully fulfilled: corresponds to a rejected state of `Promise`, but only for expected errors.
- Rejected: corresponds to a rejected state of `Promise`, but for unexpected errors.
- Pending: corresponds to a pending state of `Promise`.

Takes an `Iterable>` and returns a single `Superposition, D>`. If all `superpositions` are
in the `Alive` state, the returned instance will be successfully fulfilled with an array of the values from the
`superpositions`. If at least one of `superpositions` is in the `Dead` state, the returned instance will be
unsuccessfully fulfilled with the error from the first `Dead` state encountered. If at least one of `superpositions` is
in the `Contradiction` state, the returned instance will be rejected with the cause from the first `Contradiction` state
encountered. If there are both `Dead` and `Contradiction` states present in the `superpositions`, the returned instance
will be rejected (prioritized).

Retrieves the outcome of each asynchronous operation in `superpositions` by
calling `Superposition.prototype.terminate()` on each item. The resulting `Schrodinger` state for each `Superposition`
can be found in the documentation for `Superposition.prototype.terminate()`.

return;
}

chrono.decline(value.error);
}
catch (e: unknown) {
if (e instanceof RuntimeError) {
chrono.decline(e);

return;
}

chrono.throw(e);
}
});
```

Creates a new `Superposition` instance from a given `Schrodinger` instance. If the given `schrodinger` is in the `Alive` state, the
resulting `Superposition` will be successfully fulfilled. If it is in the `Dead` state, it will be unsuccessfully
fulfilled. If it is in the `Contradiction` or `Still` state, it will be rejected.

Generates a new `Superposition` instance from a given `Superposition` instance.

### `Superposition.prototype.get(): Promise>`

Retrieves the outcome of the asynchronous operation as a `Promise`. If the instance is in the successfully fulfilled
state, it will return a fulfilled `Promise` instance. If the instance is in the unsuccessfully fulfilled or rejected
state, it will return a rejected `Promise` instance.

Executes the given `consumer` with the non-error value of `A` type if the asynchronous operation is going to be
successfully fulfilled.

### `Superposition.prototype.ifContradiction(consumer: Consumer): this`

Executes the given `consumer` with the internal `cause` value of `unknown` type if the asynchronous operation is going
to be rejected.

### `Superposition.prototype.ifDead(consumer: Consumer): this`

Executes the given `consumer` with the error value of `D` type if the asynchronous operation is going to be
unsuccessfully fulfilled.