Benchmark: `inspect` Implementation Comparison

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) })

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Current `inspect` implementation
Older `inspect` implementation

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 26 days ago):

LLMs can make mistakes. Check important info.

Let's break down what is being tested in this benchmark.

The benchmark compares the performance of two different implementations of the `inspect` function, which is part of the Ramda library. The `inspect` function is used to extract specific properties from an object and return them as a new object.

**Current `inspect` implementation**

This implementation uses the `R.curry` method from Ramda to create a curried function that takes two arguments: `spec` and `obj`. It then defines a nested function `inspectProps` that recursively traverses the `spec` and `obj` objects, extracting the desired properties.

**Older `inspect` implementation**

This implementation is an older version of the `inspect` function, as mentioned in the benchmark definition. It also uses the `R.curry` method to create a curried function, but with some differences in how it traverses the `spec` and `obj` objects.

Now, let's discuss the pros and cons of each implementation:

**Current implementation:**

Pros:

* More concise and easier to read
* Uses a more modern and efficient way of traversing objects

Cons:

* May be slower than the older implementation due to the use of recursive function calls
* Requires Ramda library version 0.23.0 or higher

**Older implementation:**

Pros:

* Faster performance compared to the current implementation
* Does not rely on the Ramda library, making it more portable

Cons:

* Less concise and harder to read due to the use of a loop instead of recursion
* May have issues with handling nested objects and arrays

Other considerations:

* The benchmark definition includes multiple test cases with varying inputs and expected outputs, which helps to ensure that both implementations are thoroughly tested.
* The benchmark uses the `console.assert` method to verify that the `inspect` function produces the correct output for each test case.

If you're interested in optimizing the performance of the `inspect` function, you may want to consider using a more efficient data structure or algorithm, such as using a hash table or a trie, instead of relying on recursive function calls. However, this would likely require significant changes to the implementation and may not be necessary given the relatively small difference in performance between the two implementations.

As for the latest benchmark result, it shows that the older `inspect` implementation is slightly faster than the current implementation on this specific test case. However, it's essential to note that this result may not generalize to other scenarios or platforms, and further testing would be necessary to confirm these findings.

Latest run results:

Run details: (Test run date: 5 years ago)

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

Browser/OS: Chrome 76 on Mac OS X 10.14.6

View result in a separate tab

Test name	Executions per second
Current `inspect` implementation	36688.8 Ops/sec
Older `inspect` implementation	37838.6 Ops/sec

Related benchmarks:

`inspect` Implementation Comparison (version: 13)

Comparing performance of: Current `inspect` implementation vs Older `inspect` implementation

Created: 7 years ago by: Registered User

Jump to the latest result

Current `inspect` implementation

Older `inspect` implementation

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 26 days ago):