Benchmark: Beast ramda leaves no chance for native

HTML Preparation code:

<script src="//cdnjs.cloudflare.com/ajax/libs/ramda/0.27.1/ramda.min.js"></script>

Script Preparation code:

var ramdaCount = R.pipe(
  R.map(R.o(Math.round, R.multiply(50))),
  R.filter(R.modulo(R.__, 2)),
  R.countBy(R.identity)
)

var ramdaConcatTimes = R.map(R.o(R.concat(R.__, ' times'), String))

var nativeCount = vals => 
  vals
  	.map(v => Math.round(v * 50))
  	.filter(v => v % 2)
  	.reduce((acc, cur) => { acc[cur] = (acc[cur] | 0) + 1; return acc; }, {});

var nativeConcatTimes = counts => Object.keys(counts).reduce((acc, key) => { acc[key] = String(counts[key]) + ' times'; return acc }, {});

var nativeConcatTimesUsingEntries = counts => Object.fromEntries(Object.entries(counts).map(([key, val]) => [key, String(val) + ' times']));

var arr = Array.from({length: 10000}, Math.random)

const ramdaRes = ramdaConcatTimes(ramdaCount(arr))
const nativeRes = nativeConcatTimes(nativeCount(arr))
const otherNativeRes = nativeConcatTimesUsingEntries(nativeCount(arr))

if (!R.equals(ramdaRes, nativeRes) || !R.equals(nativeRes, otherNativeRes)) {
  throw new Error('different results')
}

Tests:

Ramda - Count
ramdaCount(arr)
Native - Count
nativeCount(arr)
Ramda - Count and map object
R.o(ramdaConcatTimes, ramdaCount)(arr)
Native - Count and map object
nativeConcatTimes(nativeCount(arr))
Native - Count and map object using entries
nativeConcatTimesUsingEntries(nativeCount(arr))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Ramda - Count
Native - Count
Ramda - Count and map object
Native - Count and map object
Native - Count and map object using entries

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 11_1_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.182 Safari/537.36

Browser/OS: Chrome 88 on Mac OS X 11.1.0

View result in a separate tab

Test name	Executions per second
Ramda - Count	2781.8 Ops/sec
Native - Count	486.3 Ops/sec
Ramda - Count and map object	2795.9 Ops/sec
Native - Count and map object	473.9 Ops/sec
Native - Count and map object using entries	475.9 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided JSON represents a JavaScript benchmark test case, specifically designed to compare the performance of different approaches for counting and mapping objects in JavaScript.

**Benchmark Definition**

The benchmark is defined by a set of scripts that prepare input data and execute the same logic using two different approaches: Ramda (a functional programming library) and native JavaScript. The scripts are:

1. `ramdaCount`: A Ramda function that counts the number of elements in an array, mapping each element to its rounded value multiplied by 50.
2. `nativeCount`: A native JavaScript function that achieves the same result as `ramdaCount`.
3. `ramdaConcatTimes` and `ramdaConcatTimesUsingEntries`: Ramda functions that concatenate a string with a count of elements in an array, mapping each element to its rounded value multiplied by 50.
4. `nativeConcatTimes` and `nativeConcatTimesUsingEntries`: Native JavaScript functions that achieve the same results as their Ramda counterparts.

**Options Compared**

The benchmark compares the performance of two approaches:

1. **Ramda**: Uses the Ramda library for functional programming. The `ramdaCount` and `ramdaConcatTimes` functions are used to count and map objects, respectively.
2. **Native JavaScript**: Employs native JavaScript syntax for counting and mapping objects.

**Pros and Cons**

**Ramda:**

* Pros:
	+ Provides a concise and expressive way of writing functional code.
	+ Often results in more efficient and idiomatic code.
* Cons:
	+ May require additional dependencies (e.g., Ramda library).
	+ Can be less familiar to developers without prior experience with functional programming.

**Native JavaScript:**

* Pros:
	+ No external dependencies required.
	+ Familiar syntax for most developers.
* Cons:
	+ May result in more verbose code.
	+ Can lead to less efficient or less idiomatic code.

**Other Considerations**

1. **Optimization**: The benchmark tests the optimization of both approaches, allowing users to compare the performance impact of using Ramda versus native JavaScript.
2. **Code readability and maintainability**: The benchmark highlights the importance of writing clean, readable, and maintainable code, regardless of the chosen approach.

**Library and Syntax Features**

The test case uses the Ramda library for functional programming. No special JavaScript features or syntax are used in this benchmark.

**Alternatives**

If you prefer not to use a specific library like Ramda, you can implement the equivalent functions using native JavaScript, as shown in the `nativeCount` and `nativeConcatTimes` scripts.

For alternative libraries or approaches, consider exploring other functional programming libraries (e.g., Lodash) or optimizing techniques for improving performance.

Related benchmarks:

Beast ramda leaves no chance for native (version: 0)

hm....

Comparing performance of: Ramda - Count vs Native - Count vs Ramda - Count and map object vs Native - Count and map object vs Native - Count and map object using entries

Created: 3 years ago by: Guest

Jump to the latest result

Ramda - Count

Native - Count

Ramda - Count and map object

Native - Count and map object

Native - Count and map object using entries

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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