rubico 2.0.1 → 2.2.0

package/archive/examples-v1.6.11/nodeOnRecordAddTask.js

@@ -1,34 +0,0 @@
-#!/usr/bin/env node
-
-const { pipe, fork, map, get } = require('rubico')
-
-const requestAPI = record => {/* make API request */}
-
-const saveToDatabase = result => {/* save result to database */}
-
-const getImages = apiResult => {/* make images API request */}
-
-const flatten = arr => arr.flat(1)
-
-const uploadToS3 = image => {/* upload to s3 code */}
-
-/*
-const onRecordAddTask = async record => {
-  const results = await requestAPI(record)
-  const [arraysOfImages,] = await Promise.all([
-    await Promise.all(results.map(getImages)),
-    await Promise.all(results.map(saveToDatabase)),
-  ])
-  await Promise.all(flatten(arraysOfImages).map(uploadToS3))
-}
-*/
-
-const onRecordAddTask = pipe([
-  requestAPI,
-  fork([
-    map(getImages),
-    map(saveToDatabase),
-  ]),
-  get(0),
-  map(map(uploadToS3)),
-])

package/archive/examples-v1.6.11/nodePostRequestWithAuth.js

@@ -1,36 +0,0 @@
-#!/usr/bin/env node
-
-const fetch = require('node-fetch')
-const { pipe, fork, get } = require('..')
-
-const getToken = () => 'token'
-
-const getJSON = res => res.json()
-
-// expects the object { body: {...}, uuid: 'string' }
-const postRequestWithAuth = route => pipe([
-  fork({
-    method: () => 'POST',
-    headers: pipe([
-      get('uuid'),
-      getToken,
-      token => ({
-        Authorization: `Token ${token}`,
-        'Content-Type': 'application/json',
-      }),
-    ]),
-    body: pipe([
-      get('body'),
-      JSON.stringify,
-    ]),
-  }),
-  payload => fetch(route, payload),
-  getJSON,
-])
-
-postRequestWithAuth('http://localhost:8001/myRoute')({
-  uuid: 'ffda7b1c-fc6b-4949-98c4-e5cb86675f5f',
-  body: { hello: 'world' },
-})
-
-// https://stackoverflow.com/questions/54852314/javascript-functional-programming-how-to-handle-fetch-for-pipes/61907662#61907662

package/archive/examples-v1.6.11/nodeSpeedbackMatchmakingAlgorithm.js

@@ -1,96 +0,0 @@
-#!/usr/bin/env node
-
-const {
-  pipe, fork, tap, switchCase,
-  map, filter, transform,
-  and, not, eq, get,
-} = require('rubico')
-
-const identity = x => x
-
-// [person] => Map { person => (Set { person }) }
-const makeTracker = transform(
-  map(fork([
-    person => person,
-    () => new Set(),
-  ])),
-  new Map(),
-)
-
-const db = new Map()
-
-const saveTracker = async tracker => { db.set('tracker', tracker) }
-
-const hasTracker = async () => db.has('tracker')
-
-const getTracker = async tracker => db.get('tracker')
-
-const isNotIn = set => x => !set.has(x)
-
-// { people, tracker } => { people, tracker, pairs }
-const algorithm = ({ people, tracker }) => {
-  const matchedThisRound = new Set()
-  return fork({
-    people: identity,
-    tracker: () => tracker,
-    pairs: transform(
-      pipe([
-        filter(isNotIn(matchedThisRound)),
-        map(person => {
-          for (const other of people) {
-            // console.log('person:other', `${person}:${other}`)
-            if (other === person) continue
-            if (tracker.get(person).has(other)) continue
-            if (matchedThisRound.has(other)) continue
-            tracker.get(person).add(other)
-            tracker.get(other).add(person)
-            matchedThisRound.add(person)
-            matchedThisRound.add(other)
-            return [person, other]
-          }
-        }),
-        filter(Array.isArray),
-      ]),
-      [],
-    )
-  })(people)
-}
-
-// [person, person, person, person, ...] => [[person, person], [person, person], ...]
-const matchmake = pipe([
-  fork({
-    people: identity,
-    tracker: switchCase([
-      hasTracker, getTracker,
-      makeTracker,
-    ]),
-  }),
-  algorithm,
-  tap(pipe([get('tracker'), saveTracker])),
-])
-
-const didEveryoneMatch = (tracker, people) => {
-  for (const [, set] of tracker) {
-    if (set.size < people.length - 1) return false // 1 for yourself
-  }
-  return true
-}
-
-const makePeople = number => Array.from((function*() {
-  for (let i = 0; i < number; i++) yield `${i + 1}`
-})())
-
-const main = async () => {
-  const people = makePeople(99)
-  console.log('people', people)
-  let i = 0
-  while (true) {
-    const round = await matchmake(people)
-    const { tracker, pairs } = round
-    console.log('round', i, pairs)
-    if (didEveryoneMatch(tracker, people)) break
-    i += 1
-  }
-}
-
-main()

package/archive/examples-v1.6.11/nodeTireData.js

@@ -1,36 +0,0 @@
-#!/usr/bin/env node
-
-const { pipe, tap, map, transform } = require('..')
-const request = require('request')
-
-const urls = [
-  'https://firebasestorage.googleapis.com/v0/b/moberra-tire-api.appspot.com/o/tire-data-eco%2Fforceum.json?alt=media&token=ed9db67c-d744-414f-8812-21cfbba63447',
-  'https://firebasestorage.googleapis.com/v0/b/moberra-tire-api.appspot.com/o/tire-data-eco%2Fgood-year.json?alt=media&token=1131b553-e2e5-4ff6-87cb-f346e57e389e',
-  'https://firebasestorage.googleapis.com/v0/b/moberra-tire-api.appspot.com/o/tire-data-eco%2Fgt-radial.json?alt=media&token=d2ba3f51-cef7-494e-8006-61d321d677cd',
-  'https://firebasestorage.googleapis.com/v0/b/moberra-tire-api.appspot.com/o/tire-data-eco%2Fkpatos.json?alt=media&token=75743c44-1521-4ff4-8133-e56a474f7c3e',
-  'https://firebasestorage.googleapis.com/v0/b/moberra-tire-api.appspot.com/o/tire-data-eco%2Fland-spider.json?alt=media&token=22a3aa7b-18a9-4bd1-b34b-5ae48cadbc55',
-  'https://firebasestorage.googleapis.com/v0/b/moberra-tire-api.appspot.com/o/tire-data-eco%2Fleao-tires.json?alt=media&token=84dcc7f8-de32-46a9-9aae-854639772975',
-  'https://firebasestorage.googleapis.com/v0/b/moberra-tire-api.appspot.com/o/tire-data-eco%2Fwanli.json?alt=media&token=4bb13f3a-5d9a-4c2d-b558-964ee996a534',
-  'https://firebasestorage.googleapis.com/v0/b/moberra-tire-api.appspot.com/o/tire-data-eco%2Fzeta.json?alt=media&token=c04f973c-2577-4f06-805e-68e46480e9ae'
-]
-
-const getFile = url => new Promise((resolve, reject) => {
-  request({
-    uri: url,
-    method: "GET",
-    gzip: true,
-    qs: { format: "json" },
-  }, (err, resp, body) => err ? reject(err) : resolve(body))
-})
-
-// urls => tire_json_data
-const download_tire_json_from_firebase = map(getFile)
-
-const main = async () => {
-  const data = await transform(pipe([
-    map(getFile),
-    tap(console.log),
-  ]), [])(urls)
-}
-
-main()

package/archive/examples-v1.6.11/nodeTripleMap.js

@@ -1,85 +0,0 @@
-#!/usr/bin/env node
-
-const { pipe, fork, map, reduce, get } = require('..')
-
-const data = { "Office": {
-    "California" : {
-        "Contract1": {
-            1: {Price: 1000, Count: 5}, 2: {Price: 2000, Count: 11},
-            3: {Price: 3000, Count: 3}, 4: {Price: 2000, Count: 1},
-            5: {Price: 1000, Count: 5}, 6: {Price: 2000, Count: 11},
-            7: {Price: 3000, Count: 3}, 8: {Price: 2000, Count: 1},
-            9: {Price: 1000, Count: 5}, 10: {Price: 2000, Count: 11},
-            11: {Price: 3000, Count: 3}, 12: {Price: 2000, Count: 1},
-        },
-        "Contract2": {
-            1: {Price: 7000, Count: 6}, 2: {Price: 1000, Count: 4},
-            3: {Price: 67000, Count: 6}, 4: {Price: 500, Count: 2},
-            5: {Price: 7000, Count: 6}, 6: {Price: 1000, Count: 4},
-            7: {Price: 67000, Count: 6}, 8: {Price: 500, Count: 2},
-            9: {Price: 7000, Count: 6}, 10: {Price: 1000, Count: 4},
-            11: {Price: 67000, Count: 6}, 12: {Price: 500, Count: 2},
-        },
-        "Contract3": {
-            1: {Price: 4000, Count: 4}, 2: {Price: 4000, Count: 1},
-            3: {Price: 5000, Count: 12}, 4: {Price: 5000, Count: 2},
-            5: {Price: 4000, Count: 4}, 6: {Price: 4000, Count: 1},
-            7: {Price: 5000, Count: 12}, 8: {Price: 5000, Count: 2},
-            9: {Price: 4000, Count: 4}, 10: {Price: 4000, Count: 1},
-            11: {Price: 5000, Count: 12}, 12: {Price: 5000, Count: 2},
-        }
-    },
-    "North Carolina" : {
-        "Contract1": {
-            1: {Price: 7000, Count: 4}, 2: {Price: 7000, Count: 4},
-            3: {Price: 7000, Count: 4}, 4: {Price: 7000, Count: 4},
-            5: {Price: 7000, Count: 4}, 6: {Price: 7000, Count: 4},
-            7: {Price: 7000, Count: 4}, 8: {Price: 7000, Count: 4},
-            9: {Price: 7000, Count: 4}, 10: {Price: 7000, Count: 4},
-            11: {Price: 7000, Count: 4}, 12: {Price: 7000, Count: 4},
-        },
-        "Contract2": {
-            1: {Price: 6000, Count: 4}, 2: {Price: 2000, Count: 10},
-            3: {Price: 3000, Count: 3}, 4: {Price: 2000, Count: 3},
-            5: {Price: 6000, Count: 4}, 6: {Price: 2000, Count: 10},
-            7: {Price: 3000, Count: 3}, 8: {Price: 2000, Count: 3},
-            9: {Price: 6000, Count: 4}, 10: {Price: 2000, Count: 10},
-            11: {Price: 3000, Count: 3}, 12: {Price: 2000, Count: 3},
-        },
-        "Contract3": {
-            1: {Price: 4000, Count: 5}, 2: {Price: 2000, Count: 4},
-            3: {Price: 4000, Count: 3}, 4: {Price: 2000, Count: 4},
-            5: {Price: 4000, Count: 5}, 6: {Price: 2000, Count: 4},
-            7: {Price: 4000, Count: 3}, 8: {Price: 2000, Count: 4},
-            9: {Price: 4000, Count: 5}, 10: {Price: 2000, Count: 4},
-            11: {Price: 4000, Count: 3}, 12: {Price: 2000, Count: 4},
-        },
-    },
-} }
-
-const addContracts = (total, contract) => ({
-  Price: total.Price + contract.Price,
-  Count: total.Count + contract.Count,
-})
-
-const monthNumbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
-
-const sumMonthsToQuarters = contract => {
-  const quartered = {
-    1: { Price: 0, Count: 0 },
-    2: { Price: 0, Count: 0 },
-    3: { Price: 0, Count: 0 },
-    4: { Price: 0, Count: 0 },
-  }
-  for (const monthNum of monthNumbers) {
-    const quarterNum = Math.ceil(monthNum / 3)
-    quartered[quarterNum] = addContracts(quartered[quarterNum], contract[monthNum])
-  }
-  return quartered
-}
-
-const x = map(map(map(sumMonthsToQuarters)))(data)
-
-console.log(JSON.stringify(x))
-
-// https://stackoverflow.com/questions/62103014/reducing-a-nested-object-in-javascript/62110877

package/archive/examples-v1.6.11/squaredOdds.ts

@@ -1,16 +0,0 @@
-#!/usr/bin/env -S deno run
-
-import { map, filter, pipe } from '../rubico.js'
-
-const isOdd = (x: number): boolean => x % 2 === 1
-
-const square = (x: number): number => x ** 2
-
-const squaredOdds = pipe([
-  filter(isOdd),
-  map(square),
-])
-
-console.log(
-  squaredOdds([1, 2, 3, 4, 5]), // [1, 9, 25]
-)

package/archive/examples-v1.6.11/transducerMaxBuyer.js

@@ -1,67 +0,0 @@
-#!/usr/bin/env node
-
-// from https://stackoverflow.com/questions/62074394/filter-array-and-get-max-values-of-nested-array-of-each-set-of-objects-in-javas/62077548#62077548
-
-const { transform, pipe, assign, tap, map, filter, reduce, get, gt } = require('rubico')
-
-const data = [
-  {
-    product: 'laptop',
-    count_buyer: 3,
-    buyers: [
-      { name: 'Vins', purchase_amount: 27 },
-      { name: 'Jan', purchase_amount: 38 },
-      { name: 'Alex', purchase_amount: 80 },
-    ],
-  },
-  {
-    product: 'televisor',
-    count_buyer: 2,
-    buyers: [
-      { name: 'Carl', purchase_amount: 25 },
-      { name: 'Digi', purchase_amount: 40 }
-    ],
-  },
-  {
-    product: 'ropa varon',
-    count_buyer: 0,
-    buyers: [],
-  }
-];
-
-const getMaxBuyer = (y, xi) => y.purchase_amount > xi.purchase_amount ? y : xi
-
-const getProductsWithMaxBuyer = pipe([
-  filter(gt(get('buyers.length'), 0)), // filter for products with buyers.length > 0
-  tap(x => console.log('tap', x)),
-  map(assign({
-    buyers: pipe([
-      get('buyers'), // product => product.buyers
-      reduce(getMaxBuyer), // buyers => [max_buyer]
-    ]),
-  })),
-  tap(x => console.log('tap', x)),
-])
-
-console.log('intermediate arrays, should see 2 arrays')
-
-getProductsWithMaxBuyer(data) /* > [
-  {
-    product: 'laptop',
-    count_buyer: 3,
-    buyers: { name: 'Alex', purchase_amount: 80 }
-  },
-  {
-    product: 'televisor',
-    count_buyer: 2,
-    buyers: { name: 'Digi', purchase_amount: 40 }
-  }
-]
-*/
-
-console.log('one pass, should see 4 products individually')
-
-transform(
-  getProductsWithMaxBuyer,
-  [],
-)(data)

package/archive/examples-v1.6.11/transformLogTodosRange.js

@@ -1,31 +0,0 @@
-const { pipe, map, transform } = require('rubico')
-const fetch = require('node-fetch')
-
-const toTodosUrl = id => 'https://jsonplaceholder.typicode.com/todos/' + id
-
-const fetchedToJson = fetched => fetched.json()
-
-const fetchTodo = pipe([
-  toTodosUrl,
-  fetch,
-  fetchedToJson,
-])
-
-const Stdout = {
-  concat(...args) {
-    console.log(...args)
-    return this
-  }
-}
-
-const todoIDsRange = function* (from, to) {
-  for (let id = from; id <= to; id++) {
-    yield id
-  }
-}
-
-const logTodosRange = transform(
-  map(fetchTodo), Stdout,
-)(todoIDsRange)
-
-logTodosRange(1, 100)

package/archive/examples-v1.6.11/transformStreamRandomInts.js

@@ -1,19 +0,0 @@
-#!/usr/bin/env node
-
-const { pipe, map, transform } = require('..')
-
-const square = number => number ** 2
-
-const toString = value => value.toString()
-
-const randomInt = () => Math.ceil(Math.random() * 100)
-
-const streamRandomInts = async function* () {
-  while (true) {
-    yield randomInt()
-  }
-}
-
-transform(
-  map(pipe([square, toString])), process.stdout,
-)(streamRandomInts())

package/archive/genericReduceConcurrent.js

@@ -1,277 +0,0 @@
-/**
- * @name callChain
- *
- * @synopsis
- * Monad = { chain: function }
- *
- * callChain(monad Monad, resolver)
-const callChain = (monad, resolver) => monad.chain(resolver)
- */
-
-/**
- * @name arrayPushIf
- *
- * @synopsis
- * arrayPushIf(predicate, any=>boolean, array Array, item any) -> ()
- */
-const arrayPushIf = function (predicate, array, item) {
-  if (predicate(item)) {
-    array.push(item)
-  }
-}
-
-/**
- * @name forEachReduceConcurrent
- *
- * @synopsis
- * forEachReduceConcurrent(
- *   collection { forEach: function },
- *   reducer (any, T)=>Promise|any,
- *   result any,
- * ) -> Promise|result
- */
-const forEachReduceConcurrent = function (collection, reducer, result) {
-  const promises = [],
-    getResult = () => result
-  collection.forEach(funcConcatSync(
-    curry2(reducer, result, __),
-    curry3(arrayPushIf, isPromise, promises, __)))
-
-  /*
-  collection.forEach([
-    tap(item => console.log('heyo', reducer, result, item)),
-    curry2(reducer, result, __),
-    curry3(arrayPushIf, isPromise, promises, __),
-  ].reduce(funcConcatSync))
-  */
-
-  return promises.length == 0
-    ? result
-    : promiseAll(promises).then(getResult)
-}
-
-/**
- * @name iterableReduceConcurrent
- *
- * @synopsis
- * iterableReduceConcurrent(
- *   iterable { [Symbol.iterator]: function },
- *   reducer (any, T)=>Promise|any,
- *   result any,
- * ) -> Promise|result
- */
-const iterableReduceConcurrent = function (iterable, reducer, result) {
-  const promises = [],
-    getResult = () => result,
-    pipeline = funcConcatSync(
-      curry2(reducer, result, __),
-      curry3(arrayPushIf, isPromise, promises, __))
-
-  for (const item of iterable) {
-    pipeline(item)
-  }
-  return promises.length == 0
-    ? result
-    : promiseAll(promises).then(getResult)
-}
-
-/**
- * @name asyncIterableReduceConcurrent
- *
- * @synopsis
- * asyncIterableReduceConcurrent(
- *   asyncIterable { [Symbol.iterator]: function },
- *   reducer (any, T)=>Promise|any,
- *   result any,
- * ) -> Promise|result
- */
-const asyncIterableReduceConcurrent = async function (asyncIterable, reducer, result) {
-  const promises = [],
-    getResult = () => result,
-    pipeline = funcConcatSync(
-      curry2(reducer, result, __),
-      curry3(arrayPushIf, isPromise, promises, __))
-
-  for await (const item of asyncIterable) {
-    pipeline(item)
-  }
-  return promises.length == 0
-    ? result
-    : promiseAll(promises).then(getResult)
-}
-
-/**
- * @name objectReduceConcurrent
- *
- * @synopsis
- * objectReduceConcurrent(
- *   object Object,
- *   reducer (any, T)=>Promise|any,
- *   result any,
- * ) -> Promise|result
- *
- * @related objectFlatMap
- */
-const objectReduceConcurrent = function (object, reducer, result) {
-  const promises = [],
-    getResult = () => result,
-    pipeline = funcConcatSync(
-      curry2(reducer, result, __),
-      curry3(arrayPushIf, isPromise, promises, __))
-
-  for (const key in object) {
-    pipeline(object[key])
-  }
-  return promises.length == 0
-    ? result
-    : promiseAll(promises).then(getResult)
-}
-
-/**
- * @name getArg1
- *
- * @synopsis
- * getArg1(arg0 any, arg1 any) -> arg1
- */
-const getArg1 = function (arg0, arg1) {
-  return arg1
-}
-
-/**
- * @name foldableReduceConcurrent
- *
- * @synopsis
- * foldableReduceConcurrent(
- *   foldable { reduce: function },
- *   reducer (any, T)=>Promise|any,
- *   result any,
- * ) -> Promise|result
- */
-const foldableReduceConcurrent = function (foldable, reducer, result) {
-  const promises = [],
-    getResult = () => result,
-    pipeline = [
-      getArg1,
-      curry2(reducer, result, __),
-      curry3(arrayPushIf, isPromise, promises, __),
-    ].reduce(funcConcatSync)
-
-  foldable.reduce(tapSync(pipeline), null)
-  return promises.length == 0
-    ? result
-    : promiseAll(promises).then(getResult)
-}
-
-/**
- * @name tacitGenericReduceConcurrent
- *
- * @synopsis
- * any -> T
- *
- * tacitGenericReduceConcurrent(
- *   reducer (any, T)=>any,
- *   result any,
- * ) -> reducing ...any=>result
- */
-const tacitGenericReduceConcurrent = (
-  reducer, result,
-) => function reducing(...args) {
-  return genericReduceConcurrent(args, reducer, result)
-}
-
-/**
- * @name genericReduceConcurrent
- *
- * @synopsis
- * genericReduceConcurrent(
- *   args Array,
- *   reducer function,
- *   result any,
- * ) -> result
- *
- * @related
- * genericReduce
- *
- * @NOTE
- * concurrency is only possible because result is never reassigned. in that regard, `result` is required.
- */
-const genericReduceConcurrent = function (args, reducer, result) {
-  const collection = args[0]
-  if (collection == null) {
-    reducer(result, collection)
-    return result
-  }
-  if (typeof collection.forEach == 'function') {
-    return forEachReduceConcurrent(collection, reducer, result)
-  }
-  if (typeof collection[symbolIterator] == 'function') {
-    return iterableReduceConcurrent(collection, reducer, result)
-  }
-  if (typeof collection[symbolAsyncIterator] == 'function') {
-    return asyncIterableReduceConcurrent(collection, reducer, result)
-  }
-  if (typeof collection.reduce == 'function') {
-    return foldableReduceConcurrent(collection, reducer, result)
-  }
-  if (typeof collection.chain == 'function') {
-    return collection.chain(curry2(reducer, result, __))
-  }
-  if (typeof collection.flatMap == 'function') {
-    return collection.flatMap(curry2(reducer, result, __))
-  }
-  if (collection.constructor == Object) {
-    return objectReduceConcurrent(collection, reducer, result)
-  }
-  reducer(result, collection)
-  return result
-}
-
-/**
- * @name flatteningTransducerConcurrent
- *
- * @synopsis
- * flatteningTransducerConcurrent(concat Reducer) -> flatteningReducer Reducer
- *
- * DuplexStream = { read: function, write: function }
- *
- * Monad = Array|String|Set
- *   |TypedArray|DuplexStream|Iterator|AsyncIterator
- *   |{ chain: function }|{ flatMap: function }|Object
- *
- * Foldable = Iterable|AsyncIterable|{ reduce: function }
- *
- * FlatteningReducer<T> = (any, T)=>Promise|Monad|Foldable|any
- *
- * Reducer<T> = (any, T)=>Promise|any
- *
- * flatteningTransducerConcurrent(concat Reducer) -> flatteningReducer FlatteningReducer
- *
- * @execution concurrent
- */
-const flatteningTransducerConcurrent = concat => function flatteningReducer(
-  result, item,
-) {
-  return genericReduceConcurrent([item], concat, result)
-}
-
-/**
- * @name objectMapToArray
- *
- * @synopsis
- * objectMapToArray(
- *   object Object, mapper function,
- * ) -> Promise|Array
- *
- * @note order not guaranteed
- */
-const objectMapToArray = function (object, mapper) {
-  const result = []
-  let isAsync = false
-
-  for (const key in object) {
-    const resultItem = mapper(object[key])
-    if (isPromise(resultItem)) isAsync = true
-    result.push(resultItem)
-  }
-  return isAsync ? promiseAll(result) : result
-}