Remove isErr, isErrAnd, isOk, isOkAnd

bkiac · Nov 4, 2023 · 520097e · 520097e
1 parent 0bf5190
commit 520097e
Show file tree

Hide file tree

Showing 6 changed files with 0 additions and 162 deletions.
diff --git a/src/result/err.ts b/src/result/err.ts
@@ -1,7 +1,6 @@
 import {Panic, UnwrapPanic} from "../error/panic"
 import {inspectSymbol} from "../util"
 import type {ErrVariant, Result, ResultMethods} from "./interface"
-import type {Ok} from "./ok"
 
 export class ErrImpl<E> implements ErrVariant<E>, ResultMethods<never, E> {
 	readonly ok = false
@@ -40,22 +39,6 @@ export class ErrImpl<E> implements ErrVariant<E>, ResultMethods<never, E> {
 		return this
 	}
 
-	isErr(): this is Err<E> {
-		return true
-	}
-
-	isErrAnd(f: (error: E) => boolean): this is Err<E> {
-		return f(this.error)
-	}
-
-	isOk(): this is Ok<never> {
-		return false
-	}
-
-	isOkAnd(_f: (value: never) => boolean): this is Ok<never> {
-		return false
-	}
-
 	map<U>(_f: (value: never) => U) {
 		return this
 	}

diff --git a/src/result/interface.ts b/src/result/interface.ts
@@ -1,7 +1,5 @@
 import type {Panic} from "../error/panic"
 import type {inspectSymbol} from "../util"
-import type {Err} from "./err"
-import type {Ok} from "./ok"
 
 export interface ResultMethods<T, E> {
 	and<U, F>(other: Result<U, F>): Result<U, E | F>
@@ -10,10 +8,6 @@ export interface ResultMethods<T, E> {
 	expectErr(panic: string | Panic): E
 	inspect(f: (value: T) => void): Result<T, E>
 	inspectErr(f: (error: E) => void): Result<T, E>
-	isErr(): this is Err<E>
-	isErrAnd(f: (error: E) => boolean): this is Err<E>
-	isOk(): this is Ok<T>
-	isOkAnd(f: (value: T) => boolean): this is Ok<T>
 	map<U>(f: (value: T) => U): Result<U, E>
 	mapErr<F>(f: (error: E) => F): Result<T, F>
 	mapOr<A, B>(defaultValue: A, f: (value: T) => B): A | B

diff --git a/src/result/ok.ts b/src/result/ok.ts
@@ -1,6 +1,5 @@
 import {Panic, UnwrapPanic} from "../error/panic"
 import {inspectSymbol} from "../util"
-import type {Err} from "./err"
 import type {OkVariant, Result, ResultMethods} from "./interface"
 
 export class OkImpl<T> implements OkVariant<T>, ResultMethods<T, never> {
@@ -40,22 +39,6 @@ export class OkImpl<T> implements OkVariant<T>, ResultMethods<T, never> {
 		return this
 	}
 
-	isErr(): this is Err<never> {
-		return false
-	}
-
-	isErrAnd(_f: (error: never) => boolean): this is Err<never> {
-		return false
-	}
-
-	isOk(): this is Ok<T> {
-		return true
-	}
-
-	isOkAnd(f: (value: T) => boolean): this is Ok<T> {
-		return f(this.value)
-	}
-
 	map<U>(f: (value: T) => U) {
 		return Ok(f(this.value))
 	}

diff --git a/src/result/promise.test.ts b/src/result/promise.test.ts
@@ -137,64 +137,6 @@ describe.concurrent("inspectErr", async () => {
 	})
 })
 
-describe.concurrent("isErr", () => {
-	it("returns false for an Ok result", async () => {
-		const result = new PromiseResult(Promise.resolve(Ok()))
-		await expect(result.isErr()).resolves.toEqual(false)
-	})
-
-	it("returns true for an Err result", async () => {
-		const result = new PromiseResult(Promise.resolve(Err(new Error("Test error"))))
-		await expect(result.isErr()).resolves.toEqual(true)
-	})
-})
-
-describe.concurrent("isErrAnd", () => {
-	it("returns false for an Ok result", async () => {
-		const result = new PromiseResult(Promise.resolve(Ok()))
-		await expect(result.isErrAnd(() => true)).resolves.toEqual(false)
-	})
-
-	it("returns true for an Err result when the provided function returns true", async () => {
-		const result = new PromiseResult(Promise.resolve(Err(new Error("Test error"))))
-		await expect(result.isErrAnd(() => true)).resolves.toEqual(true)
-	})
-
-	it("returns false for an Err result when the provided function returns false", async () => {
-		const result = new PromiseResult(Promise.resolve(Err(new Error("Test error"))))
-		await expect(result.isErrAnd(() => false)).resolves.toEqual(false)
-	})
-})
-
-describe.concurrent("isOk", () => {
-	it("returns true for an Ok result", async () => {
-		const result = new PromiseResult(Promise.resolve(Ok()))
-		await expect(result.isOk()).resolves.toEqual(true)
-	})
-
-	it("returns false for an Err result", async () => {
-		const result = new PromiseResult(Promise.resolve(Err(new Error("Test error"))))
-		await expect(result.isOk()).resolves.toEqual(false)
-	})
-})
-
-describe.concurrent("isOkAnd", () => {
-	it("returns true for an Ok result when the provided function returns true", async () => {
-		const result = new PromiseResult(Promise.resolve(Ok()))
-		await expect(result.isOkAnd(() => true)).resolves.toEqual(true)
-	})
-
-	it("returns false for an Ok result when the provided function returns false", async () => {
-		const result = new PromiseResult(Promise.resolve(Ok()))
-		await expect(result.isOkAnd(() => false)).resolves.toEqual(false)
-	})
-
-	it("returns false for an Err result", async () => {
-		const result = new PromiseResult(Promise.resolve(Err(new Error("Test error"))))
-		await expect(result.isOkAnd(() => true)).resolves.toEqual(false)
-	})
-})
-
 describe.concurrent("map", () => {
 	it("returns the mapped value for an Ok result", async () => {
 		const result = new PromiseResult(Promise.resolve(Ok(42)))

diff --git a/src/result/promise.ts b/src/result/promise.ts
@@ -56,22 +56,6 @@ export class PromiseResult<T, E> implements PromiseLike<Result<T, E>> {
 		return new PromiseResult<T, E>(this.then((result) => result.inspectErr(f)))
 	}
 
-	async isErr(): Promise<boolean> {
-		return (await this).isErr()
-	}
-
-	async isErrAnd(f: (error: E) => boolean): Promise<boolean> {
-		return (await this).isErrAnd(f)
-	}
-
-	async isOk(): Promise<boolean> {
-		return (await this).isOk()
-	}
-
-	async isOkAnd(f: (value: T) => boolean): Promise<boolean> {
-		return (await this).isOkAnd(f)
-	}
-
 	map<U>(f: (value: T) => U): PromiseResult<U, E> {
 		return new PromiseResult(this.then((result) => result.map(f)))
 	}

diff --git a/src/result/result.test.ts b/src/result/result.test.ts
@@ -139,54 +139,6 @@ describe.concurrent("inspectErr", () => {
 	})
 })
 
-describe.concurrent("isErr", () => {
-	it("returns false for an Ok result", () => {
-		const result = Ok(42)
-		expect(result.isErr()).toEqual(false)
-	})
-
-	it("returns true for an Err result", () => {
-		const result = Err("error")
-		expect(result.isErr()).toEqual(true)
-	})
-})
-
-describe.concurrent("isErrAnd", () => {
-	it("returns false for an Ok result", () => {
-		const result = Ok(42)
-		expect(result.isErrAnd(() => true)).toEqual(false)
-	})
-
-	it("returns true for an Err result", () => {
-		const result = Err("error")
-		expect(result.isErrAnd(() => true)).toEqual(true)
-	})
-})
-
-describe.concurrent("isOk", () => {
-	it("returns true for an Ok result", () => {
-		const result = Ok(42)
-		expect(result.isOk()).toEqual(true)
-	})
-
-	it("returns false for an Err result", () => {
-		const result = Err("error")
-		expect(result.isOk()).toEqual(false)
-	})
-})
-
-describe.concurrent("isOkAnd", () => {
-	it("returns true for an Ok result", () => {
-		const result = Ok(42)
-		expect(result.isOkAnd(() => true)).toEqual(true)
-	})
-
-	it("returns false for an Err result", () => {
-		const result = Err("error")
-		expect(result.isOkAnd(() => true)).toEqual(false)
-	})
-})
-
 describe.concurrent("map", () => {
 	it("returns the mapped value for an Ok result", () => {
 		const result = Ok(42)