any nifty shorthand function to check if the elements in array x all occur in array y ?
thanks @franciscotln
@james-gardner so you are asking if array X is a subset of array Y?
yes
R.compose(
R.flip(R.all)(permissions),
R.flip(R.contains),
R.prop('permissions')
)
is what I came up with
but it seems ott
it is as easy as this:
let isSuperset = (x, y) => R.equals(R.intersection(x, y), x)
isSuperset(A, B) === true means that B is a superset of A
@are1000 this works under one important condition: no repeated elements
@franciscotln which is obvious (I hope) because we are talking about sets!
but it's good that you mentioned it
I read array, not set :-) sorry, took it literally
I mean, I was talking about sets :P
Yeah, I just read his question and your answer
this allows repeated elements:
const xs = [ {id: 1}, {id: 2}, {id: 4}, {id: 4} ];
const ys = [ {id: 1}, {id: 2}, {id: 3}, {id: 4}, {id: 5} ];
R.equals(R.innerJoin(R.eqProps('id'), xs, ys), xs); // true
const ws = [5, 5, 4, 3, 2, 1];
const zs = [1 ,2 ,3 ,4 , 5, 6];
R.equals(R.innerJoin(R.equals, ws, zs), ws); // true
alternative:
const xs = [ {id: 1}, {id: 2}, {id: 3}, {id: 4} ];
const ys = [ {id: 5}, {id: 4}, {id: 3}, {id: 2}, {id: 1}, {id: 0} ];
R.all(R.contains(R.__, ys), xs); // true
Does it go against the theme of things to try and bind a data pipeline to a specific list?
by bind I mean generate a function that always uses the same data in conjunction with a pipeline
For example:
const segment = getRole('USER_ADMIN')(acl);The 'acl' argument
"The parameters to Ramda functions are arranged to make it convenient for currying. The data to be operated on is generally supplied last"
I'd otherwise have to write functions for every possible role, or something that generated them for me.
do you just mean, partially apply
getRole?
I tried partialRight
thinking along similar lines
you can wrap
getRole in R.curry
then you can make a new function via
const getAdmin = getRole("USER_ADMIN")
Here's the implementation of getRole:
const getRole = (role) => R.find(
R.where({ roles: R.contains(role) })
);
getAdmin would mean I would need getXXXX for every role
what are you trying to accomplish?
you can also define
getRole with the list as an argument
const getRole = R.curry((role, list) => R.find(
R.where({ roles: R.contains(role) })
)(list));
then you can do
getRole("USER_ADMIN", acl)
and also create
getAdmin by partially applying it, like above
or, do want
getRole partially applyed with acl?
with the curried version above, you can use
R.__
const getRoleFromAcl = getRole(R.__, acl);
oh, I like that :D
How would I go about to generate a diff between an original object and changed object? Any steps/hints?
there's a function for that!
http://ramdajs.com/docs/#difference
http://ramdajs.com/docs/#difference
I have two objects, not two lists
i think it still works
R.difference([{a: 1}, {b: 2}], [{a: 1}, {c: 3}]) //=> [{b: 2}]
That are two lists
ah, you're right...
so I think the deep comparison is going to be a bit of a problem, or at least, I can't wrap my head arround it
yeah, you might need something recursive
there are really to much functions for a beginner, these should be prioritized or something
what do you mean?
ahah
my ugly solution for objects
useWith(
compose(
mergeAll,
map(apply(objOf)),
difference
), [toPairs, toPairs])({a: 10, b: 20}, {a: 10, b: 30})
all those functions in the api..
that looks impressive, let me analyze :smile:
@xgrommx : at first glance this only works for flat objects right ? (
[toPairs,toPairs])
yes, do u need compare nested objects?
yeah, I have this form which renders fields from a rest api, and I want to send a
sparse update back. I have a function for it, but I thought this would be a good starting function for FP
it has some specific needs, like it requires the
id of nested objects when a subproperty changes, etc.
oh) I had the same problem on my project
take a look on
const isObject = compose(equals('Object'), type)
const isNumeric = v => !isNaN(v - parseFloat(v))
const groupObjBy = curry(compose(
map(fromPairs),
useWith(groupBy, [useWith(__, [last]), toPairs]),
))
const diffObj = compose(
evolve({
difference: map(({leftValue, rightValue}) => {
if (isObject(leftValue) && isObject(rightValue)) {
return diffObj(leftValue, rightValue)
} else {
return {leftValue, rightValue}
}
}),
common: map(prop("leftValue")),
onlyOnLeft: map(prop("leftValue")),
onlyOnRight: map(prop("rightValue"))
}),
groupObjBy(cond([
[
both(has("leftValue"), has("rightValue")),
compose(ifElse(apply(equals), always("common"), always("difference")), values)
],
[has("leftValue"), always("onlyOnLeft")],
[has("rightValue"), always("onlyOnRight")],
])),
useWith(mergeWith(merge), [map(objOf("leftValue")), map(objOf("rightValue"))])
)This is advanced version of https://github.com/ramda/ramda/wiki/Cookbook#diffobjs---diffing-objects-similar-to-guavas-mapsdifference
My version works correctly with nested objects
that just looks like magic... how did you wrap your head arround all those small steps? Is there a good read about this, or just practice, practice, practice?
@tkvw haskell :D
that's a FP language right?
yes, exactly
elm is a frontend FP language that is very similar to haskell
an ML language
hm
I don't like elm
damn, have to get me one of those some day
more better purescript
i haven't used purescript, but elm is designed to be really friendly to beginners
I come from oo and am working with React now and learn more about FP, and I really hate the way I got accustomed to solve tasks. FP looks so ellegant
@tkvw I start with writing small functions I know I will need in the final solution. Then I look at how I can build those together into composites that will solve my issue
The beauty (to me) in functional approaches is how composable everything is. You write small focused functions that do something you want, and then you can mix and match those with functions that manipulate the structure you are working with
@tkvw take a look on difference between my and cookbook version https://goo.gl/8wNsNC
@Bradcomp : yeah, well.. experience is key probably, that solution @xgrommx would have taken me till the end of the month :smile:
Definitely practice helps, but it's nice to have some direction.
@xgrommx : Yeah, I am going to play arround with it, thanks for the toy!
@Bradcomp : Exactly, that's what I am missing in the docs, something like a structurual flow to use (and which functions belong with these flows) for obvious use cases.
I need to spend some more time in the Cookbook
There's also the 'What function should I use' part of the wiki, which may help
Yes, that's a functional list (too long for my taste, but
Ctrl+F able, so helpful
Honestly, it's nice to start with a dozen or so basic building blocks -
map, filter, reduce, prop,path,pipeandcompose`, etc...
You can go a long way with just a few functions, and the more esoteric ones will start to make sense as you see the recurring patterns you're dealing with
The api is broken in to categories you'll see along the right of the function names (Math, List, Object, etc..). And you can use the search to search by the categories. I use that quite often
@xgrommx : Is your daytime job maintaining a list of links ? :wink: Impressive!
This is a great article series for getting started http://randycoulman.com/blog/categories/thinking-in-ramda/
@tkvw yes, sometime I have time for update it =)
Thanks guys, enough info for now
Wow, it's already so much fun to understand
map(objOf("leftValue")) and why you would even think of it, nice
@tkvw
map(x => ({"leftValue": x})) the same
yeah, it has landed already, now looking at the
groupObjBy beast
those placeholder thingies make it hard to wrap my head arround it, but I'll get there
@alavkx : Good tip on filtering on category, that really sanitizes the list
:)
groupObjBy is an awesome function
groupObjBy is an awesome function
what's the deal with
R.is, can we use this with Array?
i don't see it in the examples: http://ramdajs.com/docs/#is
i wondering if there is a weird edge case, kind of like
R.is(Object, new String('')); //=> true
alternatively, i can just use
Array.isArray https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray
R.is
Looks like it just does an instance check according to the source
Also, the source links Rambot provides need to be updated
i'm a little wary of
R.is because of .constuctor and instanceOf. I know there are gotcha's with those and i don't fully understand them
I would agree to some extent.
It would definitely be worthwhile to test it for your use case before just relying on it
Guys how would go about this?
const input = {
first: [
{id: 'a'},
{id: 'b'},
{id: 'c'}
],
second: [
{id: 'a'},
{id: 'b'},
{id: 'c'}
],
third: [
{id: 'a'},
{id: 'b'},
{id: 'c'}
],
};
const output = [
{ first: 'a', second: 'b', third: 'c' },
{ first: 'a', second: 'b', third: 'c' },
{ first: 'a', second: 'b', third: 'c' },
];
I've been reading about some of the functions like toPairs but I'm not sure how I can merge the objects to get my desired output
what is the transformation you're trying to make? It isn't really clear to me from the example
I have an object with 3 different arrays (first, second and third). I need to to merge there 3 arrays by property
would the first item in the output be
{ first: 'a', second: 'a', third: 'a' }?
yes, @lax4mike
I painfully failed at my example
I painfully failed at my example
Ok that makes more sense
This is what I'm actually trying to achieve:
const output = [
{ first: 'a', second: 'a', third: 'a' },
{ first: 'b', second: 'b', third: 'b' },
{ first: 'c', second: 'c', third: 'c' },
];
that's still a little weird, your array needs to have the same number of elements as each of the objects
what if there is
{id: "d"}?
this is just a basic first attempt. It works, but could probably be cleaned up.
@lax4mike it's always guaranteed that I'll have the same number of times in each array, at least in my situation
using
toPairs and pulling out the keys and values that way would technically be safer than using keys and values, but every implementation preserves object ordering so that will work fine
converge(compose(fromPairs, zip), [keys, o(transpose, values)])(input) is a tacit version if you're into that sort of thing
@Bradcomp thank you man, I didn't even know about zip. Still need so much practice until I can be proficient with Ramda
:bowtie: I think
zip and transpose are probably the two keys to that problem
what is the 'o' in o(transpose, values) referring to?
R.o
You can sub it out for
compose and it would work the same, it's just shorter
o is more restrictive than compose though
R.o confuses me, sometimes it doesn't work the same as R.compose even when it's passed a single param
for instance,
o(fromPairs, zip) would break the function because zip takes 2 parameters
Sorry, shouldn't have introduced the confusion :(
actually, i can't find an example now...