issue-#57, #87 - Updated 'drop' method to support 'Iterable<T>', and …

…updated some docs.

packages/fjl/src/list/append.ts

@@ -5,14 +5,14 @@ export const
   /**
    * Append two, or more, lists, i.e.,
    * ```
-   * expectEqual(append(take(13, alphabetString), drop(13, alphabetString)), alphabetString); // true
+   * expect(append(take(13, alphabetString), drop(13, alphabetString))).toEqual(alphabetString); // true
    *
    * // Another example
    * const result = append(
    *   alphabetStr.split(''),
    *   alphabetStr.split('')
    * ),
-   * expected = repeat(2, alphabetStr).split('');
+   * expected = take(2, repeat(alphabetStr));
    *
    * shallowEquals(result, expected) === true // `true`
    * ```

packages/fjl/src/list/drop.ts

@@ -1,11 +1,31 @@
-import {$sliceFrom, sliceFrom} from "./utils/sliceFrom";
+import {Slice} from "../types";
+import {instanceOfSome} from "../object";
 
 export const
 
-  $drop = $sliceFrom,
+  /**
+   * Drops `n` items from start of list.
+   *
+   * **Note:** Returns `string` type for strings, and `Array` type otherwise.
+   */
+  drop = <T = any>(n: number, xs: Slice<T> | Iterable<T>): typeof xs | T[] => {
+    if (instanceOfSome(xs, String, Array))
+      return (xs as (string | T[])).slice(n);
+
+    const out = [] as T[];
+    for (const x of xs) {
+      if (n-- > 0) continue;
+      out.push(x as T);
+    }
+    return out;
+  },
 
   /**
-   * Drops `n` items from start of list to `count` (exclusive).
+   * Curried version of `drop`.
+   *
+   * @curried
    */
-  drop = sliceFrom;
+  $drop = <T = any>(n: number) =>
+    (xs: Slice<T> | Iterable<T>): typeof xs | T[] => drop(n, xs)
 
+;

packages/fjl/src/types/data.ts

@@ -12,7 +12,7 @@ export interface Nameable {
 /**
  * Represents strings, arrays, and/or, any structures that contain a `length`, and number indices.
  *
- * @todo Consider deprecating this for [native] `Iterable<T>` type.
+ * @todo Consider using `Iterable<T>` type, instead of this type, where it makes sense.
  */
 export type  NumberIndexable<T = unknown> = ({
   length: number;
@@ -23,10 +23,11 @@ export type  NumberIndexable<T = unknown> = ({
    */
   {
     readonly length: number;
-    readonly [index: number]: any; // for `String`/`string`, type here
-    // should actually be `string`, this is too strict, for
-    // a Sum type, however, so `any` is used instead (works fine)
-    // interchangeably targeting `string`, and/or `Array` types, from overall type.
+    readonly [index: number]: any; // Even though string variant type here
+    // should actually be `string`, this is too strict for
+    // a Sum type so `any` is used instead - this allows
+    // `string`, and/or `Array` types, to be used where `NumberIndexable` type is required,
+    // interchangeably.
   });
 
 /**

packages/fjl/tests/list/test-drop.ts

@@ -3,8 +3,8 @@ import {expectEqual, expectError, vowelsArray, vowelsString} from "../helpers";
 import {drop} from "../../src";
 
 describe('#drop', () => {
-  it('should return a new list/string with dropped items from original until limit', () => {
-    (<[Parameters<typeof drop>, Slice<any>][]>[
+  it('should return a new list/string with dropped items from original until length', () => {
+    (<[Parameters<typeof drop>, Slice][]>[
       [[0, ''], ''],
       [[0, []], []],
       [[1, ''], ''],
@@ -25,6 +25,7 @@ describe('#drop', () => {
         expectEqual(drop(...args), expected);
       });
   });
+
   it('should throw an error when no parameter is passed in', () => {
     (<any[]>[null, undefined, 0, {}]).forEach(xs =>
       expectError(() => drop(3, xs))