Rename require to assume

Because `require` is registered word in node-js

Author: lambdalisue

README.md

@@ -145,60 +145,60 @@ ensureLike({}, b); // Now 'b' is 'Record<string, unknown>'
 ensureLike({ foo: "", bar: 0 }, b); // Now 'b' is '{foo: string, bar: number}'
 ```
 
-### requireXXXXX
+### assumeXXXXX
 
-The `unknownutil` provides the following require functions which returns a given
+The `unknownutil` provides the following assume functions which returns a given
 `x` as is or raise `EnsureError` when that is not expected type.
 
-- `requireString(x: unknown): string`
-- `requireNumber(x: unknown): number`
-- `requireBoolean(x: unknown): boolean`
-- `requireArray<T extends unknown>(x: unknown, pred?: Predicate<T>): T[]`
-- `requireObject<T extends unknown>(x: unknown, pred?: Predicate<T>): Record<string, T>`
-- `requireFunction(x: unknown): (...args: unknown[]) => unknown`
-- `requireNull(x: unknown): null`
-- `requireUndefined(x: unknown): undefined`
-- `requireNone(x: unknown): null | undefined`
+- `assumeString(x: unknown): string`
+- `assumeNumber(x: unknown): number`
+- `assumeBoolean(x: unknown): boolean`
+- `assumeArray<T extends unknown>(x: unknown, pred?: Predicate<T>): T[]`
+- `assumeObject<T extends unknown>(x: unknown, pred?: Predicate<T>): Record<string, T>`
+- `assumeFunction(x: unknown): (...args: unknown[]) => unknown`
+- `assumeNull(x: unknown): null`
+- `assumeUndefined(x: unknown): undefined`
+- `assumeNone(x: unknown): null | undefined`
 
 For example:
 
 ```typescript
-import { requireString } from "https://deno.land/x/unknownutil/mod.ts";
+import { assumeString } from "https://deno.land/x/unknownutil/mod.ts";
 
 const a: unknown = "Hello";
-const a1 = requireString(a); // Now 'a' and 'a1' is 'string'
+const a1 = assumeString(a); // Now 'a' and 'a1' is 'string'
 
 const b: unknown = 0;
-const b1 = requireString(b); // Raise EnsureError on above while 'b' is not string
+const b1 = assumeString(b); // Raise EnsureError on above while 'b' is not string
 ```
 
-Additionally, `requireArray` and `requireObject` supports an inner predicate
+Additionally, `assumeArray` and `assumeObject` supports an inner predicate
 function to predicate `x` more precisely like:
 
 ```typescript
-import { isString, requireArray } from "https://deno.land/x/unknownutil/mod.ts";
+import { assumeArray, isString } from "https://deno.land/x/unknownutil/mod.ts";
 
 const a: unknown = ["a", "b", "c"];
-const a1 = requireArray(a); // Now 'a' and 'a1' is 'unknown[]'
-const a2 = requireArray(a, isString); // Now 'a' and 'a2' is 'string[]'
+const a1 = assumeArray(a); // Now 'a' and 'a1' is 'unknown[]'
+const a2 = assumeArray(a, isString); // Now 'a' and 'a2' is 'string[]'
 
 const b: unknown = [0, 1, 2];
-const b1 = requireArray(b); // Now 'b' and 'b1' is 'unknown[]'
-const b2 = requireArray(b, isString); // Raise EnsureError on above while 'b' is not string array
+const b1 = assumeArray(b); // Now 'b' and 'b1' is 'unknown[]'
+const b2 = assumeArray(b, isString); // Raise EnsureError on above while 'b' is not string array
 ```
 
-Use `requireLike` if you need some complicated types like tuple or struct like:
+Use `assumeLike` if you need some complicated types like tuple or struct like:
 
 ```typescript
-import { requireLike } from "https://deno.land/x/unknownutil/mod.ts";
+import { assumeLike } from "https://deno.land/x/unknownutil/mod.ts";
 
 const a: unknown = ["a", "b", "c"];
-const a1 = requireLike([], a); // Now 'a' and 'a1' is 'unknown[]'
-const a2 = requireLike(["", "", ""], a); // Now 'a' and 'a2' is '[string, string, string]'
+const a1 = assumeLike([], a); // Now 'a' and 'a1' is 'unknown[]'
+const a2 = assumeLike(["", "", ""], a); // Now 'a' and 'a2' is '[string, string, string]'
 
 const b: unknown = { foo: "foo", bar: 0 };
-const b1 = requireLike({}, b); // Now 'b' and 'b1' is 'Record<string, unknown>'
-const b2 = requireLike({ foo: "", bar: 0 }, b); // Now 'b' and 'b2' is '{foo: string, bar: number}'
+const b1 = assumeLike({}, b); // Now 'b' and 'b1' is 'Record<string, unknown>'
+const b2 = assumeLike({ foo: "", bar: 0 }, b); // Now 'b' and 'b2' is '{foo: string, bar: number}'
 ```
 
 ## Development

require.ts renamed to assume.ts

@@ -16,7 +16,7 @@ import {
 /**
  * Return `x` as-is if `x` is expected type or raise an `EnsureError` when it's not.
  */
-export function require<T>(
+export function assume<T>(
   x: unknown,
   pred: Predicate<T>,
   message = "The value is not expected type",
@@ -28,31 +28,31 @@ export function require<T>(
 /**
  * Return `x` as-is if `x` is string or raise an `EnsureError` when it's not.
  */
-export function requireString(x: unknown): string {
+export function assumeString(x: unknown): string {
   ensureString(x);
   return x;
 }
 
 /**
  * Return `x` as-is if `x` is number or raise an `EnsureError` when it's not.
  */
-export function requireNumber(x: unknown): number {
+export function assumeNumber(x: unknown): number {
   ensureNumber(x);
   return x;
 }
 
 /**
  * Return `x` as-is if `x` is boolean or raise an `EnsureError` when it's not.
  */
-export function requireBoolean(x: unknown): boolean {
+export function assumeBoolean(x: unknown): boolean {
   ensureBoolean(x);
   return x;
 }
 
 /**
  * Return `x` as-is if `x` is array or raise an `EnsureError` when it's not.
  */
-export function requireArray<T extends unknown>(
+export function assumeArray<T extends unknown>(
   x: unknown,
   ipred?: Predicate<T>,
 ): T[] {
@@ -63,7 +63,7 @@ export function requireArray<T extends unknown>(
 /**
  * Return `x` as-is if `x` is object or raise an `EnsureError` when it's not.
  */
-export function requireObject<T>(
+export function assumeObject<T>(
   x: unknown,
   ipred?: Predicate<T>,
 ): Record<string, T> {
@@ -74,41 +74,39 @@ export function requireObject<T>(
 /**
  * Return `x` as-is if `x` is function or raise an `EnsureError` when it's not.
  */
-export function requireFunction(
-  x: unknown,
-): (...args: unknown[]) => unknown {
+export function assumeFunction(x: unknown): (...args: unknown[]) => unknown {
   ensureFunction(x);
   return x;
 }
 
 /**
  * Return `x` as-is if `x` is null or raise an `EnsureError` when it's not.
  */
-export function requireNull(x: unknown): null {
+export function assumeNull(x: unknown): null {
   ensureNull(x);
   return x;
 }
 
 /**
  * Return `x` as-is if `x` is undefined or raise an `EnsureError` when it's not.
  */
-export function requireUndefined(x: unknown): undefined {
+export function assumeUndefined(x: unknown): undefined {
   ensureUndefined(x);
   return x;
 }
 
 /**
  * Return `x` as-is if `x` is null or undefined or raise an `EnsureError` when it's not.
  */
-export function requireNone(x: unknown): null | undefined {
+export function assumeNone(x: unknown): null | undefined {
   ensureNone(x);
   return x;
 }
 
 /**
  * Return `x` as-is if `x` follows the reference or raise an `EnsureError` when it doesn't.
  */
-export function requireLike<R, T extends unknown>(
+export function assumeLike<R, T extends unknown>(
   ref: R,
   x: unknown,
   ipred?: Predicate<T>,