new function lensWhere

Can we have a function which uses a predicate to focus on an element in an array?

const lensWhere = (func) => R.lens(
  R.find(func),
  (focus, target) => R.update(R.findIndex(func, target), focus, target)
)

Example - https://goo.gl/eacsoa

[polytypic]

@CrossEye FYI, I just wrote a short section to the Partial Lenses documentation on a related topic: Myth: Partial Lenses are not lawful. Note that the section is a subsection of the On lens laws section.

[CrossEye]

@tusharmath:

Again, this behavior is a matter of the underlying implementation. It’s not clear what that behavior should be, I guess, but it’s easy enough to say that since our list is only three elements long, there can simply be no 120th element to focus on. And hence we can make the call that something like set doesn’t do anything in this case. (Of course, this does show that Put-Get fails here too, and perhaps we need to clean up that implementation.) But that’s not always clear. The 0th element might be more of an interesting case.

It would be easier to demonstrate the issue with an analog to lensPath/lensProp than with lensIndex, because those make missing structures easier to imagine. To make the case here, we can descend to sparse arrays (which Ramda generally does avoid, so it’s not quite clear how much it matters.):

const headLens = R.lensIndex(0);

const xs = [];
xs[1] = 'a';
xs[2] = 'b'

xs[0]; //=> undefined
R.set(headLens, 'foo', xs); //=> ['foo', 'a', 'b']

Even though this list does not have an element with index 0, the lens that focuses on that spot would allow us to do a set. Again, perhaps this is easier with lensPath:

set(lensPath(['foo', 'bar']), 10, {a: 1, b: 2}); //=> {a: 1, b: 2, foo: {bar: 10}}

My issue is that no conceivable implementation would allow us to do this sort of thing with an arbitrary predicate. Here we can create an element at index 0 or at path foo/bar, but we can’t create one that will satisfy an arbitrary predicate.

I think I picked the wrong issue to ease my way back into Ramda, because this is so clear in my head, but I’m having a hard time describing it. One more try:

const myLens = lensWhere(propEq('foo', 'bar'))
const foos1 = [{foo: 'qux'}, {foo: 'bar'}];
view(myLens, foos1); //=> {foo: 'bar'}
const foos2 = set(myLens, {foo: 'baz'}, foos1); //=> [{foo: 'qux'}, {foo: 'baz'}]
view(myLens, foos2); //=> undefined  // a failure of Put-Get

The problem is that the predicate is not about the structure of the container. It’s about the content of the value at the focus. And since that can change through lens invocations (one of the reasons for lenses, after all) we can’t count on this to function properly as a lens.