Remove distinct union type and method

This removes the union type and interface for each type and uses just an interface.

The `is___` methods no longer can discriminate between types fully; it only ensures that the instance is a single particular type. This simplifies the architecture of the library and makes documentation easier at the expense of not being able to be as exhaustive about the types in conditionals. For example, an `if/else` condition that checks for `isSome` no longer knows that the `else` condition contains a `None`.

Related to #2

Author: alexlafroscia

CHANGELOG.md

@@ -5,6 +5,16 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/) and this
 project adheres to [Semantic Versioning](http://semver.org/).
 
+## Unreleased
+
+### Changed
+
+- Removed distinct `Option` union type and `OptionMethods` interface in favor of
+  a single interface that `Option` and `None` implement
+- Removed distinct `Result` union type and `ResultMethods` interface in favor of
+  a single interface that `Ok` and `Err` implement
+- `isSome`, `isNone`, `isOk` and `isErr` are now methods, rather than properties
+
 ## 0.5.3 - 2022-03-17
 
 ### Fixed

lib/option/methods.ts

@@ -4,11 +4,11 @@ import { ExpectError, UnwrapError } from "../exceptions.ts";
 import { Err } from "../result/err.ts";
 
 Deno.test("#isSome", () => {
-  assertEquals(None.isSome, false);
+  assertEquals(None.isSome(), false);
 });
 
 Deno.test("#isNone", () => {
-  assertEquals(None.isNone, true);
+  assertEquals(None.isNone(), true);
 });
 
 Deno.test("#unwrap", () => {

lib/option/none.test.ts

@@ -1,12 +1,16 @@
-import { type OptionMethods } from "./methods.ts";
 import { type Option } from "./option.ts";
+import { type Some } from "./some.ts";
 import { Err, type Result } from "../result/mod.ts";
 import { ExpectError, UnwrapError } from "../exceptions.ts";
 
-class NoneImpl implements OptionMethods<never> {
-  readonly isSome = false;
+class NoneImpl implements Option<never> {
+  isSome(): this is Some<never> {
+    return false;
+  }
 
-  readonly isNone = true;
+  isNone(): this is typeof None {
+    return true;
+  }
 
   unwrap(): never {
     throw new UnwrapError("Cannot unwrap `None`");

lib/option/none.ts

@@ -100,18 +100,14 @@ Deno.test("discriminating `Some` from `None`", async (t) => {
   const result = toOption(1);
 
   await t.step("using `#isSome`", () => {
-    if (result.isSome) {
+    if (result.isSome()) {
       const _some: Some<number> = result;
-    } else {
-      const _none: typeof None = result;
     }
   });
 
   await t.step("using `#isNone`", () => {
-    if (result.isNone) {
+    if (result.isNone()) {
       const _none: typeof None = result;
-    } else {
-      const _some: Some<number> = result;
     }
   });
 });

lib/option/option.test.ts

@@ -1,4 +1,28 @@
 import { type Some } from "./some.ts";
 import { type None } from "./none.ts";
+import { type Result } from "../result/mod.ts";
 
-export type Option<T> = Some<T> | typeof None;
+export interface Option<T> {
+  isSome(): this is Some<T>;
+  isNone(): this is typeof None;
+
+  unwrap(): T;
+  unwrapOr(fallback: T): T;
+  unwrapOrElse(fallback: () => T): T;
+
+  expect(message: string): T;
+
+  andThen<U>(op: (value: T) => Option<U>): Option<U>;
+
+  map<U>(op: (value: T) => U): Option<U>;
+  mapOr<U>(fallback: U, op: (value: T) => U): U;
+  mapOrElse<U>(fallback: () => U, op: (value: T) => U): U;
+
+  and(other: Option<T>): Option<T>;
+
+  or(other: Option<T>): Option<T>;
+  orElse(other: () => Option<T>): Option<T>;
+
+  okOr<E>(err: E): Result<T, E>;
+  okOrElse<E>(err: () => E): Result<T, E>;
+}

lib/option/option.ts

@@ -3,11 +3,11 @@ import { Some } from "./some.ts";
 import { Ok } from "../result/mod.ts";
 
 Deno.test("#isSome", () => {
-  assertEquals(new Some(1).isSome, true);
+  assertEquals(new Some(1).isSome(), true);
 });
 
 Deno.test("#isNone", () => {
-  assertEquals(new Some(1).isNone, false);
+  assertEquals(new Some(1).isNone(), false);
 });
 
 Deno.test("#unwrap", () => {

lib/option/some.test.ts

@@ -1,16 +1,20 @@
-import { type OptionMethods } from "./methods.ts";
 import { type Option } from "./option.ts";
+import { type None } from "./none.ts";
 import { Ok, type Result } from "../result/mod.ts";
 
 /**
  * Contains the value of an `Option<T>`
  *
  * @template T The type of the present value
  */
-export class Some<T> implements OptionMethods<T> {
-  readonly isSome = true;
+export class Some<T> implements Option<T> {
+  isSome(): this is Some<T> {
+    return true;
+  }
 
-  readonly isNone = false;
+  isNone(): this is typeof None {
+    return false;
+  }
 
   constructor(private val: T) {}
 

lib/option/some.ts

@@ -14,9 +14,11 @@ export function all<T, E>(results: Iterable<Result<T, E>>): Result<T[], E> {
   const collection = [];
 
   for (const result of results) {
-    if (result.isOk) {
+    if (result.isOk()) {
       collection.push(result.unwrap());
-    } else {
+    }
+
+    if (result.isErr()) {
       return result;
     }
   }
@@ -36,9 +38,11 @@ export function any<T, E>(results: Iterable<Result<T, E>>): Result<T, E[]> {
   const collection = [];
 
   for (const result of results) {
-    if (result.isErr) {
+    if (result.isErr()) {
       collection.push(result.unwrapErr());
-    } else {
+    }
+
+    if (result.isOk()) {
       return result;
     }
   }

lib/result/aggregators.ts

@@ -11,13 +11,13 @@ import { ExpectError, UnwrapError } from "../exceptions.ts";
 Deno.test("#isOk", () => {
   const err = new Err("whatever");
 
-  assertEquals(err.isOk, false);
+  assertEquals(err.isOk(), false);
 });
 
 Deno.test("#isErr", () => {
   const err = new Err("whatever");
 
-  assertEquals(err.isErr, true);
+  assertEquals(err.isErr(), true);
 });
 
 Deno.test("#unwrap", () => {

lib/result/err.test.ts

@@ -1,5 +1,5 @@
-import { type ResultMethods } from "./methods.ts";
 import { type Result } from "./result.ts";
+import { type Ok } from "./ok.ts";
 import { EventualResult } from "./eventual.ts";
 import { None, type Option, Some } from "../option/mod.ts";
 import { ExpectError, UnwrapError } from "../exceptions.ts";
@@ -9,12 +9,17 @@ import { ExpectError, UnwrapError } from "../exceptions.ts";
  *
  * @template E The type of the error value
  */
-export class Err<E> implements ResultMethods<never, E> {
-  readonly isOk = false;
-  readonly isErr = true;
-
+export class Err<E> implements Result<never, E> {
   constructor(private val: E) {}
 
+  isOk(): this is Ok<never> {
+    return false;
+  }
+
+  isErr(): this is Err<E> {
+    return true;
+  }
+
   unwrap(): never {
     throw new UnwrapError("Cannot unwrap `Err`", this.val);
   }

lib/result/err.ts

@@ -270,7 +270,9 @@ Deno.test("#unwrapOr", async () => {
 
   assertEquals(await eventuallyOk.unwrapOr("other"), "ok");
 
-  const eventuallyErr = new EventualResult(Promise.reject("err"));
+  const eventuallyErr: EventualResult<unknown, string> = new EventualResult(
+    Promise.reject("err"),
+  );
 
   assertEquals(await eventuallyErr.unwrapOr("other"), "other");
 });