Whats the best way to add a field to the last occurrence object in an array with Ramda? - list

Question

Let's say I have a simple array of objects, that all have a type field :
let arr = [
{
"name": "First",
"type": "test"
},
{
"name": "Second",
"type": "test"
},
{
"name": "Third",
"type": "test2"
},
{
"name": "Fourth",
"type": "test2"
},
{
"name": "Fifth",
"type": "test3"
},
{
"name": "Sixth",
"type": "test3"
}
]
Using Ramda what is the best way to add a field to only the last occurrence of each types?
to get :
let newArr = [
{
"name": "First",
"type": "test"
},
{
"name": "Second",
"type": "test",
"last": true
},
{
"name": "Third",
"type": "test2"
},
{
"name": "Fourth",
"type": "test2",
"last": true
},
{
"name": "Fifth",
"type": "test3"
},
{
"name": "Sixth",
"type": "test3",
"last": true
}
]
I can't really wrap my head around it! Thanks in advance! :)

Answer 1

Here's one possible solution:
// f :: [{ type :: a }] -> [{ type :: a, last :: Boolean }]
const f = R.addIndex(R.map)((x, idx, xs) =>
R.assoc('last',
R.none(R.propEq('type', x.type), R.drop(idx + 1, xs)),
x));
For each value in the list we look ahead to see whether there is a subsequent value with the same type property.

Answer 2

I'm making the guess that your data is grouped as displayed and that elements of different types are not interspersed. If that guess is wrong, there would need to be a different solution.
My version involves two helper functions, one which groups a list according to a predicate which reports whether two (consecutive) values belong together:
const breakWhen = R.curry(
(pred, list) => R.addIndex(R.reduce)((acc, el, idx, els) => {
if (idx === 0 || !pred(els[idx - 1], el)) {
acc.push([el])
} else {
acc[acc.length - 1].push(el);
}
return acc;
}, [], list)
);
And the second a Lens which focuses on the last element of a list:
const lastLens = R.lens(R.last, (a, s) => R.update(s.length - 1, a, s));
With these two, you can build a function such as this:
const checkLasts = R.pipe(
breakWhen(R.eqProps('type')),
R.map(R.over(lastLens, R.assoc('last', true))),
R.flatten
);
checkLasts(arr);
The implementation of breakWhen is pretty awful. I'm sure there's something better. The function combines ideas from Ramda's splitEvery and splitWhen
This is slightly different from David Chambers' solution as it doesn't add a last: false property to the remaining elements. But obviously it's more complex. And either of them would fail if the data is not grouped as expected.