rubico 2.2.0 → 2.2.1

package/monad/Struct.js

@@ -0,0 +1,249 @@
+/* rubico v1.5.0
+ * https://github.com/a-synchronous/rubico
+ * (c) 2019-2020 Richard Tong
+ * rubico may be freely distributed under the MIT license.
+ */
+
+'use strict'
+
+const Instance = require('./Instance')
+
+const { isArray, isObject, isSet, isMap } = Instance
+
+/**
+ * @synopsis
+ * isStruct(x any) -> boolean
+ */
+const isStruct = x => isArray(x) || isObject(x) || isSet(x) || isMap(x)
+
+/**
+ * @name Struct
+ *
+ * @synopsis
+ * new Struct(x Array|Object|Set|Map) -> Struct
+ *
+ * @catchphrase
+ * Finite data structure
+ */
+const Struct = function(x) {
+  if (!isStruct(x)) {
+    throw new TypeError(`cannot convert ${x} to Struct`)
+  }
+  this.value = x
+}
+
+/**
+ * @name Struct.isStruct
+ *
+ * @synopsis
+ * Struct.isStruct(x any) -> boolean
+ *
+ * @catchphrase
+ * Tell if struct
+ */
+Struct.isStruct = isStruct
+
+/**
+ * @synopsis
+ * <T>objectEntriesGenerator(x Object<T>) -> Iterator<[key string, T]>
+ */
+const objectEntriesGenerator = function*(x) {
+  for (const k in x) {
+    yield [k, x[k]]
+  }
+}
+
+/**
+ * @name Struct.entries
+ *
+ * @synopsis
+ * <T any>Struct.entries(x Array<T>) -> Iterator<[index number, T]>
+ *
+ * <T any>Struct.entries(x Object<T>) -> Iterator<[key string, T]>
+ *
+ * <T any>Struct.entries(x Set<T>) -> Iterator<[T, T]>
+ *
+ * <A any, B any>Struct.entries(x Map<A, B>) -> Iterator<[A, B]>
+ *
+ * @catchphrase
+ * Get an iterator of key value pairs
+ */
+Struct.entries = x => isObject(x) ? objectEntriesGenerator(x) : x.entries()
+
+/**
+ * @synopsis
+ * <T>objectValuesGenerator(x Object<T>) -> Iterator<T>
+ */
+const objectValuesGenerator = function*(x) {
+  for (const k in x) {
+    yield x[k]
+  }
+}
+
+/**
+ * @name Struct.values
+ *
+ * @synopsis
+ * <T any>Struct.values(
+ *   x Array<T>|Object<T>|Set<T>|Map<any, T>
+ * ) -> Iterator<T>
+ *
+ * @catchphrase
+ * Get an iterator of values
+ */
+Struct.values = x => isObject(x) ? objectValuesGenerator(x) : x.values()
+
+/**
+ * @name Struct.get
+ *
+ * @synopsis
+ * <T any>Struct.get(x Array<T>, index number) -> T|undefined
+ *
+ * <T any>Struct.get(x Object<T>, index string) -> T|undefined
+ *
+ * <T any>Struct.get(x Set<T>, index T) -> T|undefined
+ *
+ * <A any, B any>Struct.get(x Map<A, B>, index A) -> B|undefined
+ *
+ * @catchphrase
+ * Get an item by index
+ */
+Struct.get = (x, index) => {
+  if (typeof x.get == 'function') return x.get(index)
+  if (typeof x.has == 'function') return x.has(index) ? index : undefined
+  return x[index]
+}
+
+/*
+Struct.get.ternary = (x, index) => (typeof x.get == 'function'
+  ? x.get(index) : typeof x.has == 'function'
+  ? x.has(index) ? index : undefined : x[index])
+*/
+
+/**
+ * @name Struct.set
+ *
+ * @synopsis
+ * Struct.set(x Array, value any, index number) -> mutated Array
+ *
+ * Struct.set(x Object, value any, index string) -> mutated Object
+ *
+ * Struct.set(x Set, value any) -> mutated Set
+ *
+ * Struct.set(x Map, value any, index any) -> mutated Map
+ *
+ * @catchphrase
+ * Set a value
+ */
+Struct.set = (x, value, index) => {
+  if (typeof x.set == 'function') return x.set(index, value)
+  if (typeof x.add == 'function') return x.add(value)
+  x[index] = value
+  return x
+}
+
+/**
+ * @synopsis
+ * objectKeysCount(obj object) -> ct number
+ */
+const objectKeysCount = obj => {
+  let ct = 0
+  for (const _ in obj) ct += 1
+  return ct
+}
+
+/**
+ * @name Struct.size
+ *
+ * @synopsis
+ * Struct.size(x Array|Object|Set|Map) -> number
+ *
+ * @catchphrase
+ * Count values
+ */
+Struct.size = x => {
+  if (isObject(x)) return objectKeysCount(x)
+  return 'size' in x ? x.size : x.length
+}
+
+/*
+Struct.size.objectKeys = x => {
+  if (isObject(x)) return Object.keys(x).length
+  return 'size' in x ? x.size : x.length
+}
+*/
+
+/**
+ * @synopsis
+ * copySet(x Set) -> y Set
+ */
+const copySet = x => {
+  const y = new Set()
+  for (const item of x) y.add(item)
+  return y
+}
+
+
+/**
+ * @synopsis
+ * copyMap(x Map) -> y Map
+ */
+const copyMap = x => {
+  const y = new Map()
+  for (const entry of x) y.set(...entry)
+  return y
+}
+
+/**
+ * @name Struct.copy
+ *
+ * @synopsis
+ * Struct.copy(x Array) -> copied Array
+ *
+ * Struct.copy(x Object) -> copied Object
+ *
+ * Struct.copy(x Set) -> copied Set
+ *
+ * Struct.copy(x Map) -> copied Map
+ *
+ * @catchphrase
+ * Shallow copy a struct
+ */
+Struct.copy = x => {
+  if (isArray(x)) return x.slice()
+  if (isObject(x)) return { ...x }
+  return isSet(x) ? copySet(x) : copyMap(x)
+}
+
+const { entries: structEntries, set: structSet } = Struct
+
+/**
+ * @name Struct.copyDeep
+ *
+ * @synopsis
+ * Struct.copyDeep(x Array) -> deeplyCopied Array
+ *
+ * Struct.copyDeep(x Object) -> deeplyCopied Object
+ *
+ * Struct.copyDeep(x Set) -> deeplyCopied Set
+ *
+ * Struct.copyDeep(x Map) -> deeplyCopied Map
+ *
+ * @catchphrase
+ * Deep copy a struct
+ */
+const structCopyDeep = x => {
+  const y = new x.constructor()
+  for (const [index, value] of structEntries(x)) {
+    structSet(
+      y,
+      isStruct(value) ? structCopyDeep(value) : value,
+      index,
+    )
+  }
+  return y
+}
+
+Struct.copyDeep = structCopyDeep
+
+module.exports = Struct

package/monad/Struct.test.js

@@ -0,0 +1,237 @@
+const assert = require('assert')
+const Struct = require('./Struct')
+
+describe('Struct', () => {
+  describe('new Struct(x Array|Object|Set|Map) -> Struct', () => {
+    it('x Array; Struct', async () => {
+      assert.equal(new Struct([1, 2, 3]).constructor, Struct)
+    })
+    it('x Object; Struct', async () => {
+      assert.equal(new Struct({ a: 1, b: 2, c: 3 }).constructor, Struct)
+    })
+    it('x Set; Struct', async () => {
+      assert.equal(new Struct(new Set([1, 2, 3])).constructor, Struct)
+    })
+    it('x Map; Struct', async () => {
+      assert.equal(new Struct(new Map([['a', 1], ['b', 2], ['c', 3]])).constructor, Struct)
+    })
+    it('x string; TypeError', async () => {
+      assert.throws(
+        () => new Struct('hey'),
+        new TypeError('cannot convert hey to Struct')
+      )
+    })
+    it('x null; TypeError', async () => {
+      assert.throws(
+        () => new Struct(null),
+        new TypeError('cannot convert null to Struct')
+      )
+    })
+    it('x undefined; TypeError', async () => {
+      assert.throws(
+        () => new Struct(undefined),
+        new TypeError('cannot convert undefined to Struct')
+      )
+    })
+  })
+
+  describe('Struct.isStruct(x any) -> boolean', () => {
+    it('x Array; true', async () => {
+      assert.equal(Struct.isStruct([]), true)
+    })
+    it('x Object; true', async () => {
+      assert.equal(Struct.isStruct({}), true)
+    })
+    it('x Set; true', async () => {
+      assert.equal(Struct.isStruct(new Set()), true)
+    })
+    it('x Map; true', async () => {
+      assert.equal(Struct.isStruct(new Map()), true)
+    })
+    it('x ArrayBuffer; false', async () => {
+      assert.equal(Struct.isStruct(new ArrayBuffer()), false)
+    })
+    it('x Number; false', async () => {
+      assert.equal(Struct.isStruct(1), false)
+    })
+    it('x String; false', async () => {
+      assert.equal(Struct.isStruct('hey'), false)
+    })
+  })
+
+  const nativeObjectToString = Object.prototype.toString
+
+  const objectToString = x => nativeObjectToString.call(x)
+
+  it('<T any>Struct.entries(x Array<T>) -> Iterator<[index number, T]>', async () => {
+    assert.equal(objectToString(Struct.entries([1, 2, 3])), '[object Array Iterator]')
+    assert.deepEqual([...Struct.entries([1, 2, 3])], [[0, 1], [1, 2], [2, 3]])
+  })
+
+  it('<T any>Struct.entries(x Object<T>) -> Iterator<[key string, T]>', async () => {
+    assert.equal(objectToString(Struct.entries({ a: 1, b: 2, c: 3 })), '[object Generator]')
+    assert.deepEqual([...Struct.entries({ a: 1, b: 2, c: 3 })], [['a', 1], ['b', 2], ['c', 3]])
+  })
+
+  it('<T any>Struct.entries(x Set<T>) -> Iterator<[T, T]>', async () => {
+    assert.equal(objectToString(Struct.entries(new Set([1, 2, 3]))), '[object Set Iterator]')
+    assert.deepEqual([...Struct.entries(new Set([1, 2, 3]))], [[1, 1], [2, 2], [3, 3]])
+  })
+
+  it('<A any, B any>Struct.entries(x Map<A, B>) -> Iterator<[A, B]>', async () => {
+    assert.equal(objectToString(Struct.entries(new Map([[1, 'a'], [2, 'b'], [3, 'c']]))), '[object Map Iterator]')
+    assert.deepEqual([...Struct.entries(new Map([[1, 'a'], [2, 'b'], [3, 'c']]))], [[1, 'a'], [2, 'b'], [3, 'c']])
+  })
+
+  describe('<T any>Struct.values(x Array<T>|Object<T>|Set<T>|Map<any, T>) -> Iterator<T>', () => {
+    it('x Array<T>; Iterator<T>', async () => {
+      assert.equal(objectToString(Struct.values([1, 2, 3])), '[object Array Iterator]')
+      assert.deepEqual([...Struct.values([1, 2, 3])], [1, 2, 3])
+    })
+    it('x Object<T>; Iterator<T>', async () => {
+      assert.equal(objectToString(Struct.values({ a: 1, b: 2, c: 3 })), '[object Generator]')
+      assert.deepEqual([...Struct.values({ a: 1, b: 2, c: 3 })], [1, 2, 3])
+    })
+    it('x Set<T>; Iterator<T>', async () => {
+      assert.equal(objectToString(Struct.values(new Set([1, 2, 3]))), '[object Set Iterator]')
+      assert.deepEqual([...Struct.values(new Set([1, 2, 3]))], [1, 2, 3])
+    })
+    it('x Map<T>; Iterator<T>', async () => {
+      assert.equal(objectToString(Struct.values(new Map([[1, 'a'], [2, 'b'], [3, 'c']]))), '[object Map Iterator]')
+      assert.deepEqual([...Struct.values(new Map([[1, 'a'], [2, 'b'], [3, 'c']]))], ['a', 'b', 'c'])
+    })
+  })
+
+  it('<T any>Struct.get(x Array<T>, index number) -> T|undefined', async () => {
+    assert.equal(Struct.get([1, 2, 3], 0), 1)
+    assert.strictEqual(Struct.get([1, 2, 3], 4), undefined)
+  })
+
+  it('<T any>Struct.get(x Object<T>, index string) -> T|undefined', async () => {
+    assert.equal(Struct.get({ a: 1, b: 2, c: 3 }, 'a'), 1)
+    assert.strictEqual(Struct.get({ a: 1, b: 2, c: 3 }, 'e'), undefined)
+  })
+
+  it('<T any>Struct.get(x Set<T>, index T) -> T|undefined', async () => {
+    assert.equal(Struct.get(new Set([1, 2, 3]), 1), 1)
+    assert.strictEqual(Struct.get(new Set([1, 2, 3]), 5), undefined)
+  })
+
+  it('<A any, B any>Struct.get(x Map<A, B>, index A) -> B|undefined', async () => {
+    const m = new Map([[1, 'a'], [2, 'b'], [3, 'c']])
+    assert.equal(Struct.get(m, 1), 'a')
+    assert.strictEqual(Struct.get(m, 5), undefined)
+  })
+
+  it('Struct.set(x Array, value any, index number) -> mutated Array', async () => {
+    const arr = [1, 2]
+    assert.deepEqual(Struct.set(arr, 3, 2), [1, 2, 3])
+  })
+
+  it('Struct.set(x Object, value any, index string) -> mutated Object', async () => {
+    const obj = { a: 1, b: 2 }
+    assert.deepEqual(Struct.set(obj, 3, 'c'), { a: 1, b: 2, c: 3 })
+  })
+
+  it('Struct.set(x Set, value any) -> mutated Set', async () => {
+    const set = new Set([1, 2])
+    assert.deepEqual(Struct.set(set, 3), new Set([1, 2, 3]))
+  })
+
+  it('Struct.set(x Map, value any, index any) -> mutated Map', async () => {
+    const map = new Map([['a', 1], ['b', 2]])
+    assert.deepEqual(Struct.set(map, 3, 'c'), new Map([['a', 1], ['b', 2], ['c', 3]]))
+  })
+
+  describe('Struct.size(x Array|Object|Set|Map) -> y number', () => {
+    it('x [1, 2, 3]; y 3', async () => {
+      assert.strictEqual(Struct.size([1, 2, 3]), 3)
+    })
+    it('x []; y 0', async () => {
+      assert.strictEqual(Struct.size([]), 0)
+    })
+    it('x { a: 1, b: 2, c: 3 }; y 3', async () => {
+      assert.strictEqual(Struct.size({ a: 1, b: 2, c: 3 }), 3)
+    })
+    it('x {}; y 0', async () => {
+      assert.strictEqual(Struct.size({}), 0)
+    })
+    it('x Set<[1, 2, 3]>; y 3', async () => {
+      assert.strictEqual(Struct.size(new Set([1, 2, 3])), 3)
+    })
+    it('x Set<[]>; y 0', async () => {
+      assert.strictEqual(Struct.size(new Set()), 0)
+    })
+    it('x Map<[[\'a\', 1], [\'b\', 2], [\'c\', 3]]>; y 3', async () => {
+      assert.strictEqual(Struct.size(new Map([['a', 1], ['b', 2], ['c', 3]])), 3)
+    })
+    it('x Map<[]>; y 0', async () => {
+      assert.strictEqual(Struct.size(new Map()), 0)
+    })
+  })
+
+  it('Struct.copy(x Array) -> copied Array', async () => {
+    const arr = [1, 2, 3]
+    const copied = Struct.copy(arr)
+    assert(copied !== arr)
+    assert.deepEqual(arr, copied)
+  })
+
+  it('Struct.copy(x Object) -> copied Object', async () => {
+    const obj = { a: 1, b: 2, c: 3 }
+    const copied = Struct.copy(obj)
+    assert(copied !== obj)
+    assert.deepEqual(obj, copied)
+  })
+
+  it('Struct.copy(x Set) -> copied Set', async () => {
+    const set = new Set([1, 2, 3])
+    const copied = Struct.copy(set)
+    assert(copied !== set)
+    assert.deepEqual(set, copied)
+  })
+
+  it('Struct.copy(x Map) -> copied Map', async () => {
+    const map = new Map([['a', 1], ['b', 2], ['c', 3]])
+    const copied = Struct.copy(map)
+    assert(copied !== map)
+    assert.deepEqual(map, copied)
+  })
+
+  it('Struct.copyDeep(x Array) -> deeplyCopied Array', async () => {
+    const arr = [1, [2], [[3], 'hey', new Uint8Array([1, 2, 3])]]
+    const copied = Struct.copyDeep(arr)
+    assert(copied !== arr)
+    assert.deepEqual(arr, copied)
+  })
+
+  it('Struct.copyDeep(x Object) -> deeplyCopied Object', async () => {
+    const obj = { a: 1, b: [2], c: [[3]], d: new Set([NaN, 'hey', { a: null }]) }
+    const copied = Struct.copy(obj)
+    assert(copied !== obj)
+    assert.deepEqual(obj, copied)
+  })
+
+  it('Struct.copyDeep(x Set) -> deeplyCopied Set', async () => {
+    const set = new Set([1, [2], [[[[3]]]], {}, [], undefined])
+    const copied = Struct.copy(set)
+    assert(copied !== set)
+    assert.deepEqual(set, copied)
+  })
+
+  it('Struct.copyDeep(x Map) -> deeplyCopied Map', async () => {
+    const map = new Map([
+      ['a', 1], ['b', 2], ['c', 3],
+      [Symbol.for('ayo'), {}], ['hey', {
+        a: [1, [2], [[3]]],
+        b: new Set([undefined, null, {}, [], new RegExp()]),
+        c: { d: { e: new BigInt64Array([1n, 2n, 3n]) } },
+      }],
+    ])
+    const copied = Struct.copy(map)
+    assert(copied !== map)
+    assert.deepEqual(map, copied)
+    assert.strictEqual(map.get('hey').c.d.e, copied.get('hey').c.d.e)
+    // anything not a struct is a reference. This is good for performance but could be dangerous
+  })
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rubico",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "description": "[a]synchronous functional programming",
   "author": "Richard Tong",
   "license": "MIT",
@@ -14,6 +14,7 @@
     "_internal",
     "dist",
     "x",
+    "monad",
     "index.js",
     "es.js",
     "global.js",