Perform grouping and reducing operations on an array of objects using a pointfree syntax

Question

Perform grouping and reducing operations on an array of objects using a pointfree syntax

Recently delved into the world of Ramda and am on a quest to discover a pointfree method for reducing an array of objects.

Behold, the array of objects :

const someObj = [
    {
        name: 'A',
        city: 1,
        other: {
            playtime: 30
        }
    },
    {
        name: 'B',
        city: 2,
        other: {
            playtime: 20
        }
    },
    {
        name: 'c',
        city: 1,
        other: {
            playtime: 20
        }
    }
];

I aspire to achieve object reduction with the wondrous powers of Ramda, all while maintaining the pointfree style like so:

{
    '1': {
        count: 2,
        avg_play_time: 20 + 30 / count
    },
    '2': {
        count: 1,
        avg_play_time: 20 / count
    }
}

The conventional method involving array reduction is within my grasp, but the enigma lies in crafting the same utilizing Ramda's unmistakable pointfree elegance. Any guidance on this matter would be greatly valued.

javascript reduce ramda.js

Answer 1

Answer №1

To tackle this issue, a potential solution involves the following approach:

// Utilizing an optic to extricate the nested playtime value
// Paired with a `lift` operation enabling its application across a collection
// Essentially A -> B => A[] -> B[]
const playtimes = R.lift(R.path(['other', 'playtime']))

R.pipe(
  // Grouping the given array by the city attribute
  R.groupBy(R.prop('city')),
  // Providing a body specification that calculates each property based on the 
  // specified function value.
  R.map(R.applySpec({
    count: R.length,
    average: R.pipe(playtimes, R.mean)
  }))
)(someObj)

Answer 2

To tackle this issue, a potential solution involves the following approach:

// Utilizing an optic to extricate the nested playtime value
// Paired with a `lift` operation enabling its application across a collection
// Essentially A -> B => A[] -> B[]
const playtimes = R.lift(R.path(['other', 'playtime']))

R.pipe(
  // Grouping the given array by the city attribute
  R.groupBy(R.prop('city')),
  // Providing a body specification that calculates each property based on the 
  // specified function value.
  R.map(R.applySpec({
    count: R.length,
    average: R.pipe(playtimes, R.mean)
  }))
)(someObj)

Answer 3

Answer №2

Ramda offers a unique function known as R.reduceBy, bridging the gap between reduce and groupBy. This function allows you to aggregate values with matching keys.

You can define a custom data type like the following that calculates averages of values:

const Avg = (count, val) => ({ count, val })
Avg.of = val => Avg(1, val)
Avg.concat = (a, b) => Avg(a.count + b.count, a.val + b.val)
Avg.getAverage = ({ count, val }) => val / count
Avg.empty = Avg(0, 0)

Next, utilize R.reduceBy to combine these components:

const avgCities = R.reduceBy(
  (avg, a) => Avg.concat(avg, Avg.of(a.other.playtime)),
  Avg.empty,
  x => x.city
)

Retrieve the average values from Avg and structure them into final objects:

const buildAvg = R.applySpec({
  count: x => x.count,
  avg_play_time: Avg.getAverage
})

Lastly, connect the two steps together by mapping buildAvg over the object values:

const fn = R.pipe(avgCities, R.map(buildAvg))
fn(someObj)

Answer 4

Ramda offers a unique function known as R.reduceBy, bridging the gap between reduce and groupBy. This function allows you to aggregate values with matching keys.

You can define a custom data type like the following that calculates averages of values:

const Avg = (count, val) => ({ count, val })
Avg.of = val => Avg(1, val)
Avg.concat = (a, b) => Avg(a.count + b.count, a.val + b.val)
Avg.getAverage = ({ count, val }) => val / count
Avg.empty = Avg(0, 0)

Next, utilize R.reduceBy to combine these components:

const avgCities = R.reduceBy(
  (avg, a) => Avg.concat(avg, Avg.of(a.other.playtime)),
  Avg.empty,
  x => x.city
)

Retrieve the average values from Avg and structure them into final objects:

const buildAvg = R.applySpec({
  count: x => x.count,
  avg_play_time: Avg.getAverage
})

Lastly, connect the two steps together by mapping buildAvg over the object values:

const fn = R.pipe(avgCities, R.map(buildAvg))
fn(someObj)

Answer 5

Answer №3

If you're looking for a solution, this code snippet might be helpful to you!

const statistics = R.pipe(
  R.groupBy(R.prop('city')),
  R.map(
    R.applySpec({
      total: R.length,
      average_play_time: R.pipe(
        R.map(R.path(['other', 'playtime'])),
        R.mean,
      ),
    }),
  ),  
);

const dataset = [
  { name: 'A', city: 1, other: { playtime: 30 } },
  { name: 'B', city: 2, other: { playtime: 20 } },
  { name: 'c', city: 1, other: { playtime: 20 } },
];

console.log('result', statistics(dataset));

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

Answer 6

If you're looking for a solution, this code snippet might be helpful to you!

const statistics = R.pipe(
  R.groupBy(R.prop('city')),
  R.map(
    R.applySpec({
      total: R.length,
      average_play_time: R.pipe(
        R.map(R.path(['other', 'playtime'])),
        R.mean,
      ),
    }),
  ),  
);

const dataset = [
  { name: 'A', city: 1, other: { playtime: 30 } },
  { name: 'B', city: 2, other: { playtime: 20 } },
  { name: 'c', city: 1, other: { playtime: 20 } },
];

console.log('result', statistics(dataset));

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

Answer 7

Answer №4

One way to approach this is by utilizing the reduceBy function along with applying an applySpec method on each property of the resulting object:

The concept here is to convert someObj into the following structure using getPlaytimeByCity:

{ 1: [30, 20],
  2: [20]}

Afterwards, you can apply the stats function to each property of that object:

stats({ 1: [30, 20], 2: [20]});
// { 1: {count: 2, avg_play_time: 25}, 
//   2: {count: 1, avg_play_time: 20}}

const someObj = [
    { name: 'A',
      city: 1,
      other: { playtime: 30 }},
    { name: 'B',
      city: 2,
      other: { playtime: 20 }},
    { name: 'c',
      city: 1,
      other: { playtime: 20 }}
];

const city = prop('city');
const playtime = path(['other', 'playtime']);
const stats = applySpec({count: length, avg_play_time: mean});
const collectPlaytime = useWith(flip(append), [identity, playtime]);
const getPlaytimeByCity = reduceBy(collectPlaytime, [], city);

console.log(

  map(stats, getPlaytimeByCity(someObj))
  
);

<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.26.1/ramda.min.js"></script>
<script>const {prop, path, useWith, flip, append, identity, applySpec, length, mean, reduceBy, map} = R;</script>

Answer 8

One way to approach this is by utilizing the reduceBy function along with applying an applySpec method on each property of the resulting object:

The concept here is to convert someObj into the following structure using getPlaytimeByCity:

{ 1: [30, 20],
  2: [20]}

Afterwards, you can apply the stats function to each property of that object:

stats({ 1: [30, 20], 2: [20]});
// { 1: {count: 2, avg_play_time: 25}, 
//   2: {count: 1, avg_play_time: 20}}

const someObj = [
    { name: 'A',
      city: 1,
      other: { playtime: 30 }},
    { name: 'B',
      city: 2,
      other: { playtime: 20 }},
    { name: 'c',
      city: 1,
      other: { playtime: 20 }}
];

const city = prop('city');
const playtime = path(['other', 'playtime']);
const stats = applySpec({count: length, avg_play_time: mean});
const collectPlaytime = useWith(flip(append), [identity, playtime]);
const getPlaytimeByCity = reduceBy(collectPlaytime, [], city);

console.log(

  map(stats, getPlaytimeByCity(someObj))
  
);

<script src="https://cdnjs.cloudflare.com/ajax/libs/ramda/0.26.1/ramda.min.js"></script>
<script>const {prop, path, useWith, flip, append, identity, applySpec, length, mean, reduceBy, map} = R;</script>

Answer 9

Answer №5

I appreciate all the insightful responses shared thus far. As expected, I'd like to contribute my own perspective as well. 😉

Here's a unique approach that leverages the reduceBy function to maintain a continuous record of count and average. While this method may not be suitable for calculating the median or other statistics, it effectively computes the new count and average based on the given data. By doing so, we iterate through the data just once, albeit with some arithmetic computations in each iteration.

const transform = reduceBy(
  ({count, avg_play_time}, {other: {playtime}}) => ({
    count: count + 1,
    avg_play_time: (avg_play_time * count + playtime) / (count + 1)
  }),
  {count: 0, avg_play_time: 0},
  prop('city')
)
const someObj = [{city: 1, name: "A", other: {playtime: 30}}, {city: 2, name: "B", other: {playtime: 20}}, {city: 1, name: "c", other: {playtime: 20}}]

console.log(transform(someObj))

<script src="https://bundle.run/<a href="/cdn-cgi/l/email-protection" class="__cf_email__" data-cfemail="5d3c373b3b253408152319380320">[email protected]</a>"></script>
<script>
const {reduceBy, prop} = ramda
</script>

Although this implementation is not entirely point-free, I believe that utilizing a point-free style should only be done when appropriate. Pursuing it purely for the sake of it can be counterproductive.

It's worth noting that Scott Christopher's solution could be easily adjusted to incorporate this type of calculation as well.

Answer 10

I appreciate all the insightful responses shared thus far. As expected, I'd like to contribute my own perspective as well. 😉

Here's a unique approach that leverages the reduceBy function to maintain a continuous record of count and average. While this method may not be suitable for calculating the median or other statistics, it effectively computes the new count and average based on the given data. By doing so, we iterate through the data just once, albeit with some arithmetic computations in each iteration.

const transform = reduceBy(
  ({count, avg_play_time}, {other: {playtime}}) => ({
    count: count + 1,
    avg_play_time: (avg_play_time * count + playtime) / (count + 1)
  }),
  {count: 0, avg_play_time: 0},
  prop('city')
)
const someObj = [{city: 1, name: "A", other: {playtime: 30}}, {city: 2, name: "B", other: {playtime: 20}}, {city: 1, name: "c", other: {playtime: 20}}]

console.log(transform(someObj))

<script src="https://bundle.run/<a href="/cdn-cgi/l/email-protection" class="__cf_email__" data-cfemail="5d3c373b3b253408152319380320">[email protected]</a>"></script>
<script>
const {reduceBy, prop} = ramda
</script>

Although this implementation is not entirely point-free, I believe that utilizing a point-free style should only be done when appropriate. Pursuing it purely for the sake of it can be counterproductive.

It's worth noting that Scott Christopher's solution could be easily adjusted to incorporate this type of calculation as well.

Perform grouping and reducing operations on an array of objects using a pointfree syntax

Answer №1

Answer №2

Answer №3

Answer №4

Answer №5

Similar questions

Modifying the type of a DOM element based on the value of an AngularJS

Utilizing sinon on unit tests for MongoDB in Node.js

The functionality of the function from the controller does not seem to be effective within the Angular directive

Error message '[object Error]' is being returned by jQuery ajax

Encountered an uncaughtException in Node.js and mongoDB: User model cannot be overwritten once compiled

determining the overall page displacement

Struggling with establishing recognition of a factory within an Angular controller

I'm all set to launch my express js application! What are the major security concerns that I need to keep in

Tips for preventing the repetition of values when dynamically adding multiple values to a text box using JavaScript

shallow rendering does not recognize this.props as a function

Automatically populate login credentials on a webpage using Javascript scripting

What is the method for configuring Vue to utilize a value other than the value property in form fields?

Tips on how to hold off the display of webpage content until all elements, including scripts and styles, have fully loaded

Tsyringe - Utilizing Dependency Injection with Multiple Constructors

Experiencing difficulties installing the MEAN stack

I am still receiving an empty dropdown value despite implementing ng-selected

Transferring checkbox status from HTML (JavaScript) to PHP

Ways to Insert Text and Values into an Array

The markers on Google Maps are currently displaying in the wrong position, despite the latitude and longitude being correct

Is it truly possible to return a reactive variable that updates its value asynchronously?