fixing small bugs

Author: ch-shubham

crossproduct.ts

@@ -1,19 +1,17 @@
 import curryN from "./utils/curry_n.ts"
 import { Curry2 } from "./utils/types.ts"
 
-
-/** Creates a new list out of the two supplied by creating each possible pair
- * from the list passed as arguments.
- * @function
- * 
- *     Fae.xprod([1, 2, 3], ['a', 'b']); //=> [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b'], [3, 'a'], [3, 'b']]
- */
-
 function crossproduct(a: Array<any>, b: Array<any>) {
   let result = []
   for(let idx = 0; idx < a.length; idx++)  
     for(let j = 0; j < b.length; j++) 
       result[result.length] = [a[idx], b[j]]
   return result
 }
+
+/** Creates a new list out of the two supplied by creating each possible pair
+ * from the list passed as arguments.
+ * 
+ *     Fae.crossproduct([1, 2, 3], ['a', 'b']); //=> [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b'], [3, 'a'], [3, 'b']]
+ */
 export default curryN(2, crossproduct) as Curry2<Array<any>>

reject.ts

@@ -3,16 +3,14 @@ import { Func, Curry2, Obj, Predicate1 } from "./utils/types.ts"
 import complement from './complement.ts';
 import filter from './filter.ts';
 
+function reject<T>(pred: Predicate1, filterable: Array<T> | Obj) {
+  return filter(complement(pred), filterable)
+}
+
 /** works as the complement of filter
- * @function
  * 
  *      const isOdd = n => (n & 1) === 1;
  *      const f = Fae.reject(isOdd, [1, 2, 3, 4])
  *      f() // [2, 4]
  */
-
-function reject<T>(pred: Predicate1, filterable: Array<T> | Obj) {
-  return filter(complement(pred), filterable)
-}
-
-export default curryN(2, reject) as Curry2<Func, Array<any> | Obj, Array<any> | Obj>
+export default curryN(2, reject) as Curry2<Predicate1, Array<any> | Obj, Array<any> | Obj>

specs/whereEq.spec.ts

@@ -1,5 +1,5 @@
 import { describe, it } from "./_describe.ts"
-import { whereEq, curry } from '../mod.ts'
+import { whereEq } from '../mod.ts'
 import { eq } from "./utils/utils.ts"
 
 

utils/types.ts

@@ -46,7 +46,7 @@ export type ObjArr<T = any> = {
 }
 
 export type ObjRec<T = number> = {
-  [key: string]: ObjRec | ObjArr | string | number | T
+  [key: string]: ObjRec | ObjArr | string | number | null | undefined | T
 }
 
 export type Comparator<T> = (a: T, b: T) => 1 | -1 | 0

whereEq.ts

@@ -2,11 +2,22 @@ import curryN from "./utils/curry_n.ts"
 import { Curry2, ObjRec, Obj } from "./utils/types.ts"
 import where from "./where.ts"
 import map from "./map.ts"
-import curry from './curry.ts'
+import equals from './equals.ts'
 
 function whereEq(spec: ObjRec, testObj: ObjRec) {
-  const equals = curry(2, (x: number, y: number) => x === y)
   return where(map(equals, spec), testObj)
 }
 
-export default curryN(2, whereEq) as Curry2<Obj, ObjRec, boolean>
+/**
+ * Takes a spec object and a test object, returns true if the test satisfies
+ * the spec, false otherwise.
+ * `whereEq` is a specialization of [`where`].
+ * 
+ *      const pred = Fae.whereEq({a: 1, b: 2})
+ *
+ *      pred({a: 1})              //=> false
+ *      pred({a: 1, b: 2})        //=> true
+ *      pred({a: 1, b: 2, c: 3})  //=> true
+ *      pred({a: 1, b: 1})        //=> false
+ */
+export default curryN(2, whereEq) as Curry2<ObjRec, ObjRec, boolean>

xor.ts

@@ -1,18 +1,16 @@
 import curryN from "./utils/curry_n.ts"
 import { Curry2, Obj } from "./utils/types.ts"
 
+function xor(a: any, b: any) {
+  return Boolean(a ? !b : b)
+}
+
 /** Exclusive Or - Returns `true` if one of the arguments is truthy and the other is falsy.
  * Otherwise, it returns `false`.
- * @function     
  * 
  *      Fae.xor(true, true) //=> false
  *      Fae.xor(true, false) //=> true
  *      Fae.xor(false, true) //=> true
  *      Fae.xor(false, false) //=> false 
  */
-
-function xor(a: any, b: any) {
-  return Boolean(a ? !b : b)
-}
-
 export default curryN(2, xor) as Curry2<any, any, boolean>