so I created a
createModArgs
that takes a
resolver
the resolver accepts
arg, index, arguments (like value, index, array)
it's used to then create a function that passes the transforms args based on the resolves of the resolver
so for
useWith the resolver would be identity and for converge it would be function(value, index, args) { return args }
could be
baseModArgs(func, transforms, resolver)
W (foo)(x) == foo (x)(x)
Hi all, is there a function in Ramda that loops over the values of an array, and transforms them to keys of an object ie
['FY', 'Q3', 'Q2'] => {'FY': [ some filtered stuff here], 'Q3': [ 'some other stuff' ], 'Q2': [ ]} Use case is when getting some stuff from SQL and transforming into more json like structure
@jdalton I also like
converge as a name. I do think useWith would have to be renamed as it can mean anything. How about converge ("To come together from different directions") and disperse ("To strew or distribute widely")? The two words are related because they're kind of opposite, but they also both say something about what happens to the arguments. Besides, I think the subtle differences between the two are too great to name them after the same thing. I'm specifically talking about how the arity for the returned functions is chosen. For converge it will be the biggest arity of all given transformers, and for useWith it will be equal to the amount of given transformers.
Hi folks, I would like to use Ramda, but didn't find the right solution, do you have any ideas how can I do this? Thanks
// input
var input = {
apple: 3,
cucumber: 1
};
// desired output
[{
name: 'apple',
quantity: 3
}, {
name: 'cucumber',
quantity: 1
}];
function transformData(content) {
return reduce(function(output, key) {
output.push({
name: key,
quantity: content[key]
});
return output;
}, [], Object.keys(content));
}
@bling5630
var transformData = R.pipe(R.toPairs, R.map(R.zipObj(["name", "quantity"]))) - http://bit.ly/1QfI7WH
@jdalton The more I think about my naming of
disperse, the more I like it! Converge "converges" the arguments with every given transformer, and disperse "disperses" the arguments across all given transformers! :D .. Maybe I'm falling in love, and I should kill my darlings and such.. It's a good name right? :worried:
@Avaq Well, both
converge and useWith necessarily disperse first, converge dispersing the entirety of arguments to all transformers and useWith dispersing individual arguments to individual transformers. So it's a little unclear from that perspective, I think. It's still better than useWith to describe the behaviour at least.
@00Davo Ah, I think of the word "disperse" as kind of "being driven apart". Like a herd of sheep is "dispersed" when a dog runs into the center of the herd. From that point of view I can't think of "dispersing the entirety of arguments to all transformers", because it would involve cloning the sheep ;). But maybe my concept of the word is wrong, I'm no native speaker.
Perhaps working the word "spread" into
useWith's new name would be helpful, considering "spread" is used with similar meaning by Q (and other promise libraries?).
That's an interesting idea too. It lacks the intrinsic connection to the word "converge" (via opposites) that "disperse" does though :). Also, to me just
R.spread sounds like an alias to R.apply (which is really what it means in Q and such too), so you would have to come up with a function name containing "spread", which might get long.
diverge is not bad, as long as we don't make to much of its connection with converge. The two words describe well different parts of the operation, and in actuality the way the word 'converge' fits would equally fit useWith.
this is sort of the purpose of my https://github.com/algesten/fnuc/blob/master/api.md#ppipe function. you can test the pipe using non-promises and then both accept promises in and return promises in production code.
granted it doesn't work well if the IO is in the middle.
I can pretend I don't use promises :)
Ya
converge and useWith are essentially the same. It comes down to one passes the transforms a single argument of the index of the transform and the other passes it all arguments. So I'm trying to come up with a common name that describes that (tough). I'll keep kicking it around.
and by module i mean the file that exports something else that uses the private function in a pipeline
Something like that, yeah. But if you're writing a mostly-pure pipeline that happens to do one impure action in the middle, it'd probably be a good idea to parameterise it on the impure function anyway? Maybe make the usual source of the promise a default argument, and pass a replacement for it in unit tests.