Run results for: `inspect` Implementation Comparison

Run details:

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.95 Safari/537.36

Browser: Chrome 55

Operating system: Mac OS X 10.11.6

Device Platform: Other

Date tested: 7 years ago

Test name	Executions per second
Current `inspect` implementation	402418.1 Ops/sec
Alternate `inspect` implementation	341074.8 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