Merge pull request #91 from poteat/poteat/new-reified-implementations

Add reified implementations for various methods

.eslintrc

@@ -110,7 +110,8 @@
     "prefer-const": "error", // ts provides better types with const
     "prefer-rest-params": "error", // ts provides better types with rest args over arguments
     "prefer-spread": "error", // ts transpiles spread to apply, so no need for manual apply
-    "valid-typeof": "off" // ts(2367)
+    "valid-typeof": "off", // ts(2367)
+    "no-constant-condition": "off"
   },
   "settings": {
     "import/parsers": {

changelog.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [0.24.5]
+- Add `NaturalNumber.Square` to compute the square of a natural number.
+- Add `Object.AtKey` to get the value at a key in an object. (swapped argument order of `Object.At`)
+- Modify `Conditional.equals` to perform deep equality.
+- Add various value-level implementations.
+
 ## [0.24.4]
 - Add various value-level implementations across `List`, `NaturalNumber`, `String`, and `Type`.
 - Add `Type.Never` to represent the `never` type.

src/_internal/deepEqual.ts

@@ -0,0 +1,67 @@
+export function deepEqual(a: unknown, b: unknown): boolean {
+  if (Object.is(a, b)) return true
+
+  if (
+    a &&
+    b &&
+    typeof a === 'object' &&
+    typeof b === 'object' &&
+    Object.getPrototypeOf(a) === Object.getPrototypeOf(b)
+  ) {
+    if (Array.isArray(a)) {
+      if (!Array.isArray(b)) return false
+      if (a.length !== b.length) return false
+      for (let i = 0; i < a.length; i++) {
+        if (!deepEqual(a[i], b[i])) return false
+      }
+      return true
+    }
+
+    if (a instanceof Map) {
+      if (!(b instanceof Map)) return false
+      if (a.size !== b.size) return false
+      for (const [key, val] of a) {
+        if (!b.has(key)) return false
+        if (!deepEqual(val, b.get(key))) return false
+      }
+      return true
+    }
+
+    if (a instanceof Set) {
+      if (!(b instanceof Set)) return false
+      if (a.size !== b.size) return false
+      for (const val of a) {
+        if (!b.has(val)) return false
+      }
+      return true
+    }
+
+    if (a instanceof Date) {
+      if (!(b instanceof Date)) return false
+      return a.getTime() === b.getTime()
+    }
+
+    if (a instanceof RegExp) {
+      if (!(b instanceof RegExp)) return false
+      return a.toString() === b.toString()
+    }
+
+    const aKeys = Object.keys(a as Record<string, unknown>)
+    const bKeys = Object.keys(b as Record<string, unknown>)
+    if (aKeys.length !== bKeys.length) return false
+
+    for (const key of aKeys) {
+      if (
+        !deepEqual(
+          (a as Record<string, unknown>)[key],
+          (b as Record<string, unknown>)[key]
+        )
+      )
+        return false
+    }
+
+    return true
+  }
+
+  return false
+}

src/boolean/and-all.spec.ts → src/boolean/and-all.test.ts

@@ -20,3 +20,11 @@ type AndAll_Spec = [
   // @ts-expect-error
   Test.Expect<$<$<Boolean.AndAll, true>, number>>
 ]
+
+it('should return true if all elements are true', () => {
+  expect(Boolean.andAll([true, true, true])).toBe(true)
+})
+
+it('should return false if any element is false', () => {
+  expect(Boolean.andAll([true, true, false])).toBe(false)
+})

src/boolean/and-all.ts

@@ -49,3 +49,19 @@ type TrueList<
 export interface AndAll extends Kind.Kind {
   f(x: Type._$cast<this[Kind._], boolean[]>): _$andAll<typeof x>
 }
+
+/**
+ * Given a list of booleans, return whether all elements are true.
+ *
+ * @param {boolean[]} b - The list of booleans.
+ *
+ * @example
+ * ```ts
+ * import { Boolean } from "hkt-toolbelt";
+ *
+ * const result = Boolean.andAll([true, true, true])
+ * //    ^? true
+ * ```
+ */
+export const andAll = ((b: boolean[]) =>
+  b.every((e) => e)) as Kind._$reify<AndAll>

src/boolean/and.spec.ts → src/boolean/and.test.ts

@@ -27,3 +27,11 @@ type And_Spec = [
   // @ts-expect-error
   Test.Expect<$<Boolean.And<true>, number>>
 ]
+
+it('should return true if both inputs are true', () => {
+  expect(Boolean.and(true)(true)).toBe(true)
+})
+
+it('should return false if one input is false', () => {
+  expect(Boolean.and(true)(false)).toBe(false)
+})

src/boolean/and.ts

@@ -56,3 +56,19 @@ interface And_T<T extends boolean> extends Kind.Kind {
 export interface And extends Kind.Kind {
   f(x: Type._$cast<this[Kind._], boolean>): And_T<typeof x>
 }
+
+/**
+ * Given two booleans, return whether both are true.
+ *
+ * @param {boolean} a - The first boolean.
+ * @param {boolean} b - The second boolean.
+ *
+ * @example
+ * ```ts
+ * import { Boolean } from "hkt-toolbelt";
+ *
+ * const result = Boolean.and(true)(false)
+ * //    ^? false
+ * ```
+ */
+export const and = ((a: boolean) => (b: boolean) => a && b) as Kind._$reify<And>

src/combinator/fix-sequence.ts

@@ -1,4 +1,5 @@
 import { $, Kind, Type, Function } from '..'
+import { deepEqual } from '../_internal/deepEqual'
 
 /**
  * _$fixSequence is a type-level function that generates a fixed-point sequence
@@ -202,7 +203,7 @@ export interface FixSequence extends Kind.Kind {
  * ```
  */
 export const fixSequence = ((f: Function.Function) => (x: unknown) => {
-  let state = [x]
+  const state = [x]
 
   let previousValue = undefined
   let value = x
@@ -219,49 +220,3 @@ export const fixSequence = ((f: Function.Function) => (x: unknown) => {
     previousValue = value
   }
 }) as Kind._$reify<FixSequence>
-
-function deepEqual(a: any, b: any): boolean {
-  if (a === b) return true
-
-  if (a && b && typeof a === 'object' && typeof b === 'object') {
-    if (a.constructor !== b.constructor) return false
-
-    if (Array.isArray(a)) {
-      if (a.length !== b.length) return false
-      for (let i = 0; i < a.length; i++) {
-        if (!deepEqual(a[i], b[i])) return false
-      }
-      return true
-    }
-
-    if (a instanceof Map) {
-      if (a.size !== b.size) return false
-      for (const [key, val] of a) {
-        if (!b.has(key) || !deepEqual(val, b.get(key))) return false
-      }
-      return true
-    }
-
-    if (a instanceof Set) {
-      if (a.size !== b.size) return false
-      for (const val of a) {
-        if (!b.has(val)) return false
-      }
-      return true
-    }
-
-    if (a instanceof Date) return a.getTime() === b.getTime()
-    if (a instanceof RegExp) return a.toString() === b.toString()
-
-    const keys = Object.keys(a)
-    if (keys.length !== Object.keys(b).length) return false
-
-    for (const key of keys) {
-      if (!deepEqual(a[key], b[key])) return false
-    }
-
-    return true
-  }
-
-  return Number.isNaN(a) && Number.isNaN(b)
-}

src/conditional/equals.test.ts

@@ -72,3 +72,7 @@ it('should return true for equal values', () => {
 it('should return false for unequal values', () => {
   expect(Conditional.equals(1)(2)).toBe(false)
 })
+
+it('performs deep equality', () => {
+  expect(Conditional.equals({ a: 1, b: 2 })({ a: 1, b: 2 })).toBe(true)
+})

src/conditional/equals.ts

@@ -1,4 +1,5 @@
 import { Kind } from '..'
+import { deepEqual } from '../_internal/deepEqual'
 
 /**
  * `_$equals` is a type-level function that takes in two types, `T` and `U`, and
@@ -78,4 +79,4 @@ export interface Equals extends Kind.Kind {
  * ```
  */
 export const equals = ((x: unknown) => (y: unknown) =>
-  x === y) as Kind._$reify<Equals>
+  deepEqual(x, y)) as Kind._$reify<Equals>

src/loop/until.spec.ts → src/loop/until.test.ts

@@ -29,3 +29,9 @@ type Until_Spec = [
     [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
   >
 ]
+
+it('should loop until the stopping predicate is satisfied', () => {
+  expect(
+    Loop.until(NaturalNumber.isGreaterThan(10))(NaturalNumber.increment)(0)
+  ).toBe(11)
+})

src/loop/until.ts

@@ -1,4 +1,4 @@
-import { $, Conditional, Kind, Type } from '..'
+import { $, Conditional, Kind, Type, Function } from '..'
 
 /**
  * `_$until` is a type-level function that takes in a looping clause kind, an
@@ -92,3 +92,34 @@ export interface Until extends Kind.Kind {
     x: Type._$cast<this[Kind._], Kind.Kind<(x: never) => boolean>>
   ): Until_T1<typeof x>
 }
+
+/**
+ * Given a stopping predicate, an updater, and an initial value, loop until we reach
+ * a value that satisfies the stopping predicate.
+ *
+ * @param {Kind.Kind<(x: never) => boolean>} p - The stopping predicate.
+ * @param {Kind.Kind<(x: never) => unknown>} u - The updater.
+ * @param {unknown} x - The initial value.
+ *
+ * @example
+ * ```ts
+ * import { Kind, NaturalNumber } from "hkt-toolbelt";
+ *
+ * const result = Kind.until(
+ *   NaturalNumber.isGreaterThan(10),
+ *   NaturalNumber.add(1),
+ *   0
+ * ) // 11
+ * ```
+ */
+export const until = ((p: Function.Function) =>
+  (u: Function.Function) =>
+  (x: unknown) => {
+    let value = x
+
+    while (!p(value as never)) {
+      value = u(value as never)
+    }
+
+    return value
+  }) as Kind._$reify<Until>

src/natural-number/index.ts

@@ -13,6 +13,7 @@ export * from './is-odd'
 export * from './modulo-by'
 export * from './modulo'
 export * from './multiply'
+export * from './square'
 export * from './subtract'
 export * from './subtract-by'
 export * from './to-list'

src/natural-number/is-greater-than.spec.ts → src/natural-number/is-greater-than.test.ts

@@ -22,3 +22,7 @@ type IsGreaterThan_Spec = [
   // @ts-expect-error
   Test.Expect<$<$<NaturalNumber.IsGreaterThan, boolean>, 2>>
 ]
+
+it('should return whether the second number is greater than the first', () => {
+  expect(NaturalNumber.isGreaterThan(3)(2)).toBe(false)
+})

src/natural-number/is-greater-than.ts

@@ -82,3 +82,21 @@ interface IsGreaterThan_T<A extends Number.Number> extends Kind.Kind {
 export interface IsGreaterThan extends Kind.Kind {
   f(x: Type._$cast<this[Kind._], Number.Number>): IsGreaterThan_T<typeof x>
 }
+
+/**
+ * Given two numbers, return whether the second number is greater than the
+ * first.
+ *
+ * @param {number} a - The first number.
+ * @param {number} b - The second number.
+ *
+ * @example
+ * ```ts
+ * import { NaturalNumber } from "hkt-toolbelt";
+ *
+ * const result = NaturalNumber.isGreaterThan(3)(2)
+ * //    ^? false
+ * ```
+ */
+export const isGreaterThan = ((a: number) => (b: number) =>
+  b > a) as Kind._$reify<IsGreaterThan>

src/natural-number/square.test.ts

@@ -0,0 +1,17 @@
+import { $, Test, NaturalNumber } from '..'
+
+type Square_Spec = [
+  /**
+   * Can square a natural number.
+   */
+  Test.Expect<$<NaturalNumber.Square, 42>, 1764>,
+
+  /**
+   * Squaring zero results in zero.
+   */
+  Test.Expect<$<NaturalNumber.Square, 0>, 0>
+]
+
+it('should square a natural number', () => {
+  expect(NaturalNumber.square(42)).toBe(1764)
+})