ramda/ramda

Practical functional Javascript

Martin Algesten

@algesten

haha! :D

just out of curiosity. does Object.keys guarantee an order?

or that multiple invocations will have the same order as a result.

Scott Sauyet

@CrossEye

Very big point of contention now. #1067.

Scott Sauyet

@CrossEye

It is not really consisyent with our notion of equals. Two things we think of as equal could have different order of keys. I'm proposing a change, but there's significant opposition.

Martin Algesten

@algesten

I'm reading. just now at the bit where jdalton appear to be wilfully obtuse regarding the natural order of a list.

Scott Sauyet

@CrossEye

He's not just trolling, even if it sometimes feels that way. He does have serious points to make. And decisions here are clearly not as obvious to everyone as I would have thought. Lots of smart people with lots of different opinions.

John-David Dalton

@jdalton

:hear_no_evil:

Martin Algesten

@algesten

:blush:

Scott Sauyet

@CrossEye

... and jdalton is one of them :angel:

Raine Virta

@raine

I think the arrow syntax is a bit too loose

let foo = (a) => ... // ok
let bar = () => ... // ok
let baz = a => ... // ok
let xyz = => ... // not ok

however in case of map(x => x*x) I can understand without parens it's more readable

John-David Dalton

@jdalton

Arrow funcs are nice

I donno why skinny arrow wasn't done (no lexical bind)

like CS. There was prolly a ton of discussion (as per usual)

Alex Schenkman

@alesch

@algesten @Avaq @CrossEye Thank you all for the explanations. I’ll have to study them more.

@CrossEye You said you used compose but you thought of it with pipe. How would it be with pipe? In case it becomes easier to read for me.

Scott Sauyet

@CrossEye

R.pipe(R.toPairs, R.map(R.apply(R.assoc('id')))) -- just reversing the parameter order.

Aldwin Vlasblom

@Avaq

@alesch pipe is just compose but reversed: pipe(a, b, c) === compose(c, b, a)

I think compose is meant to resemble nested-function calling, like so: compose(a, b, c)(x) looks like a(b(c(x)))

And pipe is meant to resemble piping, like so: pipe(a, b, c)(x) looks like x > a | b | c

Or that's how I think of them anyway. ;)

John-David Dalton

@jdalton

trying to come up with a better name for useWith and converge. It looks like useWith may be created by way of converge.

naming these things is hhaaaarrrdd grumble grumble

John-David Dalton

@jdalton

modArgs and distArgs woo

John-David Dalton

@jdalton

still not great

but betterish

Raine Virta

@raine

mapArgs

John-David Dalton

@jdalton

that makes me think of 1 function to map over args

Raine Virta

@raine

yeah that's true

John-David Dalton

@jdalton

it could be maybe

converge -> modArgs and useWith -> modPerArg

John-David Dalton

@jdalton

oh snao

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)

Jethro Larson

@jethrolarson

About half the time I use useWith I actually want the W combinator

W (foo)(x) == foo (x)(x)

Jethro Larson

@jethrolarson

Well, that's only true if everything is manually curried, including compose

Matthew Steedman

@knubie

@jdalton I actually think converge makes a lot of sense as a name

Dominik Dumaine

@Bondifrench

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

John-David Dalton

@jdalton

@knubie you can be wrong it's ok ; )

Jethro Larson

@jethrolarson

Converge made sense to me. UseWith not so much

Stefano Vozza

@svozza

@Bondifrench do you mean something like fromPairs?

Dominik Dumaine

@Bondifrench

@svozza will have a look, thx

Aldwin Vlasblom

@Avaq

@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.

Tamas

@bling5630

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));

}

Aldwin Vlasblom

@Avaq

@bling5630 var transformData = R.pipe(R.toPairs, R.map(R.zipObj(["name", "quantity"]))) - http://bit.ly/1QfI7WH

Tamas

@bling5630

@Avaq thanks, I really appreciate your help!

Aldwin Vlasblom

@Avaq

You're very welcome. :)

Where communities thrive

People

Repo info

Activity