rubico 2.0.1 → 2.2.0

package/monad/Struct.js

@@ -1,249 +0,0 @@
-/* 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

@@ -1,237 +0,0 @@
-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/rubico.js

@@ -1,66 +0,0 @@
-const pipe = require('./pipe')
-const compose = require('./compose')
-const tap = require('./tap')
-const all = require('./all')
-const assign = require('./assign')
-const tryCatch = require('./tryCatch')
-const switchCase = require('./switchCase')
-const map = require('./map')
-const filter = require('./filter')
-const reduce = require('./reduce')
-const transform = require('./transform')
-const flatMap = require('./flatMap')
-const forEach = require('./forEach')
-const some = require('./some')
-const every = require('./every')
-const and = require('./and')
-const or = require('./or')
-const not = require('./not')
-const eq = require('./eq')
-const gt = require('./gt')
-const lt = require('./lt')
-const gte = require('./gte')
-const lte = require('./lte')
-const get = require('./get')
-const set = require('./set')
-const pick = require('./pick')
-const omit = require('./omit')
-const thunkify = require('./thunkify')
-const always = require('./always')
-const curry = require('./curry')
-const __ = require('./__')
-
-/**
- * design principles
- *
- * rubico is a module, not a grab bag
- * functional code should not care about async
- * exported methods are time and space optimal
- * memory used by exported methods is properly garbage collected
- * no special types; use built-in types
- * avoid variadic functions; use lists
- * avoid anonymous function creation; use names and factory functions
- * avoid creating functions inside functions
- */
-
-const rubico = {
-  pipe, compose,
-
-  tap, forEach,
-
-  switchCase,
-
-  tryCatch,
-
-  all, assign, get, set, pick, omit,
-
-  map, filter, flatMap, reduce, transform,
-
-  and, or, not, some, every,
-
-  eq, gt, lt, gte, lte,
-
-  thunkify, always, curry, __,
-}
-
-module.exports = rubico