@amirbr Always is used basically to turn a value into a function to return that value.
R.filter(isEven, array) is evaluated at the time the function fn invoved, returning an Array. Then, after that, 0 is passed into R.cond([...]) at which point it starts checking the conditions.
R.equals(0)(0) is then evaluated, and returns true. As a result, the second item in the pair, R.filter(isEven, array), now evaluated to [2, 4], is retrieved as the function to invoke.
At that point, cond will try to call that function, actually an array, and return the error you experienced.
cond in this way. It's best case is to allow for lazy execution of the branches. In the general case if you pass in a function it will only be evaluated if its guard returns true. By pre-filltering the Array and wrapping the result in Always you force the function to be run every time fn is called regardless of whether the condition holds.
how i can replace neededAlternativeByRamda function by native Ramda function call or combination of calls ?
const neededAlternativeByRamda = (args, func) => arg => func(...args.map(a => (a === R.__ ? arg : a)))
// example of IRL usage
const newEditorState = R.pipe(
ContentState.createFromText,
neededAlternativeByRamda([editorState, R.__, 'change-block-data'], EditorState.push),
EditorState.moveSelectionToEnd
)(String(value))I need this for convenient inclusion in the pipe, for use argument that descent on this pipe to functions that have more wide signature that only one argument, and target argument will be placed in arbitrary order in total arguments (replaces R.__ from array of arguments that defined at call)
I think this is good idea and will look good
(2) [Array(2), Array(2)]
0: (2) ["["Bmw"]", "["Fiat"]"]
1: (2) ["{"locations":[{"label":"Toute la France"}]}", "{}"]
length: 2
__proto__: Array(0)
Hello, it may be foolish question, but what are the reason of making _arity and, consequently, _curryN accept functions that accept only up to 10 args?
From https://github.com/ramda/ramda/blob/master/source/internal/_arity.js :
default: throw new Error('First argument to _arity must be a non-negative integer no greater than ten');
Tips and advices are welcome 😉
1:11:03 AM - Found 0 errors. Watching for file changes.
-- Getting started --
⛔️ Test "map: double array" was not passed
TypeError: doubleArray is not a function
at Object.test (/home/women/projects/ramda-learning/prod/getting_started.js:18:24)
hi, i’m trying to figure out the best way to tackle this:
i have an object
{ firstName: 'Joe', lastName: 'Schmoe', age: 25, weight: 160 }
that I need to add another property to which combines a few properties into a new property and then adds that to the resulting object.
this is the last chain of a pipe:pipe(… , <my method>)
The best way I’ve come up with so far is to use converge with assoc and identity:pipe(… , converge( assoc('proposedLogin'), [ (s) => `${s.firstName}${s.lastName}${s.age}`, identity ] )
but i get the sense that there’s a better way that I’m not aware of
chain for this:// getProposedLogin :: Object -> String
const getProposedLogin = o(
join( '' ),
props( [ 'firstName', 'lastName', 'age' ] )
)
// addProposedLogin :: Object -> Object
const addProposedLogin = chain(
assoc('proposedLogin'),
getDerivedProperty
);
const pipeline = pipe(
…,
addProposedLogin
);ap and chain take up nicely the cases seemingly meant for converge, where there are just two functions and one of them is identity.
fold on an event/stream, I am lost.
eventStream.fold((acc, v) => [ ...acc, v ], [])const assocDerived = (name, f, obj) => ({
...obj,
[name]: f(obj),
})curry() ... I left it off for brevity)
chain instead.
I have been using a few functions from Ramda for a while but this is my first
time using transduce.
The sample is some data and code from a Ract app. There is a stripped-down
version of the React app at: https://codesandbox.io/s/data-with-ramda-38j7b
The code is building a table and applies formatting when a dataField has a formatFn property.
It is expected to process about 1,000 objects/rows, each with 14 properties and maybe 7 of them having a formatFn property.
It works as is but I am wondering if there is a better way to make use of Ramda to make the code more efficient?
Data
const data = [
{
_id: "1234",
date: "2020-01-23T08:00:00.000Z",
description: "ATM CHECK DEPOSIT",
debit: 0,
credit: 91.5,
omit: false
},
{
_id: "5678",
date: "2020-02-10T08:00:00.000Z",
description: "CHEVRON",
debit: -63.51,
credit: 0,
omit: true
}
];
const columns = ["_id", "date", "description", "credit", "debit", "omit"];
const dataFields = {
_id: {
name: "_id",
description: "Id"
},
date: {
name: "date",
description: "Date",
formatFn: d => `++${d}` // actual format is from date-fns
},
description: {
name: "description",
description: "Description"
},
credit: {
name: "credit",
description: "Credidt"
},
debit: {
name: "debit",
description: "Debit"
},
omit: {
name: "omit",
description: "Omit",
formatFn: d => (d ? "yes" : "no")
}
};Code
const modValues = (value, key, obj) => {
const column = dataFields[key];
if (has("formatFn")(column)) {
const { formatFn } = column;
return formatFn(value);
} else {
return value;
}
};
const _transform = map(mapObjIndexed(modValues));
transduce(_transform, flip(append), [], data);evolve function for performing the formatting of your object:map(evolve({
date: d => `++${d}`,
omit: d => (d ? "yes" : "no"),
// ... and whatever else
}))To expand a bit:
Transducers come with a certain amount of overhead. If you want to perform a number of operations on a list (map, filter, take, etc.) it will reduce the performance hit for the combined operations. In the case of functions like take it also has the benefit of stopping the whole composition, so there is no need to map over 1000 items if you just wanna take(5) at the end. The transducer will ensure you only process 5 items.
// Let's turn this into something `evolve` can use.
const dataFields = {
_id: {
name: "_id",
description: "Id"
},
date: {
name: "date",
description: "Date",
formatFn: d => `++${d}` // actual format is from date-fns
},
description: {
name: "description",
description: "Description"
},
credit: {
name: "credit",
description: "Credidt"
},
debit: {
name: "debit",
description: "Debit"
},
omit: {
name: "omit",
description: "Omit",
formatFn: d => (d ? "yes" : "no")
}
};
const evolver = filter(Boolean, map(prop('formatFn'), dataFields));
map(evolve(evolver))(data);