functional programming modify two items in an array

Question

I am looking into functional programming where I have the following code so far:

const R   = require('ramda')
const original = {
  words: [
    { duration: '0.360000', name: 'Arthur', position: '0.660000' },
    { duration: '0.150000', name: 'the',    position: '1.020000' },
    { duration: '0.380000', name: 'rat',    position: '1.170000' },
    { duration: '0.770000', name: '.',      position: '1.550000' }
  ]
}

// 1. convert position and duration to int and multiply by 100
const makeInteger = a => parseFloat(a) * 100

const words = R.lensPath(['words'])
log('position', R.over(words, R.map(R.over(position, makeInteger)), original).words)

returns:

position: [
    {
        duration: '0.360000',
        name: 'Arthur',
        position: 66
    },
    {
        duration: '0.150000',
        name: 'the',
        position: 102
    },
    {
        duration: '0.380000',
        name: 'rat',
        position: 117
    },
    {
        duration: '0.770000',
        name: '.',
        position: 155
    }
]

How do I modify both duration and position in the same function in order to make them integers?

Following that, I would have this function where I pass an index and update all the positions following that point.

Basically I like to shift the 'position' offset depending on the object where the 'duration' was modified?

const pos = R.over(words, R.map(R.over(position, makeInteger)), original)
const y = (i) => R.slice(i, Infinity, pos.words)
const foo = R.adjust(R.add(-2), 0, y(1))
log(foo)

And I got

[
    NaN,
    {
        duration: '0.150000',
        name: 'the',
        position: 102
    },
    {
        duration: '0.380000',
        name: 'rat',
        position: 117
    },
    {
        duration: '0.770000',
        name: '.',
        position: 155
    }
]

So I am kind of stuck on how to offset the position.

Any advice is much appreciated.

Ian Hofmann-Hicks · Accepted Answer · 2016-12-11 01:26:18Z

1

I would do something like this, evolve and splitAt are your buddies:

const {
  lensProp, lensIndex, splitAt, compose,
  curry, flatten, add, map, multiply,
  over, evolve
} = require('ramda')

const original = {
  words: [
    { duration: '0.360000', name: 'Arthur', position: '0.660000' },
    { duration: '0.150000', name: 'the',    position: '1.020000' },
    { duration: '0.380000', name: 'rat',    position: '1.170000' },
    { duration: '0.770000', name: '.',      position: '1.550000' }
  ]
}

const words = lensProp('words')
const snd = lensIndex(1)

const makeInt =
  compose(multiply(100), parseFloat)

const updateProps =
  evolve({ duration: makeInt, position: makeInt })

const offsetPos =
  offset => evolve({ duration: add(offset), position: add(offset) })

const wordsToInt =
  over(words, map(updateProps))

const offsetTail = curry(
  (offset, list) => over(snd, map(offsetPos(offset)))(list)
)

const applyOffset = curry(
  (indx, offset, list) => compose(
    flatten,
    offsetTail(offset),
    splitAt(indx)
  )(list)
)

const offsetWords = curry(
  (indx, offset, obj) =>
    over(words, applyOffset(indx, offset))(obj)
)

const flow =
  compose(offsetWords(2, -2), wordsToInt)

log(flow(original))

answered Dec 11, 2016 at 1:26

Ian Hofmann-Hicks

714 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

khinester Over a year ago

nice one, this is perfect

Ian Hofmann-Hicks Over a year ago

The answer by @scott-sauyet is pretty darn good. his use of lift with concat(well with any n-ary > 1 function) is a super powerful pattern for ramda when working with lists.

Community · Accepted Answer · 2017-05-23 11:45:39Z

1

Another version, modelled on the one from @Ian Hoffman-Hicks, but with a slightly different public API (flow takes all three parameters) and several fewer intermediate functions, looks like this:

const wordsLens = lensProp('words') 

const makeInt = compose(multiply(100), parseFloat)

const offsetWords = curry((idx, offset, obj) => over(
  wordsLens, 
  lift(concat)(
    take(idx), 
    compose(
      map(evolve({position: add(offset)})), 
      drop(idx)
    )
  ), 
  obj
))

const flow = curry((idx, offset, obj) => offsetWords(
  idx, 
  offset, 
  over(
    wordsLens, 
    map(evolve({duration: makeInt, position: makeInt})), 
    obj
  )
))

flow(2, -2, original)

You can see this in action on the Ramda REPL.

This version also used evolve, although it chooses take and drop over splitAt. This might or might not be worth considering for you, but it at least shows a different approach.

edited May 23, 2017 at 11:45

CommunityBot

11 silver badge

answered Dec 11, 2016 at 3:53

Scott Sauyet

50.9k5 gold badges57 silver badges111 bronze badges

1 Comment

khinester Over a year ago

thanks for the response, is really good and have learned more.

Flarp · Accepted Answer · 2016-12-10 23:43:56Z

0

For you first quesion, that's easy.

const parsedList = words.map(word => {
    return {
        duration:parseInt(word.duration)*100,
        name,word.name,
        position: parseInt(word.position)*100
    }
})

.map is a new ES6 function that loops over an array, and then returns a new array. (Doesn't mutate the array it's mapping, which is functional programming 101)

For your second one, forgive me if I'm wrong, but it sounds like either .filter or .push would work.

answered Dec 10, 2016 at 23:43

Flarp

1692 silver badges10 bronze badges

Collectives™ on Stack Overflow

functional programming modify two items in an array

3 Answers 3

2 Comments

1 Comment

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

2 Comments

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest