Rename xxxNone to xxxNullish

https://developer.mozilla.org/en-US/docs/Glossary/Nullish

Author: lambdalisue

README.md

@@ -24,7 +24,7 @@ The `unknownutil` provides the following predicate functions
 - `isFunction(x: unknown): x is (...args: unknown[]) => unknown`
 - `isNull(x: unknown): x is null`
 - `isUndefined(x: unknown): x is undefined`
-- `isNone(x: unknown): x is null | undefined`
+- `isNullish(x: unknown): x is null | undefined`
 - `isLike<R, T extends unknown>(ref: R, x: unknown, pred?: Predicate<T>): x is R`
 
 For example:
@@ -103,7 +103,7 @@ The `unknownutil` provides the following ensure functions which will raise
 - `ensureFunction(x: unknown): x is (...args: unknown[]) => unknown`
 - `ensureNull(x: unknown): x is null`
 - `ensureUndefined(x: unknown): x is undefined`
-- `ensureNone(x: unknown): x is null | undefined`
+- `ensureNullish(x: unknown): x is null | undefined`
 
 For example:
 
@@ -160,7 +160,7 @@ The `unknownutil` provides the following assume functions which returns a given
 - `assumeFunction(x: unknown): (...args: unknown[]) => unknown`
 - `assumeNull(x: unknown): null`
 - `assumeUndefined(x: unknown): undefined`
-- `assumeNone(x: unknown): null | undefined`
+- `assumeNullish(x: unknown): null | undefined`
 
 For example:
 

assume.ts

@@ -5,7 +5,7 @@ import {
   ensureBoolean,
   ensureFunction,
   ensureLike,
-  ensureNone,
+  ensureNullish,
   ensureNull,
   ensureNumber,
   ensureObject,
@@ -98,8 +98,8 @@ export function assumeUndefined(x: unknown): undefined {
 /**
  * Return `x` as-is if `x` is null or undefined or raise an `EnsureError` when it's not.
  */
-export function assumeNone(x: unknown): null | undefined {
-  ensureNone(x);
+export function assumeNullish(x: unknown): null | undefined {
+  ensureNullish(x);
   return x;
 }
 

assume_test.ts

@@ -5,7 +5,7 @@ import {
   assumeBoolean,
   assumeFunction,
   assumeLike,
-  assumeNone,
+  assumeNullish,
   assumeNull,
   assumeNumber,
   assumeObject,
@@ -177,20 +177,20 @@ Deno.test("assumeUndefined throws error on non undefined", () => {
 });
 
 Deno.test(
-  "assumeNone returns the value when the value is null or undefined",
+  "assumeNullish returns the value when the value is null or undefined",
   () => {
-    assertEquals(assumeNone(null), null);
-    assertEquals(assumeNone(undefined), undefined);
+    assertEquals(assumeNullish(null), null);
+    assertEquals(assumeNullish(undefined), undefined);
   },
 );
-Deno.test("assumeNone throws error on non null nor undefined", () => {
-  assertThrows(() => assumeNone("a"));
-  assertThrows(() => assumeNone(0));
-  assertThrows(() => assumeNone(true));
-  assertThrows(() => assumeNone(false));
-  assertThrows(() => assumeNone([]));
-  assertThrows(() => assumeNone({}));
-  assertThrows(() => assumeNone(function () {}));
+Deno.test("assumeNullish throws error on non null nor undefined", () => {
+  assertThrows(() => assumeNullish("a"));
+  assertThrows(() => assumeNullish(0));
+  assertThrows(() => assumeNullish(true));
+  assertThrows(() => assumeNullish(false));
+  assertThrows(() => assumeNullish([]));
+  assertThrows(() => assumeNullish({}));
+  assertThrows(() => assumeNullish(function () {}));
 });
 
 Deno.test("assumeLike does it's job on string", () => {

ensure.ts

@@ -3,7 +3,7 @@ import {
   isBoolean,
   isFunction,
   isLike,
-  isNone,
+  isNullish,
   isNull,
   isNumber,
   isObject,
@@ -106,8 +106,8 @@ export function ensureUndefined(x: unknown): asserts x is undefined {
 /**
  * Ensure if `x` is null or undefined by raising an `EnsureError` when it's not.
  */
-export function ensureNone(x: unknown): asserts x is null | undefined {
-  return ensure(x, isNone, "The value must be null or undefined");
+export function ensureNullish(x: unknown): asserts x is null | undefined {
+  return ensure(x, isNullish, "The value must be null or undefined");
 }
 
 /**

ensure_test.ts

@@ -5,7 +5,7 @@ import {
   ensureBoolean,
   ensureFunction,
   ensureLike,
-  ensureNone,
+  ensureNullish,
   ensureNull,
   ensureNumber,
   ensureObject,
@@ -164,18 +164,18 @@ Deno.test("ensureUndefined throws error on non undefined", () => {
   assertThrows(() => ensureUndefined(null));
 });
 
-Deno.test("ensureNone does nothing on null or undefined", () => {
-  ensureNone(null);
-  ensureNone(undefined);
-});
-Deno.test("ensureNone throws error on non null nor undefined", () => {
-  assertThrows(() => ensureNone("a"));
-  assertThrows(() => ensureNone(0));
-  assertThrows(() => ensureNone(true));
-  assertThrows(() => ensureNone(false));
-  assertThrows(() => ensureNone([]));
-  assertThrows(() => ensureNone({}));
-  assertThrows(() => ensureNone(function () {}));
+Deno.test("ensureNullish does nothing on null or undefined", () => {
+  ensureNullish(null);
+  ensureNullish(undefined);
+});
+Deno.test("ensureNullish throws error on non null nor undefined", () => {
+  assertThrows(() => ensureNullish("a"));
+  assertThrows(() => ensureNullish(0));
+  assertThrows(() => ensureNullish(true));
+  assertThrows(() => ensureNullish(false));
+  assertThrows(() => ensureNullish([]));
+  assertThrows(() => ensureNullish({}));
+  assertThrows(() => ensureNullish(function () {}));
 });
 
 Deno.test("ensureLike does it's job on string", () => {

is.ts

@@ -38,7 +38,7 @@ export function isObject<T extends unknown>(
   x: unknown,
   pred?: Predicate<T>,
 ): x is Record<string, T> {
-  if (isNone(x) || isArray(x)) {
+  if (isNullish(x) || isArray(x)) {
     return false;
   }
   return typeof x === "object" &&
@@ -70,7 +70,7 @@ export function isUndefined(x: unknown): x is undefined {
 /**
  * Return true if the value is null or undefined
  */
-export function isNone(x: unknown): x is null | undefined {
+export function isNullish(x: unknown): x is null | undefined {
   return x == null;
 }
 

is_test.ts

@@ -4,8 +4,8 @@ import {
   isBoolean,
   isFunction,
   isLike,
-  isNone,
   isNull,
+  isNullish,
   isNumber,
   isObject,
   isString,
@@ -154,18 +154,18 @@ Deno.test("isUndefined returns false on non null", () => {
   assertEquals(isUndefined(null), false);
 });
 
-Deno.test("isNone returns true on null/undefined", () => {
-  assertEquals(isNone(null), true);
-  assertEquals(isNone(undefined), true);
-});
-Deno.test("isNone returns false on non null/undefined", () => {
-  assertEquals(isNone(""), false);
-  assertEquals(isNone(0), false);
-  assertEquals(isNone(true), false);
-  assertEquals(isNone(false), false);
-  assertEquals(isNone([]), false);
-  assertEquals(isNone({}), false);
-  assertEquals(isNone(function () {}), false);
+Deno.test("isNullish returns true on null/undefined", () => {
+  assertEquals(isNullish(null), true);
+  assertEquals(isNullish(undefined), true);
+});
+Deno.test("isNullish returns false on non null/undefined", () => {
+  assertEquals(isNullish(""), false);
+  assertEquals(isNullish(0), false);
+  assertEquals(isNullish(true), false);
+  assertEquals(isNullish(false), false);
+  assertEquals(isNullish([]), false);
+  assertEquals(isNullish({}), false);
+  assertEquals(isNullish(function () {}), false);
 });
 
 Deno.test("isLike returns true/false on string", () => {