up vote 12 down vote favorite

I have some datatypes along the line of

data Outer = Outer { _list :: [ Inner ] }
data Inner = Inner { _bool :: Bool }

using Control.Lens, I can access the _bool of the ith Inner (inside a 'State Outer' monad) like this

boolValue <- gets (^. list . to (!! i) . inner)

I would like to also be able to update this value with something like

list ^. (to (!! i)) ^. inner %= True

However (by my understanding), the 'to' function only creates a getter, not a true lens that can be used as either getter or setter.

So, how can I convert (!! i) into a lens that will allow me to update this field?

share|improve this question
up vote 15 down vote accepted

You can't* turn (!!) into any lens-like thing other than a Getter -- but there's a function to do this sort of thing: ix, for accessing things at indices. It's actually a Traversal, not a Lens -- which, here, just means that it can fail (if the index is out of bounds) -- but as long as the index is in the list, it'll work.

There's another problem, though -- (^.) is also an operator that's used exclusively for getting values. It's incompatible with e.g. (%=), which takes a lens-like thing as its first argument. And: (%=) is for mapping a function over the existing value; if you just want to set, you can use (.=). So you probably want something like:

list . ix i . inner .= True

* There actually is a function that can do this -- it's called upon -- but it uses wonderful evil black magic and you shouldn't use it, at least not for this (and probably not for any real code).

share|improve this answer
    
could you clarify what the difference is between ix and element? I've gone with Gabriel's element since it seems simpler, taking an Int instead of an Index. From the docs you linked, it seems ix is more general in what it allows - is it strictly more general? – ajp Jun 9 '13 at 6:21
    
I didn't think of element. It isn't exactly that one is more general than the other... ix is a type class that has a bunch of instances for indexing with particular index types (for example, lists with Int, Maps with their index type, functions with their domain). element takes any Traversable type and counts left-to-right with an Int index. In this case they happen to coïncide. – shachaf Jun 9 '13 at 6:58
    
I haven't tested it, but I would guess that ix is a bit more efficient for this particular case (mostly because I haven't figured out a way to make Indexing generate good code... :-( Someone else is welcome to try). It's also a somewhat ad-hoc class. – shachaf Jun 9 '13 at 7:02
up vote 7 down vote

Use element, which is a Traversal to the specified list element:

list . element i . inner %= True :: Outer -> Outer

If you want to get the list element you must do so using a Maybe since the list element might not be there:

myList :: Outer

myList ^? list . element i . inner :: Maybe Bool
share|improve this answer
    
Note that %= gives you a State action for modifying a state, i.e. ... :: State Outer (). (Also, I assume the question meant .= here.) – shachaf Jun 9 '13 at 5:41
    
Yeah, I mean %~, but I think your answer is better anyway. – Gabriel Gonzalez Jun 9 '13 at 15:26

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.