CycleJS Sink helper function

transformSinks.js

/**
  pretty straightforward implementatation.
  ( Stream -> Stream ) -> string -> HOC
  
  HOC is a higher order component where the Signature is always
  (sources -> sinks) -> sources -> sinks
**/
function transformSink( fn, key ) {
  return ( Component ) => ( sources ) => {
    const sinks = Component( sources )
    return {
      ...sinks,
      [key]: sinks[key].map( fn )
    }
  }
}

/**
  now to transform multiple sinks
  
  gets a key to fn pair dictionary object,
  reduce over all keys and transform sinks.
  
  To maintain purity, clone sinks.
  
  e.g. transformDict = { 'HTTP' : stream => stream.map( /../ ) }
  
  Transform Object -> HOC
**/
function transformSinks( transformDict ) {
  return ( Component ) => ( sources ) => Object.keys( transformDict )
    .reduce((sinks, key) => ({
      ...sinks,
      [key]: sinks[key].map( transformDict[key] )
    })
    , Component( sources ))
}

/**
  gets carried away with Ramda? lol
**/

// import R from 'ramda'
function v2_transformSinks( transformObj ) {
  const transformSink = ( sinks, [ key, fn ] ) => ({
    ...sinks,
    [key] : sinks[key].map( fn )
  })

  return ( Component ) => ( sources ) => R.compose(
    R.reduce( transformSink, Component( sources )),
    R.toPairs
  )( transformObj )
}

/**
  How would `v2_transformSinks` be refactored?
  Or how better would you refactor `transformSinks`?
  Right now it has become quite a mess. Perhaps I've gone too far?
  Also still learning Hindley Milner notation.. help correct my mistake please :P
**/