I'm trying to understand how to use State in a function. I've avoided the topic for several years because State just never seemed very useful, but I figure it's time for me to figure it out: I have the following function
update :: (a -> (r,a)) -> Int -> [a] -> (r, [a]) update s 0 (a:as) = let (r,a') = s a in (r,a':as) update s i (a:as) = let (r,as') = update s (i-1) as in (r, a:as')
which updates a particular element of a list. Looking at it, I see two parts of the type signature that look like State types, which leads me to think of this:
update' :: State a r -> Int -> State [a] r
Which leads to me writing this:
update' s 0 = do (a:as) <- get let (r, a') = runState s a put (a':as) return r update' s i = do (a:as) <- get put as r <- update' s (i-1) as' <- get put (a:as') return r
Now, this just looks awful. The first half, the base condition, is actually "running" a State calculation. And the second half sets the state within the monad twice! I like the idea of using State because it simplifies the type. When I see (a -> (b,a)) I say "Wait a second, that's a State calculation, isn't it?" and then, hopefully, generalize. But I can't write that calculation nearly as concisely. How do I do this properly?