atomic-fns 0.2.3 → 0.3.1

package/src/itertools/index.js

@@ -4,7 +4,7 @@
  * @module Iterators
  */
 import { call, isEmpty, isObject, notNull, ValueError } from '../globals/index.js';
-import { bool, comp, eq, gt, id, le, add } from '../operators/index.js';
+import { add, bool, comp, eq, id } from '../operators/index.js';
 /**
  * Make an iterator that returns accumulated sums, or accumulated results of other binary functions (specified via the optional `func` argument).
  * @param iterable The iterable to accumulate
@@ -99,7 +99,7 @@ contains('abcd', 'bc')
 // => true
 ```
  *
- * @see {@link collections.find}
+ * @see {@link Collections.find}
  */
 export function contains(collection, value) {
     if (!collection)
@@ -263,24 +263,6 @@ export function partition(iterable, predicate) {
     }
     return [left, right];
 }
-/**
- * Returns the smallest element in an iterable. The optional `key` argument specifies a transform on the elements before comparing them. If the elements in the iterable are objects that implement a custom `le` method, this will be called to compare.
- * @param iterable The iterable to inspect.
- * @param key Optional key function to transform the elements (default `id`).
- * @returns The smallest element in the iterable.
- */
-export function min(iterable, key = id) {
-    return reduce(iterable, (x, y) => (le(key(x), key(y)) ? x : y));
-}
-/**
- * Returns the largest element in an iterable. The optional `key` argument specifies a transform on the elements before comparing them. If the elements in the iterable are objects that implement a custom `gt` method, this will be called to compare.
- * @param iterable The iterable to inspect.
- * @param key Optional key function to transform the elements (default `id`).
- * @returns The largest element in the iterable.
- */
-export function max(iterable, key = id) {
-    return reduce(iterable, (x, y) => (gt(key(x), key(y)) ? x : y));
-}
 /**
  * Returns a generator for a sequence of numbers in the given range, starting from `start` (default 0) to `stop` (not-inclusive) in increments of `step` (default 1).
  *
@@ -310,6 +292,8 @@ export function* range(...args) {
     let step = 1;
     if (args.length === 1) {
         stop = args[0];
+        if (stop < 0)
+            step = -1;
     }
     else if (args.length === 2) {
         start = args[0];
@@ -411,26 +395,6 @@ export function sort(args, reverse, compareFn) {
         args.reverse();
     return args;
 }
-/**
- * Sums `initial` and the items of an iterable and returns the total.
- * @param args The elements to add to `initial`.
- * @param initial The initial value to add to (default `0`).
- * @returns The total sum of initial and iterable elements.
- * @example
-```js
-sum([1, 2, 3, 4])
-// => 10
-
-sum([1, 2, 3, 4], 5)
-// => 15
-```
- */
-export function sum(args, initial = 0) {
-    for (const x of args) {
-        initial += x;
-    }
-    return initial;
-}
 export function take(n, iterable) {
     return [...itake(n, iterable)];
 }

package/src/itertools/index.ts

@@ -14,7 +14,7 @@ import {
   Predicate,
   ValueError
 } from '../globals/index.js'
-import { bool, comp, eq, gt, id, le, add } from '../operators/index.js'
+import { add, bool, comp, eq, id } from '../operators/index.js'
 
 /**
  * Make an iterator that returns accumulated sums, or accumulated results of other binary functions (specified via the optional `func` argument).
@@ -110,7 +110,7 @@ contains('abcd', 'bc')
 // => true
 ```
  *
- * @see {@link collections.find}
+ * @see {@link Collections.find}
  */
 export function contains(collection: Iterable<any>, value) {
   if (!collection) return false
@@ -272,26 +272,6 @@ export function partition<T>(iterable: Iterable<T>, predicate: Predicate<T>) {
   return [left, right]
 }
 
-/**
- * Returns the smallest element in an iterable. The optional `key` argument specifies a transform on the elements before comparing them. If the elements in the iterable are objects that implement a custom `le` method, this will be called to compare.
- * @param iterable The iterable to inspect.
- * @param key Optional key function to transform the elements (default `id`).
- * @returns The smallest element in the iterable.
- */
-export function min<T>(iterable: Iterable<T>, key = id) {
-  return reduce(iterable, (x, y) => (le(key(x), key(y)) ? x : y))
-}
-
-/**
- * Returns the largest element in an iterable. The optional `key` argument specifies a transform on the elements before comparing them. If the elements in the iterable are objects that implement a custom `gt` method, this will be called to compare.
- * @param iterable The iterable to inspect.
- * @param key Optional key function to transform the elements (default `id`).
- * @returns The largest element in the iterable.
- */
-export function max<T>(iterable: Iterable<T>, key = id) {
-  return reduce(iterable, (x, y) => (gt(key(x), key(y)) ? x : y))
-}
-
 /**
  * Returns a generator for a sequence of numbers in the given range, starting from `start` (default 0) to `stop` (not-inclusive) in increments of `step` (default 1).
  *
@@ -321,6 +301,7 @@ export function* range(...args: number[]) {
   let step = 1
   if (args.length === 1) {
     stop = args[0]
+    if (stop < 0) step = -1
   } else if (args.length === 2) {
     start = args[0]
     stop = args[1]
@@ -436,27 +417,6 @@ export function sort(args: any[], reverse?: boolean | Comp, compareFn?: Comp) {
   return args
 }
 
-/**
- * Sums `initial` and the items of an iterable and returns the total.
- * @param args The elements to add to `initial`.
- * @param initial The initial value to add to (default `0`).
- * @returns The total sum of initial and iterable elements.
- * @example
-```js
-sum([1, 2, 3, 4])
-// => 10
-
-sum([1, 2, 3, 4], 5)
-// => 15
-```
- */
-export function sum(args: Iterable<number>, initial = 0) {
-  for (const x of args) {
-    initial += x
-  }
-  return initial
-}
-
 export function take<T>(n: number, iterable: Iterable<T>) {
   return [...itake<T>(n, iterable)]
 }

package/src/math/index.d.ts

@@ -3,12 +3,39 @@
  *
  * @module Math
  */
+import { Predicate } from '../globals/index.js';
 /**
  * Returns the absolute value of a number. The argument may be a number or an object implementing the `abs()`.
  * @param x The value.
  * @returns The absolute value.
  */
 export declare function abs(x: any): number;
+/**
+ * Round `x` to the number of digits after the decimal point. If `digits` is
+ * omitted, it returns the nearest integer to x.
+ *
+ * @param {number} x
+ * @param {number} [digits=0]
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round Math.round()}
+ */
+export declare function round(x: number, digits?: number): number;
+/**
+ * Rounds down and returns the largest integer less than or equal to a given number.
+ * @param x A number.
+ * @returns Nearest integer less than or equal to number.
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/floor Math.floor()}
+ */
+export declare const floor: (x: number) => number;
+/**
+ * Rounds up and returns the largest integer greater than or equal to a given number.
+ * @param x A number.
+ * @returns Nearest integer greater than or equal to number.
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/ceil Math.ceil()}
+ */
+export declare const ceil: (x: number) => number;
 /**
  * Returns a tuple like `[x / y, x % y]`.
  *
@@ -19,3 +46,52 @@ export declare function abs(x: any): number;
 export declare function divmod(x: number, y: number): number[];
 export declare function log2(x: any): number;
 export declare function logBase(x: any, y: any): number;
+/**
+ * Returns the smallest element in an iterable. The optional `key` argument specifies a transform on the elements before comparing them. If the elements in the iterable are objects that implement a custom `lt` method, this will be called to compare.
+ * @param iterable The iterable to inspect.
+ * @param key Optional key function to transform the elements (default `id`).
+ * @returns The smallest element in the iterable.
+ */
+export declare function min(iterable: number[]): number;
+export declare function min<T>(iterable: Iterable<T>, key?: Predicate<T>): T;
+/**
+ * Returns the largest element in an iterable. The optional `key` argument specifies a transform on the elements before comparing them. If the elements in the iterable are objects that implement a custom `gt` method, this will be called to compare.
+ * @param iterable The iterable to inspect.
+ * @param key Optional key function to transform the elements (default `id`).
+ * @returns The largest element in the iterable.
+ */
+export declare function max(iterable: number[]): number;
+export declare function max<T>(iterable: Iterable<T>, key?: Predicate<T>): T;
+/**
+ * Computes the mean of the values in `iterable` and accepts an optional `key` function which is invoked for each element to generate the values to be averaged.
+ * @param {Array<number>|Iterable<T>} iterable
+ * @param {Function} [key] Optional iteratee invoked per element.
+ * @returns Returns the mean value or `false` if no elements.
+ * @template T
+ * @example
+```js
+let objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }]
+
+mean(objects, (o) => o.n)
+// => 5
+```
+ */
+export declare function mean(iterable: number[]): false | number;
+export declare function mean<T>(iterable: Iterable<T>, key?: Predicate<T>): false | number;
+/**
+ * Sums `initial` and the items of an iterable and returns the total.
+ * @param args The elements to add to `initial`.
+ * @param initial The initial value to add to (default `0`).
+ * @returns The total sum of initial and iterable elements.
+ * @example
+```js
+sum([1, 2, 3, 4])
+// => 10
+
+sum([1, 2, 3, 4], 5)
+// => 15
+```
+ */
+export declare function sum(iterable: number[]): number;
+export declare function sum<T>(iterable: Iterable<T>, key?: Predicate<T>): T;
+export declare function sum<T>(iterable: Iterable<T>, key?: Predicate<T>): T;

package/src/math/index.js

@@ -4,6 +4,8 @@
  * @module Math
  */
 import { call } from '../globals/index.js';
+import { reduce } from '../itertools/index.js';
+import { gt, id, lt } from '../operators/index.js';
 /**
  * Returns the absolute value of a number. The argument may be a number or an object implementing the `abs()`.
  * @param x The value.
@@ -15,6 +17,35 @@ export function abs(x) {
         return op;
     return Math.abs(x);
 }
+/**
+ * Round `x` to the number of digits after the decimal point. If `digits` is
+ * omitted, it returns the nearest integer to x.
+ *
+ * @param {number} x
+ * @param {number} [digits=0]
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round Math.round()}
+ */
+export function round(x, digits = 0) {
+    const base = 10 ** digits;
+    return Math.round(x * base) / base;
+}
+/**
+ * Rounds down and returns the largest integer less than or equal to a given number.
+ * @param x A number.
+ * @returns Nearest integer less than or equal to number.
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/floor Math.floor()}
+ */
+export const floor = (x) => Math.floor(x);
+/**
+ * Rounds up and returns the largest integer greater than or equal to a given number.
+ * @param x A number.
+ * @returns Nearest integer greater than or equal to number.
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/ceil Math.ceil()}
+ */
+export const ceil = (x) => Math.ceil(x);
 /**
  * Returns a tuple like `[x / y, x % y]`.
  *
@@ -37,3 +68,25 @@ export function logBase(x, y) {
     }
     return Number.NaN;
 }
+export function min(iterable, key = id) {
+    return reduce(iterable, (x, y) => (lt(key(x), key(y)) ? x : y));
+}
+export function max(iterable, key = id) {
+    return reduce(iterable, (x, y) => (gt(key(x), key(y)) ? x : y));
+}
+export function mean(iterable, key = id) {
+    let total = 0;
+    let count = 0;
+    for (const value of iterable) {
+        total += key(value);
+        count++;
+    }
+    return count !== 0 && total / count;
+}
+export function sum(args, key = id) {
+    let initial = 0;
+    for (const x of args) {
+        initial += key(x);
+    }
+    return initial;
+}

package/src/math/index.ts

@@ -4,8 +4,9 @@
  * @module Math
  */
 
-import { call, Comp, isFunc } from '../globals/index.js'
-import { comp } from '../operators/index.js'
+import { call, Predicate } from '../globals/index.js'
+import { reduce } from '../itertools/index.js'
+import { gt, id, lt } from '../operators/index.js'
 
 /**
  * Returns the absolute value of a number. The argument may be a number or an object implementing the `abs()`.
@@ -18,6 +19,38 @@ export function abs(x): number {
   return Math.abs(x)
 }
 
+/**
+ * Round `x` to the number of digits after the decimal point. If `digits` is
+ * omitted, it returns the nearest integer to x.
+ *
+ * @param {number} x
+ * @param {number} [digits=0]
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round Math.round()}
+ */
+export function round(x: number, digits = 0) {
+  const base = 10 ** digits
+  return Math.round(x * base) / base
+}
+
+/**
+ * Rounds down and returns the largest integer less than or equal to a given number.
+ * @param x A number.
+ * @returns Nearest integer less than or equal to number.
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/floor Math.floor()}
+ */
+export const floor = (x: number) => Math.floor(x)
+
+/**
+ * Rounds up and returns the largest integer greater than or equal to a given number.
+ * @param x A number.
+ * @returns Nearest integer greater than or equal to number.
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/ceil Math.ceil()}
+ */
+export const ceil = (x: number) => Math.ceil(x)
+
 /**
  * Returns a tuple like `[x / y, x % y]`.
  *
@@ -42,3 +75,78 @@ export function logBase(x, y) {
   }
   return Number.NaN
 }
+
+/**
+ * Returns the smallest element in an iterable. The optional `key` argument specifies a transform on the elements before comparing them. If the elements in the iterable are objects that implement a custom `lt` method, this will be called to compare.
+ * @param iterable The iterable to inspect.
+ * @param key Optional key function to transform the elements (default `id`).
+ * @returns The smallest element in the iterable.
+ */
+export function min(iterable: number[]): number
+export function min<T>(iterable: Iterable<T>, key?: Predicate<T>): T
+export function min<T>(iterable: Iterable<T>, key = id) {
+  return reduce(iterable, (x, y) => (lt(key(x), key(y)) ? x : y))
+}
+
+/**
+ * Returns the largest element in an iterable. The optional `key` argument specifies a transform on the elements before comparing them. If the elements in the iterable are objects that implement a custom `gt` method, this will be called to compare.
+ * @param iterable The iterable to inspect.
+ * @param key Optional key function to transform the elements (default `id`).
+ * @returns The largest element in the iterable.
+ */
+export function max(iterable: number[]): number
+export function max<T>(iterable: Iterable<T>, key?: Predicate<T>): T
+export function max<T>(iterable: Iterable<T>, key = id) {
+  return reduce(iterable, (x, y) => (gt(key(x), key(y)) ? x : y))
+}
+
+/**
+ * Computes the mean of the values in `iterable` and accepts an optional `key` function which is invoked for each element to generate the values to be averaged.
+ * @param {Array<number>|Iterable<T>} iterable
+ * @param {Function} [key] Optional iteratee invoked per element.
+ * @returns Returns the mean value or `false` if no elements.
+ * @template T
+ * @example
+```js
+let objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }]
+
+mean(objects, (o) => o.n)
+// => 5
+```
+ */
+export function mean(iterable: number[]): false | number
+export function mean<T>(iterable: Iterable<T>, key?: Predicate<T>): false | number
+export function mean<T>(iterable: Iterable<T>, key = id): false | number {
+  let total = 0
+  let count = 0
+  for (const value of iterable) {
+    total += key(value)
+    count++
+  }
+  return count !== 0 && total / count
+}
+
+/**
+ * Sums `initial` and the items of an iterable and returns the total.
+ * @param args The elements to add to `initial`.
+ * @param initial The initial value to add to (default `0`).
+ * @returns The total sum of initial and iterable elements.
+ * @example
+```js
+sum([1, 2, 3, 4])
+// => 10
+
+sum([1, 2, 3, 4], 5)
+// => 15
+```
+ */
+export function sum(iterable: number[]): number
+export function sum<T>(iterable: Iterable<T>, key?: Predicate<T>): T
+export function sum<T>(iterable: Iterable<T>, key?: Predicate<T>): T
+export function sum<T>(args: Iterable<T>, key: Predicate<T> = id) {
+  let initial = 0
+  for (const x of args) {
+    initial += key(x)
+  }
+  return initial
+}

package/src/operators/index.d.ts

@@ -10,12 +10,12 @@ export declare const isinstance: (x: any, y: any) => boolean;
 export declare function comp(x: any, y: any): 0 | 1 | -1;
 export declare function eq(x: any, y: any): any;
 export declare function lt(x: any, y: any): any;
-export declare function le(x: any, y: any): any;
+export declare function lte(x: any, y: any): any;
 export declare function gt(x: any, y: any): any;
-export declare function ge(x: any, y: any): any;
+export declare function gte(x: any, y: any): any;
 export declare function add(x: any, y: any): any;
 export declare function sub(x: any, y: any): any;
-export declare function mult(x: any, y: any): any;
+export declare function mul(x: any, y: any): any;
 export declare function div(x: any, y: any): any;
 export declare function mod(x: any, y: any): any;
 /**

package/src/operators/index.js

@@ -14,9 +14,9 @@ export function comp(x, y) {
         return op;
     if (eq(x, y))
         return 0;
-    if (le(x, y))
+    if (lte(x, y))
         return -1;
-    if (ge(x, y))
+    if (gte(x, y))
         return 1;
     return 0;
 }
@@ -32,8 +32,8 @@ export function lt(x, y) {
         return op;
     return x < y;
 }
-export function le(x, y) {
-    let op = call(x, 'le', y);
+export function lte(x, y) {
+    let op = call(x, 'lte', y);
     if (op != null)
         return op;
     op = call(x, 'eq', y);
@@ -50,8 +50,8 @@ export function gt(x, y) {
         return op;
     return x > y;
 }
-export function ge(x, y) {
-    let op = call(x, 'ge', y);
+export function gte(x, y) {
+    let op = call(x, 'gte', y);
     if (op != null)
         return op;
     op = call(x, 'eq', y);
@@ -74,8 +74,8 @@ export function sub(x, y) {
         return op;
     return x - y;
 }
-export function mult(x, y) {
-    const op = call(x, 'mult', y);
+export function mul(x, y) {
+    const op = call(x, 'mul', y);
     if (op != null)
         return op;
     return x * y;

package/src/operators/index.ts

@@ -18,8 +18,8 @@ export function comp(x, y) {
   const op = call(x, 'compare', y)
   if (isNumber(op)) return op as 0 | 1 | -1
   if (eq(x, y)) return 0
-  if (le(x, y)) return -1
-  if (ge(x, y)) return 1
+  if (lte(x, y)) return -1
+  if (gte(x, y)) return 1
   return 0
 }
 
@@ -35,8 +35,8 @@ export function lt(x, y) {
   return x < y
 }
 
-export function le(x, y) {
-  let op = call(x, 'le', y)
+export function lte(x, y) {
+  let op = call(x, 'lte', y)
   if (op != null) return op
   op = call(x, 'eq', y)
   if (op === true) return op
@@ -51,8 +51,8 @@ export function gt(x, y) {
   return x > y
 }
 
-export function ge(x, y) {
-  let op = call(x, 'ge', y)
+export function gte(x, y) {
+  let op = call(x, 'gte', y)
   if (op != null) return op
   op = call(x, 'eq', y)
   if (op === true) return op
@@ -73,8 +73,8 @@ export function sub(x, y) {
   return x - y
 }
 
-export function mult(x, y) {
-  const op = call(x, 'mult', y)
+export function mul(x, y) {
+  const op = call(x, 'mul', y)
   if (op != null) return op
   return x * y
 }

package/tests/globals.spec.ts

@@ -29,17 +29,15 @@ import {
   next,
   oct,
   ord,
-  round,
   str,
   True,
   type,
   uniqueId,
-  values
+  values,
+  _
 } from '../src/globals/index.js'
 import { enumerate } from '../src/itertools/index.js'
 
-function cb() {}
-
 describe('globals', () => {
   it('CustomError', () => {
     let err = new CustomError('custom')
@@ -69,12 +67,14 @@ describe('globals', () => {
     assert(type([]) === 'array')
     assert(type({}) === 'object')
     assert(type(type) === 'function')
+    assert(type(Error()) === 'error')
+    assert(type(new CustomError()) === 'error')
     assert(type(Symbol()) === 'symbol')
     assert(type(new Map()) === 'Map')
     assert(type(new WeakMap()) === 'WeakMap')
     assert(type(new Set()) === 'Set')
     assert(type(new WeakSet()) === 'WeakSet')
-    assert(type(new Promise(cb)) === 'Promise')
+    assert(type(new Promise(_)) === 'Promise')
     assert(type(new Int8Array()) === 'Int8Array')
     assert(type(new Uint8Array()) === 'Uint8Array')
     assert(type(new Uint8ClampedArray()) === 'Uint8ClampedArray')
@@ -115,14 +115,14 @@ describe('globals', () => {
   })
 
   it('isFunc', () => {
-    assert(isFunc(cb))
+    assert(isFunc(_))
     assert(!isFunc([]))
   })
 
   it('isAsync', () => {
     assert(isAsync(async function () {}))
     assert(isAsync(async () => {}))
-    assert(!isAsync(cb))
+    assert(!isAsync(_))
   })
 
   it('isNaN', () => {
@@ -143,7 +143,7 @@ describe('globals', () => {
   })
 
   it('isPromise', () => {
-    assert(isPromise(new Promise(cb)))
+    assert(isPromise(new Promise(_)))
   })
 
   it('isSymbol', () => {
@@ -207,14 +207,6 @@ describe('globals', () => {
     assert.deepEqual(values(obj), Object.values(obj))
   })
 
-  it('round', () => {
-    assert(round(0.5) === 1)
-    assert(round(-0.5) === 0)
-    assert(round(1.5) === 2)
-    assert(round(1.54, 2) === 1.54)
-    assert(round(1.545, 3) === 1.545)
-  })
-
   it('next', () => {
     const iter = enumerate([1, 2, 3])
     assert.deepEqual(next(iter), [0, 1])