From 4313b923bf49e9370f16907f88352d3ce331e45c Mon Sep 17 00:00:00 2001
From: "Timothy J. Warren" <tim@timshomepage.net>
Date: Wed, 3 Jul 2024 17:49:15 -0400
Subject: [PATCH] Refactor Option type to one implementation instead of two

---
 src/common/option.ts | 194 ++++++++++++++++---------------------------
 1 file changed, 73 insertions(+), 121 deletions(-)

diff --git a/src/common/option.ts b/src/common/option.ts
index fa4d0ce..252a5e9 100644
--- a/src/common/option.ts
+++ b/src/common/option.ts
@@ -1,175 +1,127 @@
+/**
+ * The sad, lonely enum that should be more tightly coupled
+ * to the Option type...but this isn't Rust
+ */
+enum OptionType {
+	Some = 'Some',
+	None = 'None',
+}
+
+const isOption = <T>(v: any): v is Option<T> => v instanceof Option;
+
 /**
  * Rust-style optional type
  *
  * Based on https://gist.github.com/s-panferov/575da5a7131c285c0539
  */
-export default interface Option<T> {
-	isSome(): boolean;
-	isNone(): boolean;
-	isSomeAnd(fn: (a: T) => boolean): boolean;
-	isNoneAnd(fn: () => boolean): boolean;
-	unwrap(): T | never;
-	unwrapOr(def: T): T;
-	unwrapOrElse(f: () => T): T;
-	map<U>(f: (a: T) => U): Option<U>;
-	mapOr<U>(def: U, f: (a: T) => U): U;
-	mapOrElse<U>(def: () => U, f: (a: T) => U): U;
-	and<U>(optb: Option<U>): Option<U>;
-	andThen<U>(f: (a: T) => Option<U>): Option<U>;
-	or(optb: Option<T>): Option<T>;
-	orElse(f: () => Option<T>): Option<T>;
-}
+export class Option<T> {
+	/**
+	 * The placeholder for the 'None' value type
+	 */
+	private static _noneInstance: Option<any> = new Option();
 
-class _Some<T> implements Option<T> {
-	private value: T;
+	/**
+	 * Is this a 'Some' or a 'None'?
+	 */
+	private optionType: OptionType;
 
-	constructor(v: T) {
-		this.value = v;
-	}
+	/**
+	 * The value for the 'Some' type
+	 */
+	private value?: T;
 
-	static wrapNull<T>(value: T): Option<T> {
-		if (value == null) {
-			return None;
+	private constructor(v?: T | null) {
+		if (v !== undefined && v !== null) {
+			this.optionType = OptionType.Some;
+			this.value = v;
 		} else {
-			return new _Some<T>(value);
+			this.optionType = OptionType.None;
+			this.value = undefined;
 		}
 	}
 
-	map<U>(fn: (a: T) => U): Option<U> {
-		return new _Some(fn(this.value));
+	public static get None(): Option<any> {
+		return <Option<any>> Option._noneInstance;
 	}
 
-	mapOr<U>(_def: U, f: (a: T) => U): U {
-		return f(this.value);
+	public static Some<X>(v: X): Option<X> {
+		return new Option(v);
 	}
 
-	mapOrElse<U>(_def: () => U, f: (a: T) => U): U {
-		return f(this.value);
+	public static from<X>(v: any): Option<X> {
+		return (isOption(v)) ? Option.from(v.unwrap()) : new Option(v);
 	}
 
 	isSome(): boolean {
-		return true;
+		return this.optionType === OptionType.Some && this.value !== undefined;
 	}
 
 	isNone(): boolean {
-		return false;
+		return this.optionType === OptionType.None;
 	}
 
 	isSomeAnd(fn: (a: T) => boolean): boolean {
-		return fn(this.value);
-	}
-
-	isNoneAnd(_fn: () => boolean): boolean {
-		return false;
-	}
-
-	unwrap(): T {
-		return this.value;
-	}
-
-	unwrapOr(_def: T): T {
-		return this.value;
-	}
-
-	unwrapOrElse(_f: () => T): T {
-		return this.value;
-	}
-
-	and<U>(optb: Option<U>): Option<U> {
-		return optb;
-	}
-
-	andThen<U>(f: (a: T) => Option<U>): Option<U> {
-		return f(this.value);
-	}
-
-	or(_optb: Option<T>): Option<T> {
-		return this;
-	}
-
-	orElse(_f: () => Option<T>): Option<T> {
-		return this;
-	}
-
-	toString(): string {
-		return 'Some ' + this.value;
-	}
-}
-
-class _None<T> implements Option<T> {
-	constructor() {
-	}
-
-	map<U>(_fn: (a: T) => U): Option<U> {
-		return <Option<U>> _None._instance;
-	}
-
-	isSome(): boolean {
-		return false;
-	}
-
-	isNone(): boolean {
-		return true;
-	}
-
-	isSomeAnd(_fn: (a: T) => boolean): boolean {
-		return false;
+		return this.isSome() ? fn(this.unwrap()) : false;
 	}
 
 	isNoneAnd(fn: () => boolean): boolean {
-		return fn();
+		return this.isNone() ? fn() : false;
 	}
 
-	unwrap(): never {
+	map<U>(fn: (a: T) => U): Option<U> {
+		return this.isSome() ? new Option(fn(this.unwrap())) : Option._noneInstance;
+	}
+
+	mapOr<U>(def: U, f: (a: T) => U): U {
+		return this.isSome() ? f(this.unwrap()) : def;
+	}
+
+	mapOrElse<U>(def: () => U, f: (a: T) => U): U {
+		return this.isSome() ? f(this.unwrap()) : def();
+	}
+
+	unwrap(): T | never {
+		if (this.isSome() && this.value !== undefined) {
+			return this.value;
+		}
+
 		console.error('None.unwrap()');
 		throw 'None.get';
 	}
 
 	unwrapOr(def: T): T {
-		return def;
+		return this.isSome() ? this.unwrap() : def;
 	}
 
 	unwrapOrElse(f: () => T): T {
-		return f();
+		return this.isSome() ? this.unwrap() : f();
 	}
 
-	mapOr<U>(def: U, _f: (a: T) => U): U {
-		return def;
+	and<U>(optb: Option<U>): Option<U> {
+		return this.isSome() ? optb : Option._noneInstance;
 	}
 
-	mapOrElse<U>(def: () => U, _f: (a: T) => U): U {
-		return def();
-	}
-
-	and<U>(_optb: Option<U>): Option<U> {
-		return _None.instance<U>();
-	}
-
-	andThen<U>(_f: (a: T) => Option<U>): Option<U> {
-		return _None.instance<U>();
+	andThen<U>(f: (a: T) => Option<U>): Option<U> {
+		return this.isSome() ? f(this.unwrap()) : Option._noneInstance;
 	}
 
 	or(optb: Option<T>): Option<T> {
-		return optb;
+		return this.isNone() ? optb : this;
 	}
 
 	orElse(f: () => Option<T>): Option<T> {
-		return f();
+		return this.isNone() ? f() : this;
 	}
 
-	private static _instance: Option<any> = new _None();
+	toString(): string {
+		const innerValue = (this.value !== undefined)
+			? JSON.stringify(this.value)
+			: '';
+		const prefix = this.optionType.valueOf();
 
-	public static instance<X>(): Option<X> {
-		return <Option<X>> _None._instance;
-	}
-
-	public toString(): string {
-		return 'None';
+		return (innerValue.length > 0) ? `${prefix} (${innerValue})` : prefix;
 	}
 }
 
-export const None: Option<any> = _None.instance();
-
-export function Some<T>(value: T): Option<T> {
-	return _Some.wrapNull(value);
-}
+export const { Some, None } = Option;
+export default Option;