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?