Run results for: `inspect` Implementation Comparison

Run details:

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 12_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.1 Mobile/15E148 Safari/604.1

Browser: Mobile Safari 12

Operating system: iOS 12.2

Device Platform: Mobile

Date tested: 5 years ago

Test name	Executions per second
Current `inspect` implementation	6979.6 Ops/sec
Older `inspect` implementation	6475.4 Ops/sec

HTML Preparation code:

<script src="https://unpkg.com/ramda@0.23.0/dist/ramda.js"></script>

Script Preparation code:

// Retrieves values from a data structure according to a given spec which are
// then returned within an object keyed according to strings in the spec.
var inspect = R.curry((spec, obj) => {
  var props = {}
  function inspectProps(spec, obj) {
    R.forEachObjIndexed((v, k) => {
      var objValue = obj[k]
      if (typeof v === "string") {
        props[v] = objValue
      } else if (typeof objValue === "object") {
        inspectProps(v, objValue)
      }
    }, spec)
  }
  inspectProps(spec, obj)
  return props
})

// Older `inspect` as originally proposed in:
// https://github.com/ramda/ramda/issues/2038
var oldInspect = R.curry(function _inspect(spec, obj) {
  var props = {}
  function inspectProps(spec, obj) {
    R.forEachObjIndexed(function _inspectProp(value, key) {
      var objValue = obj[key]
      if (typeof value === "string" && typeof objValue !== "undefined") {
        props[value] = objValue
      } else if (typeof objValue === "object") {
        inspectProps(value, objValue)
      }
    }, spec)
  }
  inspectProps(spec, obj)
  return props
})

// -----------------------------------------------------------------------------

var trials = [
  {
    spec: {
      a: [{ b: "one" }],
      c: "two",
      d: { e: "three" },
      f: {
        g: "four",
        h: [[{ j: "six" }, { k: "nine" }]],
      },
    },
    data: {
      a: [{ b: 1 }],
      c: 2,
      d: { e: 3 },
      f: {
        g: [4],
        h: [
          { i: 5 },
          [{ j: 6, k: 7 }, { j: 8, k: 9 }],
          10,
        ],
      },
    },
    expected: { one: 1, two: 2, three: 3, four: [4] },
  },
  {
    spec: { a: [{ b: "foo" }] },
    data: { a: [{ b: 2 }] },
    expected: { foo: 2 },
  },
  {
    spec: { a: "foo" },
    data: { a: 1 },
    expected: { foo: 1 },
  },
  {
    spec: { a: "foo" },
    data: { a: 1, b: 2 },
    expected: { foo: 1 },
  },
  {
    spec: { a: "foo", b: "bar" },
    data: { a: 1, b: 2 },
    expected: { foo: 1, bar: 2 },
  },
  {
    spec: { a: "foo", b: { c: "bar" } },
    data: { a: 1, b: { c: 3 } },
    expected: { foo: 1, bar: 3 },
  },
  {
    spec: { a: "foo", b: { c: "bar" } },
    data: { a: 1, b: { c: { d: 5 } } },
    expected: { foo: 1, bar: { d: 5 } },
  },
  {
    spec: { a: "foo", b: { c: { d: "bar" } } },
    data: { a: 1, b: { c: { d: 5 } } },
    expected: { foo: 1, bar: 5 },
  },
]

Tests:

Current `inspect` implementation
trials.forEach((v, k) => { console.assert(R.equals(inspect(v.spec, v.data), v.expected), "`inspect` went BOOM! on trial " + k) })
Older `inspect` implementation
trials.forEach((v, k) => { console.assert(R.equals(oldInspect(v.spec, v.data), v.expected), "`inspect` went BOOM! on trial " + k) })

Run results for: `inspect` Implementation Comparison

Current `inspect` implementation

Older `inspect` implementation