This question is related to the Ramda Docs and Html sematics.
The Ramda Docs page has headers like "add", that when clicked navigate within the current window to the add function.
Looking at the html:
<h2>
<a tabindex="2" class="name" href="#add">add</a>
<span class="pull-right">
<span class="label label-category">Math</span>
<a target="_blank" title="View source on GitHub" href="https://github.com/ramda/ramda/tree/v0.28.0/source/add.js"><small class="glyphicon glyphicon-new-window"></small></a>
</span>
</h2>
Mdn docs for the a tag say using the ID creates the link,
<p><a href="#Section_further_down">
Jump to the heading below
</a></p>
<h2 id="Section_further_down">Section further down</h2>
Yet in Ramda docs there is no ID, so how does it still work?
Hi everyone, I'm new to Ramda (and FP) and was hoping for some help with implementing some code with Ramda.
I have an object o with current value of { foo: [{ value: "bar" }] }.
I would like to create a function that appends an array of newData to one of the child arrays of existingData based on a dynamic criteria (in this case, I just take the first key of existingData).
Without Ramda, it looks like this:
const o = { foo: [{ value: "bar" }] };
function pushToFirstKey(newData, existingData) {
const key = Object.keys(existingData)[0]
return {
...existingData,
[key]: [...existingData[key], ...newData]
}
}
pushToFirstKey([{ value: "baz" }], o);
// Result: {"foo": [{"value": "bar"}, {"value": "baz"}]}My attempt with Ramda looks like this:
const o = { foo: [{ value: "bar" }] };
const pushToFirstKeyFP = (newData, existingData) =>
R.compose(
R.assocPath([R.head(R.keys(existingData))], R.__, existingData),
R.concat(R.prop(R.head(R.keys(existingData)), existingData))
)(newData);
pushToFirstKeyFP([{ value: "baz" }], o);
// Result: {"foo": [{"value": "bar"}, {"value": "baz"}]}Which I suspect could be better written.
Does anyone have suggestions for me?
you can use modify like this:
const mergeArraysAtFirstKey = (arr, obj) => (
modify(head(keys(obj)),
concat(arr))
);I should have mentioned that this is just for illustration, I wanted to understand how exactly it works, so optimisations like that wouldn't work in my case.
I also didn't hope to get any answer after so long, since then for my case I also considered generators, but they have overhead and are slower when entire collection must be computed. What is the performance price of using transducers? They look a bit like generators, object that has a function. So I guess it could be same as generators.
I don't know if this is useful information, but I found an example where R.flatten() on an array of objects with a length property does not work as intended.
In this example, R.flatten(array) and array.flat() produce different results.
This behavior is probably due to the fact that in the implementation of _isArrayLike(), an object with a length property of 0 is considered an array.
(I found this while using CodeMirror; CodeMirror's Line object has a length property which signifies how many chars the Line has.)
if (x.length === 0) { return true; } there is specific case for such object which makes it array like so I guess it works as intended.
{0: 'a', length: 1} this is array like, same "array" with zero items should look like {length: 0}
https://ramdajs.com/repl/?v=0.28.0#?const%20m%20%3D%20new%20Map%28%29%3B%0A%0Am.set%28%27hello%27%2C%20%27world%27%29%3B%0A%0Aconst%20r%20%3D%20R.map%28%28e%29%3D%3E%20e%20%2B%20%27%21%27%2C%20%5B...m.entries%28%29%5D%29%3B%0A%2F%2F%20why%20not%20just%20const%20r%20%3D%20R.map%28%28e%29%3D%3E%20e%20%2B%20%27%21%27%2C%20m.entries%28%29%29%3B%0A
Hi, I would like to know how to make a check inside the pipelines to avoid the process to throw exception.
For example:
const isTypeDensity = R.propEq('type', 'density');
const getDensity = R.pipe(
R.find(isTypeDensity),
R.pick(['value', 'error', 'measureUnit'])
)
when I pass a null argument to getDenisty it will throw an error but also if i pass an empty array (or an array with all alements that don't match the predicate) will throw an error because R.pick will take a null value. How can i fix this issue?
with vanilla javascript i can easily do with something like this:
myArray?.find()?. etc..
thank you for the help.
you should somehow stop when find is undefined, there is no reason to do the pick at that point
const isTypeDensity = R.propEq('type', 'density');
const data = [{type: 'density', value: '1'}];
const wrongData = [{type: 'abc'}]
const density = //find(isTypeDensity, data);
find(isTypeDensity, wrongData);
const userPick = pick(['value', 'error', 'measureUnit']);
ifElse(identity, userPick, F)(density);so something like this works, I can't say that I like it.
it is also not clear what u want returned when it fails.
:point_up: Edit: you should somehow stop when find is undefined, there is no reason to do the pick at that point
const isTypeDensity = R.propEq('type', 'density');
const data = [{type: 'density', value: '1'}];
const wrongData = [{type: 'abc'}]
const density = //find(isTypeDensity, data);
find(isTypeDensity, wrongData);
const userPick = pick(['value', 'error', 'measureUnit']);
ifElse(identity, userPick, F)(density);
// or
when(identity, userPick)(density);so something like this works, I can't say that I like it.
it is also not clear what u want returned when it fails.
var data_array = [1, 2, 3,'hot', 4, 5, 6]
var D = x=> new Dataflow()
var data = D()
.filter(Number.isInteger)
.filter(x => x % 2)
.map(x => x * 2)
// these two filters and map get transduced automagically
.append('test')
.filter(x=> x>3)
.map(x => x * 2)
// filter + map = separate transducer
.prepend('maroon')
.compute(data_array)
// [ 'maroon', 5 ]
Hello everyone, I'm using Ramda with TS and can't get the mapping of objects to work:
const double = (x: number) => x * 2;
R.map(double, { aKey: 1 });Complains that no overload can be found:
No overload matches this call.
Overload 1 of 6, '(fn: (x: number) => number, list: readonly number[]): number[]', gave the following error.
Argument of type '{ aKey: number; }' is not assignable to parameter of type 'readonly number[]'.
Object literal may only specify known properties, and 'aKey' does not exist in type 'readonly number[]'.
Overload 2 of 6, '(fn: (x: number) => never, list: { aKey: number; }): unknown', gave the following error.
Argument of type '(x: number) => number' is not assignable to parameter of type '(x: number) => never'.
Type 'number' is not assignable to type 'never'.
Overload 3 of 6, '(fn: (x: number) => number, obj: Functor<number>): Functor<number>', gave the following error.
Argument of type '{ aKey: number; }' is not assignable to parameter of type 'Functor<number>'.
Property 'map' is missing in type '{ aKey: number; }' but required in type '{ [key: string]: any; map: <B>(fn: (a: number) => B) => Functor<B>; }'.ts(2769)
1 reply
hello, for guitar players I wanted to share a front-end project I made with ramda (and react): https://silently.github.io/cocotte/
this app iterates on the guitar fretboard to find playable chord voicing (see how ramda is used here for instance: https://github.com/silently/cocotte/blob/main/src/domain/processors/fingering.ts)
Thanks for ramda!
(if you have some feedback don't hesitate opening an issue on the project)
3 replies
Or should I misuse
ap with a one element array?const double = x => x*2;
const square = x => x*x;
R.whatever([double, square], 3) => // [6, 9]
I have a strange problem:
two functions, with difference in using assoc or dissoc, I d like to do something like
// this is just a simplified example
const k = 1;
const v = 2;
const obj = {};
const abstract = (f) => f(k,v obj)
const assocEr = abstract(assoc)
const dissocEr = abstract(dissoc)the problem is that dissoc and assoc take different number of arguments, and object is last argument, value is in the middle. Should I define my own functions to assoc/dissoc that would change order of arguments to (obj,k,v) ? Or just give up on abstracting these functions if they are like 2 lines of code anyway?
7 replies
Hi, why does transduce fail to work with reduce?
const reduceTransducer = R.compose(R.reduce((acc, x) => R.concat(acc, [x + 1]), []), R.take(2))
const mapTransducer = R.compose(R.map(x => x + 1), R.take(3))
R.transduce(reduceTransducer, R.flip(R.append), [], [1, 2, 3, 4]);
R.transduce(mapTransducer, R.flip(R.append), [], [1, 2, 3, 4]);Both transducer functions do the same thing, but the reduce variant throws reduce: list must be array or iterable. Can someone enlighten me? :D
map, promap, filter, and etc. "Acts as a transducer if a transformer is given in list position". But I wonder, can I make a reduce function transducable by hand? Is it possible, does it make sense to do? Because I can imagine having a reduce in the pipe/compose stack that I might want to it be transducable, I think. Also, is into a simpler alternative to transduce?
Hi, I was hoping to get some help with my ramda code with typescript. I am trying to use R.evolve, but am running into a strange type error in typescript that I am a bit confused by. Here is the code on the typescript playground: https://tsplay.dev/wOxApN
You should see the following error:
No overload matches this call.
The last overload gave the following error.
Type '<V extends Evolvable<{ [x: string]: (a: string) => unknown; }>>(obj: V) => Evolve<V, { [x: string]: (a: string) => unknown; }>' is not assignable to type '(list: readonly any[]) => any'.
Types of parameters 'obj' and 'list' are incompatible.
Type 'readonly any[]' is not assignable to type 'Evolvable<{ [x: string]: (a: string) => unknown; }>'.
Index signature for type 'string' is missing in type 'readonly any[]'.(2769)I'm not to sure where its getting the readonly any[] from.