ts-data-forge 13.0.0 → 14.0.1

package/src/array/impl/array-utils-length-bounded-array-guard.mts

@@ -20,36 +20,75 @@ import {
  *   example, a value narrowed to `MinLengthArray<3, E>` is assignable to
  *   `MinLengthArray<1, E>`.
  *
+ * The length argument comes first, matching the type-parameter order of
+ * `MinLengthArray<MinLength, Elm>`. Omitting the array returns a reusable type
+ * guard, which is convenient for `filter`/`pipe`.
+ *
  * @example
  *
  * ```ts
- * const input: readonly number[] = [0, 1, 2, 3];
+ * const input: readonly number[] = [0, 1, 2, 3] as const;
  *
- * assert.isTrue(Arr.isMinLengthArray(input, 3));
+ * assert.isTrue(Arr.isMinLengthArray(3, input));
  *
- * assert.isFalse(Arr.isMinLengthArray([0], 3));
+ * assert.isFalse(Arr.isMinLengthArray(3, [0]));
  *
- * if (Arr.isMinLengthArray(input, 3)) {
+ * if (Arr.isMinLengthArray(3, input)) {
  *   const history: MinLengthArray<3, number> = input;
  *
  *   const nonEmpty: MinLengthArray<1, number> = input; // OK (3 >= 1)
+ *
+ *   assert.deepStrictEqual(history[0], 0);
+ *
+ *   assert.deepStrictEqual(nonEmpty[0], 0);
  * }
+ *
+ * // curried version
+ * const hasThree = Arr.isMinLengthArray(3);
+ *
+ * assert.isTrue(hasThree(input));
  * ```
  *
- * @template Xs - The input array type (tuple types are preserved).
  * @template MinLength - The minimum number of elements (inclusive).
- * @param xs - The array to check.
+ * @template Xs - The input array type (tuple types are preserved).
  * @param minLength - The minimum number of elements (inclusive).
+ * @param xs - The array to check.
  * @returns `true` if `xs.length >= minLength`, `false` otherwise. When `true`,
  *   TypeScript narrows `xs` to `MinLengthArray<MinLength, Xs[number]> & Xs`.
  */
-export const isMinLengthArray = <
-  Xs extends readonly unknown[],
+export function isMinLengthArray<
   MinLength extends SupportedLength,
+  Xs extends readonly unknown[],
 >(
+  minLength: MinLength,
   xs: Xs,
+): xs is MinLengthArray<MinLength, Xs[number]> & Xs;
+
+// Curried version
+export function isMinLengthArray<MinLength extends SupportedLength>(
   minLength: MinLength,
-): xs is MinLengthArray<MinLength, Xs[number]> & Xs => xs.length >= minLength;
+): <Xs extends readonly unknown[]>(
+  xs: Xs,
+) => xs is MinLengthArray<MinLength, Xs[number]> & Xs;
+
+export function isMinLengthArray(
+  ...args:
+    | readonly [minLength: SupportedLength, xs: readonly unknown[]]
+    | readonly [minLength: SupportedLength]
+): boolean | ((xs: readonly unknown[]) => boolean) {
+  switch (args.length) {
+    case 2:
+      return hasMinLength(...args);
+
+    case 1:
+      return (xs) => hasMinLength(args[0], xs);
+  }
+}
+
+const hasMinLength = (
+  minLength: SupportedLength,
+  xs: readonly unknown[],
+): boolean => xs.length >= minLength;
 
 /**
  * Type guard that checks if an array has at most `maxLength` elements.
@@ -65,36 +104,75 @@ export const isMinLengthArray = <
  *   example, a value narrowed to `MaxLengthArray<8, E>` is assignable to
  *   `MaxLengthArray<16, E>`.
  *
+ * The length argument comes first, matching the type-parameter order of
+ * `MaxLengthArray<MaxLength, Elm>`. Omitting the array returns a reusable type
+ * guard, which is convenient for `filter`/`pipe`.
+ *
  * @example
  *
  * ```ts
- * const input: readonly string[] = ['a', 'b', 'c'];
+ * const input: readonly string[] = ['a', 'b', 'c'] as const;
  *
- * assert.isTrue(Arr.isMaxLengthArray(input, 8));
+ * assert.isTrue(Arr.isMaxLengthArray(8, input));
  *
- * assert.isFalse(Arr.isMaxLengthArray(input, 2));
+ * assert.isFalse(Arr.isMaxLengthArray(2, input));
  *
- * if (Arr.isMaxLengthArray(input, 8)) {
+ * if (Arr.isMaxLengthArray(8, input)) {
  *   const tags: MaxLengthArray<8, string> = input;
  *
  *   const relaxed: MaxLengthArray<16, string> = input; // OK (8 <= 16)
+ *
+ *   assert.deepStrictEqual(tags.length, 3);
+ *
+ *   assert.deepStrictEqual(relaxed.length, 3);
  * }
+ *
+ * // curried version
+ * const fitsInEight = Arr.isMaxLengthArray(8);
+ *
+ * assert.isTrue(fitsInEight(input));
  * ```
  *
- * @template Xs - The input array type (tuple types are preserved).
  * @template MaxLength - The maximum number of elements (inclusive).
- * @param xs - The array to check.
+ * @template Xs - The input array type (tuple types are preserved).
  * @param maxLength - The maximum number of elements (inclusive).
+ * @param xs - The array to check.
  * @returns `true` if `xs.length <= maxLength`, `false` otherwise. When `true`,
  *   TypeScript narrows `xs` to `MaxLengthArray<MaxLength, Xs[number]> & Xs`.
  */
-export const isMaxLengthArray = <
-  Xs extends readonly unknown[],
+export function isMaxLengthArray<
   MaxLength extends SupportedLength,
+  Xs extends readonly unknown[],
 >(
+  maxLength: MaxLength,
   xs: Xs,
+): xs is MaxLengthArray<MaxLength, Xs[number]> & Xs;
+
+// Curried version
+export function isMaxLengthArray<MaxLength extends SupportedLength>(
   maxLength: MaxLength,
-): xs is MaxLengthArray<MaxLength, Xs[number]> & Xs => xs.length <= maxLength;
+): <Xs extends readonly unknown[]>(
+  xs: Xs,
+) => xs is MaxLengthArray<MaxLength, Xs[number]> & Xs;
+
+export function isMaxLengthArray(
+  ...args:
+    | readonly [maxLength: SupportedLength, xs: readonly unknown[]]
+    | readonly [maxLength: SupportedLength]
+): boolean | ((xs: readonly unknown[]) => boolean) {
+  switch (args.length) {
+    case 2:
+      return hasMaxLength(...args);
+
+    case 1:
+      return (xs) => hasMaxLength(args[0], xs);
+  }
+}
+
+const hasMaxLength = (
+  maxLength: SupportedLength,
+  xs: readonly unknown[],
+): boolean => xs.length <= maxLength;
 
 /**
  * Type guard that checks if an array's length is within the inclusive range
@@ -111,42 +189,89 @@ export const isMaxLengthArray = <
  *   type checker even when the element type is large — unlike
  *   `isBoundedLengthTuple`, which narrows to a union of tuple types.
  *
+ * The length arguments come first, matching the type-parameter order of
+ * `BoundedLengthArray<MinLength, MaxLength, Elm>`. Omitting the array returns a
+ * reusable type guard, which is convenient for `filter`/`pipe`.
+ *
  * @example
  *
  * ```ts
- * const input: readonly number[] = [1, 2, 3];
+ * const input: readonly number[] = [1, 2, 3] as const;
  *
- * assert.isTrue(Arr.isBoundedLengthArray(input, 1, 5));
+ * assert.isTrue(Arr.isBoundedLengthArray(1, 5, input));
  *
- * assert.isFalse(Arr.isBoundedLengthArray([], 1, 5));
+ * assert.isFalse(Arr.isBoundedLengthArray(1, 5, []));
  *
- * if (Arr.isBoundedLengthArray(input, 1, 5)) {
+ * if (Arr.isBoundedLengthArray(1, 5, input)) {
  *   const selection: BoundedLengthArray<1, 5, number> = input;
  *
  *   const relaxed: BoundedLengthArray<0, 100, number> = input; // OK ([1, 5] ⊆ [0, 100])
+ *
+ *   assert.deepStrictEqual(selection[0], 1);
+ *
+ *   assert.deepStrictEqual(relaxed.length, 3);
  * }
+ *
+ * // curried version
+ * const isSmallSelection = Arr.isBoundedLengthArray(1, 5);
+ *
+ * assert.isTrue(isSmallSelection(input));
  * ```
  *
- * @template Xs - The input array type (tuple types are preserved).
  * @template MinLength - The minimum number of elements (inclusive).
  * @template MaxLength - The maximum number of elements (inclusive).
- * @param xs - The array to check.
+ * @template Xs - The input array type (tuple types are preserved).
  * @param minLength - The minimum number of elements (inclusive).
  * @param maxLength - The maximum number of elements (inclusive).
+ * @param xs - The array to check.
  * @returns `true` if `minLength <= xs.length && xs.length <= maxLength`,
  *   `false` otherwise. When `true`, TypeScript narrows `xs` to
  *   `BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs`.
  */
-export const isBoundedLengthArray = <
-  Xs extends readonly unknown[],
+export function isBoundedLengthArray<
   MinLength extends SupportedLength,
   MaxLength extends SupportedLength,
+  Xs extends readonly unknown[],
 >(
+  minLength: MinLength,
+  maxLength: MaxLength,
   xs: Xs,
+): xs is BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs;
+
+// Curried version
+export function isBoundedLengthArray<
+  MinLength extends SupportedLength,
+  MaxLength extends SupportedLength,
+>(
   minLength: MinLength,
   maxLength: MaxLength,
-): xs is BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs =>
-  xs.length >= minLength && xs.length <= maxLength;
+): <Xs extends readonly unknown[]>(
+  xs: Xs,
+) => xs is BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs;
+
+export function isBoundedLengthArray(
+  ...args:
+    | readonly [
+        minLength: SupportedLength,
+        maxLength: SupportedLength,
+        xs: readonly unknown[],
+      ]
+    | readonly [minLength: SupportedLength, maxLength: SupportedLength]
+): boolean | ((xs: readonly unknown[]) => boolean) {
+  switch (args.length) {
+    case 3:
+      return hasBoundedLength(...args);
+
+    case 2:
+      return (xs) => hasBoundedLength(args[0], args[1], xs);
+  }
+}
+
+const hasBoundedLength = (
+  minLength: SupportedLength,
+  maxLength: SupportedLength,
+  xs: readonly unknown[],
+): boolean => xs.length >= minLength && xs.length <= maxLength;
 
 /**
  * Type guard that checks if an array has exactly `length` elements.
@@ -163,33 +288,117 @@ export const isBoundedLengthArray = <
  *   type checker even when the element type is large — unlike
  *   `isFixedLengthTuple`, which narrows to a structural tuple type.
  *
+ * The length argument comes first, matching the type-parameter order of
+ * `FixedLengthArray<Length, Elm>`. Omitting the array returns a reusable type
+ * guard, which is convenient for `filter`/`pipe`.
+ *
  * @example
  *
  * ```ts
- * const input: readonly number[] = [255, 128, 0];
+ * const input: readonly number[] = [255, 128, 0] as const;
  *
- * assert.isTrue(Arr.isFixedLengthArray(input, 3));
+ * assert.isTrue(Arr.isFixedLengthArray(3, input));
  *
- * assert.isFalse(Arr.isFixedLengthArray(input, 4));
+ * assert.isFalse(Arr.isFixedLengthArray(4, input));
  *
- * if (Arr.isFixedLengthArray(input, 3)) {
+ * if (Arr.isFixedLengthArray(3, input)) {
  *   const rgb: FixedLengthArray<3, number> = input;
  *
  *   const atMost5: MaxLengthArray<5, number> = input; // OK (3 <= 5)
+ *
+ *   assert.deepStrictEqual(rgb[0], 255);
+ *
+ *   assert.deepStrictEqual(atMost5.length, 3);
  * }
+ *
+ * // curried version
+ * const isRgb = Arr.isFixedLengthArray(3);
+ *
+ * assert.isTrue(isRgb(input));
  * ```
  *
- * @template Xs - The input array type (tuple types are preserved).
  * @template Length - The exact number of elements.
- * @param xs - The array to check.
+ * @template Xs - The input array type (tuple types are preserved).
  * @param length - The exact number of elements.
+ * @param xs - The array to check.
  * @returns `true` if `xs.length === length`, `false` otherwise. When `true`,
  *   TypeScript narrows `xs` to `FixedLengthArray<Length, Xs[number]> & Xs`.
  */
-export const isFixedLengthArray = <
-  Xs extends readonly unknown[],
+export function isFixedLengthArray<
   Length extends SupportedLength,
->(
-  xs: Xs,
+  Xs extends readonly unknown[],
+>(length: Length, xs: Xs): xs is FixedLengthArray<Length, Xs[number]> & Xs;
+
+// Curried version
+export function isFixedLengthArray<Length extends SupportedLength>(
   length: Length,
-): xs is FixedLengthArray<Length, Xs[number]> & Xs => xs.length === length;
+): <Xs extends readonly unknown[]>(
+  xs: Xs,
+) => xs is FixedLengthArray<Length, Xs[number]> & Xs;
+
+export function isFixedLengthArray(
+  ...args:
+    | readonly [length: SupportedLength, xs: readonly unknown[]]
+    | readonly [length: SupportedLength]
+): boolean | ((xs: readonly unknown[]) => boolean) {
+  switch (args.length) {
+    case 2:
+      return hasFixedLength(...args);
+
+    case 1:
+      return (xs) => hasFixedLength(args[0], xs);
+  }
+}
+
+const hasFixedLength = (
+  length: SupportedLength,
+  xs: readonly unknown[],
+): boolean => xs.length === length;
+
+/**
+ * Type guard that checks if an array is empty.
+ *
+ * @example
+ *
+ * ```ts
+ * const emptyNumbers: readonly number[] = [] as const;
+ *
+ * const words = ['Ada', 'Lovelace'] as const;
+ *
+ * assert.isTrue(Arr.isEmpty(emptyNumbers));
+ *
+ * assert.isFalse(Arr.isEmpty(words));
+ *
+ * if (Arr.isEmpty(emptyNumbers)) {
+ *   // `isEmpty` narrows to the branded `FixedLengthArray<0, number>`, so the
+ *   // expected value is annotated with the unbranded type.
+ *   assert.deepStrictEqual<readonly number[]>(emptyNumbers, []);
+ * }
+ * ```
+ */
+export const isEmpty = <Xs extends readonly unknown[]>(
+  array: Xs,
+): array is FixedLengthArray<0, Xs[number]> & Xs => array.length === 0;
+
+/**
+ * Type guard that checks if an array is non-empty.
+ *
+ * @example
+ *
+ * ```ts
+ * const users: readonly Readonly<{ id: number }>[] = [{ id: 1 }] as const;
+ *
+ * const emptyUsers: readonly Readonly<{ id: number }>[] = [] as const;
+ *
+ * assert.isTrue(Arr.isNonEmpty(users));
+ *
+ * assert.isFalse(Arr.isNonEmpty(emptyUsers));
+ *
+ * if (Arr.isNonEmpty(users)) {
+ *   assert.deepStrictEqual(users[0], { id: 1 });
+ * }
+ * ```
+ */
+export const isNonEmpty = <Xs extends readonly unknown[]>(
+  array: Xs,
+): array is MinLengthArray<1, Xs[number]> & Xs => array.length > 0;

package/src/array/impl/array-utils-length-bounded-array-guard.test.mts

@@ -7,30 +7,32 @@ import {
 import { expectType } from '../../expect-type.mjs';
 import {
   isBoundedLengthArray,
+  isEmpty,
   isFixedLengthArray,
   isMaxLengthArray,
   isMinLengthArray,
+  isNonEmpty,
 } from './array-utils-length-bounded-array-guard.mjs';
 
 describe(isMinLengthArray, () => {
   test('should return true when the array is long enough', () => {
-    assert.isTrue(isMinLengthArray([1, 2, 3], 3));
+    assert.isTrue(isMinLengthArray(3, [1, 2, 3]));
 
-    assert.isTrue(isMinLengthArray([1, 2, 3], 2));
+    assert.isTrue(isMinLengthArray(2, [1, 2, 3]));
 
-    assert.isTrue(isMinLengthArray([], 0));
+    assert.isTrue(isMinLengthArray(0, []));
   });
 
   test('should return false when the array is too short', () => {
-    assert.isFalse(isMinLengthArray([1, 2], 3));
+    assert.isFalse(isMinLengthArray(3, [1, 2]));
 
-    assert.isFalse(isMinLengthArray([], 1));
+    assert.isFalse(isMinLengthArray(1, []));
   });
 
   test('should act as a type guard', () => {
     const value: readonly number[] = [0, 1, 2, 3] as const;
 
-    if (isMinLengthArray(value, 3)) {
+    if (isMinLengthArray(3, value)) {
       expectType<typeof value, MinLengthArray<3, number>>('<=');
 
       expectType<typeof value, MinLengthArray<1, number>>('<='); // 3 >= 1
@@ -58,7 +60,7 @@ describe(isMinLengthArray, () => {
   test('should preserve the original array type', () => {
     const tuple = [1, 2, 3] as const;
 
-    if (isMinLengthArray(tuple, 2)) {
+    if (isMinLengthArray(2, tuple)) {
       expectType<typeof tuple, readonly [1, 2, 3]>('<=');
 
       expectType<typeof tuple, MinLengthArray<2, 1 | 2 | 3>>('<=');
@@ -68,23 +70,23 @@ describe(isMinLengthArray, () => {
 
 describe(isMaxLengthArray, () => {
   test('should return true when the array is short enough', () => {
-    assert.isTrue(isMaxLengthArray([1, 2, 3], 3));
+    assert.isTrue(isMaxLengthArray(3, [1, 2, 3]));
 
-    assert.isTrue(isMaxLengthArray([1, 2, 3], 4));
+    assert.isTrue(isMaxLengthArray(4, [1, 2, 3]));
 
-    assert.isTrue(isMaxLengthArray([], 0));
+    assert.isTrue(isMaxLengthArray(0, []));
   });
 
   test('should return false when the array is too long', () => {
-    assert.isFalse(isMaxLengthArray([1, 2, 3], 2));
+    assert.isFalse(isMaxLengthArray(2, [1, 2, 3]));
 
-    assert.isFalse(isMaxLengthArray([1], 0));
+    assert.isFalse(isMaxLengthArray(0, [1]));
   });
 
   test('should act as a type guard', () => {
     const value: readonly number[] = [0, 1, 2] as const;
 
-    if (isMaxLengthArray(value, 8)) {
+    if (isMaxLengthArray(8, value)) {
       expectType<typeof value, MaxLengthArray<8, number>>('<=');
 
       expectType<typeof value, MaxLengthArray<16, number>>('<='); // 8 <= 16
@@ -98,23 +100,23 @@ describe(isMaxLengthArray, () => {
 
 describe(isBoundedLengthArray, () => {
   test('should return true when the length is within the range', () => {
-    assert.isTrue(isBoundedLengthArray([1, 2, 3], 1, 5));
+    assert.isTrue(isBoundedLengthArray(1, 5, [1, 2, 3]));
 
-    assert.isTrue(isBoundedLengthArray([1], 1, 5));
+    assert.isTrue(isBoundedLengthArray(1, 5, [1]));
 
-    assert.isTrue(isBoundedLengthArray([1, 2, 3, 4, 5], 1, 5));
+    assert.isTrue(isBoundedLengthArray(1, 5, [1, 2, 3, 4, 5]));
   });
 
   test('should return false when the length is out of the range', () => {
-    assert.isFalse(isBoundedLengthArray([], 1, 5));
+    assert.isFalse(isBoundedLengthArray(1, 5, []));
 
-    assert.isFalse(isBoundedLengthArray([1, 2, 3, 4, 5, 6], 1, 5));
+    assert.isFalse(isBoundedLengthArray(1, 5, [1, 2, 3, 4, 5, 6]));
   });
 
   test('should act as a type guard', () => {
     const value: readonly number[] = [1, 2, 3] as const;
 
-    if (isBoundedLengthArray(value, 1, 5)) {
+    if (isBoundedLengthArray(1, 5, value)) {
       expectType<typeof value, BoundedLengthArray<1, 5, number>>('<=');
 
       expectType<typeof value, BoundedLengthArray<0, 100, number>>('<=');
@@ -130,21 +132,21 @@ describe(isBoundedLengthArray, () => {
 
 describe(isFixedLengthArray, () => {
   test('should return true when the length matches exactly', () => {
-    assert.isTrue(isFixedLengthArray([1, 2, 3], 3));
+    assert.isTrue(isFixedLengthArray(3, [1, 2, 3]));
 
-    assert.isTrue(isFixedLengthArray([], 0));
+    assert.isTrue(isFixedLengthArray(0, []));
   });
 
   test('should return false when the length does not match', () => {
-    assert.isFalse(isFixedLengthArray([1, 2, 3], 2));
+    assert.isFalse(isFixedLengthArray(2, [1, 2, 3]));
 
-    assert.isFalse(isFixedLengthArray([1, 2, 3], 4));
+    assert.isFalse(isFixedLengthArray(4, [1, 2, 3]));
   });
 
   test('should act as a type guard', () => {
     const value: readonly number[] = [255, 128, 0] as const;
 
-    if (isFixedLengthArray(value, 3)) {
+    if (isFixedLengthArray(3, value)) {
       expectType<typeof value, FixedLengthArray<3, number>>('<=');
 
       expectType<typeof value, MaxLengthArray<5, number>>('<='); // 3 <= 5
@@ -167,3 +169,112 @@ describe(isFixedLengthArray, () => {
     }
   });
 });
+
+describe('curried length guards', () => {
+  test('isMinLengthArray narrows when applied later', () => {
+    const hasThree = isMinLengthArray(3);
+
+    assert.isTrue(hasThree([1, 2, 3]));
+
+    assert.isFalse(hasThree([1, 2]));
+
+    const value: readonly number[] = [0, 1, 2, 3] as const;
+
+    assert.isTrue(hasThree(value));
+
+    if (hasThree(value)) {
+      expectType<typeof value, MinLengthArray<3, number>>('<=');
+
+      const _first = value[0];
+
+      expectType<typeof _first, number>('=');
+    }
+  });
+
+  test('isMaxLengthArray narrows when applied later', () => {
+    const fitsInTwo = isMaxLengthArray(2);
+
+    assert.isTrue(fitsInTwo([1, 2]));
+
+    assert.isFalse(fitsInTwo([1, 2, 3]));
+
+    const value: readonly number[] = [1, 2] as const;
+
+    if (fitsInTwo(value)) {
+      expectType<typeof value, MaxLengthArray<2, number>>('<=');
+    }
+  });
+
+  test('isFixedLengthArray narrows when applied later', () => {
+    const isRgb = isFixedLengthArray(3);
+
+    assert.isTrue(isRgb([255, 128, 0]));
+
+    assert.isFalse(isRgb([255, 128]));
+
+    const value: readonly number[] = [255, 128, 0] as const;
+
+    if (isRgb(value)) {
+      expectType<typeof value, FixedLengthArray<3, number>>('<=');
+    }
+  });
+
+  test('isBoundedLengthArray narrows when applied later', () => {
+    const isSmallSelection = isBoundedLengthArray(1, 3);
+
+    assert.isTrue(isSmallSelection([1, 2]));
+
+    assert.isFalse(isSmallSelection([]));
+
+    assert.isFalse(isSmallSelection([1, 2, 3, 4]));
+
+    const value: readonly number[] = [1, 2] as const;
+
+    if (isSmallSelection(value)) {
+      expectType<typeof value, BoundedLengthArray<1, 3, number>>('<=');
+    }
+  });
+
+  test('the returned guard is reusable across arrays', () => {
+    const isNonEmptyEnough = isMinLengthArray(2);
+
+    assert.deepStrictEqual([[1], [1, 2], [1, 2, 3]].filter(isNonEmptyEnough), [
+      [1, 2],
+      [1, 2, 3],
+    ]);
+  });
+});
+
+describe('empty / non-empty guards', () => {
+  describe(isEmpty, () => {
+    const xs = [1, 2, 3] as const;
+
+    const result = isEmpty(xs);
+
+    expectType<typeof result, boolean>('=');
+
+    test('case 1', () => {
+      assert.isFalse(result);
+    });
+
+    test('case 2', () => {
+      assert.isTrue(isEmpty([]));
+    });
+  });
+
+  describe(isNonEmpty, () => {
+    const xs = [1, 2, 3] as const;
+
+    const result = isNonEmpty(xs);
+
+    expectType<typeof result, boolean>('=');
+
+    test('case 1', () => {
+      assert.isTrue(result);
+    });
+
+    test('case 2', () => {
+      assert.isFalse(isNonEmpty([]));
+    });
+  });
+});