It's often not reasonable to switch to a pure FP language for one reason or another, as much as we would like to.
It's nice to use
pipe rather than method chaining, @MikaAK. Let me find an example featuring fromMaybe.
It's hard to use pipe in my situation maybe you can provide some guidance @davidchambers? I wasn't sure how to use it
const replaceIndex = curry((array, replacement, index) => set(lensIndex(index), replacement, array))
const replaceInArray = (findFn, array, replacement) => findIndex(findFn)
.map(replaceIndex(array, replacement))
// need fromMaybe(array.concat(replacement))
In general I have a hard time with things like this because I'm unsure of how to compose them together point free style when I have a requirement on args like that
Oh, I think I see what you're saying now. Replace the first occurrence if found, otherwise append to the input.
@ram-bot
// findIndex_ :: (a -> Boolean, Array a) -> Maybe Integer
const findIndex_ = (pred, xs) => {
const idx = R.findIndex(pred, xs);
return idx >= 0 ? S.Just(idx) : S.Nothing();
};
// f :: (a -> Boolean, a, Array a) -> Array a
const f = (pred, repl, xs) =>
S.maybe(R.append(repl, xs),
S.compose(R.set(R.__, repl, xs), R.lensIndex),
findIndex_(pred, xs));
[f(R.equals('baz'), 'quux', []),
f(R.equals('baz'), 'quux', ['foo']),
f(R.equals('baz'), 'quux', ['foo', 'bar']),
f(R.equals('baz'), 'quux', ['foo', 'bar', 'baz'])];
R.update
@ram-bot
// findIndex_ :: (a -> Boolean, Array a) -> Maybe Integer
const findIndex_ = (pred, xs) => {
const idx = R.findIndex(pred, xs);
return idx >= 0 ? S.Just(idx) : S.Nothing();
};
// f :: (a -> Boolean, a, Array a) -> Array a
const f = (pred, repl, xs) =>
S.maybe(R.append(repl, xs),
R.update(R.__, repl, xs),
findIndex_(pred, xs));
[f(R.equals('baz'), 'quux', []),
f(R.equals('baz'), 'quux', ['foo']),
f(R.equals('baz'), 'quux', ['foo', 'bar']),
f(R.equals('baz'), 'quux', ['foo', 'bar', 'baz'])];
Well I'm hanging around here more for sure, I learned a bunch already thanks guys
@ram-bot
// findIndex_ :: (a -> Boolean, Array a) -> Maybe Integer
const findIndex_ = (pred, xs) => {
const idx = R.findIndex(pred, xs);
return idx >= 0 ? S.Just(idx) : S.Nothing();
};
// f :: (a -> Boolean, a, Array a) -> Array a
const f = (pred, repl, xs) => {
const thunk =
S.maybe(() => R.append(repl, xs),
idx => () => R.update(idx, repl, xs),
findIndex_(pred, xs));
return thunk();
};
[f(R.equals('baz'), 'quux', []),
f(R.equals('baz'), 'quux', ['foo']),
f(R.equals('baz'), 'quux', ['foo', 'bar']),
f(R.equals('baz'), 'quux', ['foo', 'bar', 'baz'])];
The implementation is a bit less elegant, but this may be a price worth paying.
Is there a global way of disabling sanctuary's typecheck without doing the
const {create, env} = require('sanctuary') part ?
I can always import sanctuary and reexport it and then use my own "S" alias, but I'd prefer to use it without that
What is the point of having the typecheck with NODE_ENV=production ?
Most library disable warnings/check/errors on this flag (thinking about react)
some time ago I was collecting good articles here but then I stoped and instead i'm just tweeting :p
This question is well worth discussing, @jgoux. One thing to keep in mind is that type checking can be used to enforce invariants in one's programs which are particularly important in production. Type checking applications of
withdraw :: PositiveFiniteNumber -> BankAccount -> BankAccount may not be important during development, but would be crucial in production to prevent negative withdrawals (i.e. deposits).