Советы по более элегантному коду с монадами?

Question

Я наконец понял, как использовать монады (не знаю, понимаю ли я их ...), но мой код никогда не бывает очень элегантным. Я полагаю, из-за недостатка контроля над тем, как все эти функции на Control.Monad могут реально помочь. Поэтому я подумал, что было бы неплохо попросить совета по этому вопросу в конкретном куске кода с использованием монады состояния.

Целью кода является вычисление многих видов случайных блужданий, и я пытаюсь это сделать перед чем-то более сложным. Проблема в том, что у меня есть два вычисления с сохранением состояния одновременно, и я хотел бы знать, как их составить с элегантностью:

1. Функция обновления генератора случайных чисел имеет тип Seed -> (DeltaPosition, Seed)
2. Функция, которая обновляет положение случайного бродяги, имеет тип DeltaPosition -> Position -> (Log, Position) (где Log - это просто какой-то способ сообщить мне, каково текущее положение бродяги).

Что я сделал, так это:

У меня есть функция для составления этих двух вычислений с состоянием:

composing :: (g -> (b, g)) -> (b -> s -> (v,s)) -> (s,g) -> (v, (s, g))
composing generate update (st1, gen1) = let (rnd, gen2) = generate gen1
                                            (val, st2)  = update rnd st1
                                        in (val, (st2, gen2))

и затем я превращаю его в функцию, которая составляет состояния:

stateComposed :: State g b -> (b -> State s v) -> State (s,g) v
stateComposed rndmizer updater = let generate = runState rndmizer
                                     update x = runState $ updater x
                                 in  State $ composing generate update 

И тогда у меня есть простейшая вещь, например, случайный бродяга, который просто суммирует случайное число с его текущей позицией:

update :: Double -> State Double Double
update x = State (\y -> let z = x+y
                        in  (z,z))

generate :: State StdGen Double
generate = State random

rolling1 = stateComposed generate update 

и функция для повторного выполнения:

rollingN 1 = liftM (:[]) rolling1
rollingN n = liftM2 (:) rolling1 rollings
    where rollings = rollingN (n-1) 

И потом, если я загрузлю это в ghci и запусту:

*Main> evalState (rollingN 5) (0,mkStdGen 0)
[0.9872770354820595,0.9882724161698186,1.9620425108498993,2.0923229488759123,2.296045158010918]

Я получаю то, что хочу, то есть список позиций, занимаемых случайным бродягой. Но ... я чувствую, что должен быть более элегантный способ сделать это. У меня два вопроса:

1. Могу ли я переписать эти функции более "монадным" способом, используя умные функции из Control.Monad?

2. Существует ли общая схема объединения таких состояний, которую можно использовать? Это как-то связано с монадными трансформаторами или чем-то в этом роде?

Answer 1

Обновление: я должен был упомянуть, что на самом деле есть гораздо более приятный способ сделать это, который не требует State или монад вообще:

takeStep :: (Double, StdGen) -> (Double, StdGen)
takeStep (p, g) = let (d, g') = random g in (p + d, g')

takeSteps n = take n . tail . map fst $ iterate takeStep (0, mkStdGen 0)

Он работает как нужно:

*Main> takeSteps 5
[0.9872770354820595,0.9882724161698186,1.9620425108498993,2.0923229488759123,2.296045158010918]

---

Если вы не привержены идее «составления» двух отдельных вычислений с состоянием, вы можете выполнить то же самое гораздо проще:

takeStep :: State (Double, StdGen) Double
takeStep = do
  (pos, gen) <- get
  let (delta, gen') = random gen
  let pos' = pos + delta
  put (pos', gen')
  return pos'

takeSteps n = evalState (replicateM n takeStep) (0, mkStdGen 0)

Это дает тот же результаткак ваш пример:

*Main> takeSteps 5
[0.9872770354820595,0.9882724161698186,1.9620425108498993,2.0923229488759123,2.296045158010918]

Этот подход (выполнение всех манипуляций с состоянием в одной монаде вместо того, чтобы пытаться составить State A и State B) кажется мне наиболее элегантным решением.

---

Обновление: чтобы ответить на ваш вопрос об использовании монадных преобразователей для укладки State монад: это, безусловно, возможно.Например, мы можем написать следующее:

update' :: (Monad m) => Double -> StateT Double m Double
update' x = StateT $ \y -> let z = x + y in return (z, z)

generate' :: (Monad m) => StateT StdGen m Double
generate' = StateT $ return . random

takeStep' :: StateT Double (State StdGen) Double
takeStep' = update' =<< lift generate'

takeSteps' n = evalState (evalStateT (replicateM n takeStep') 0) $ mkStdGen 0

Мы могли бы также выполнить укладку в обратном порядке.

Эта версия снова производит тот же вывод, но, на мой взгляд, неStateT версия немного понятнее.

Answer 2

Обычный способ составления 2 монад (и единственный способ для большинства монад) - с помощью монадных трансформаторов, но с разными State монадами у вас есть больше возможностей. Например: вы можете использовать эти функции:

leftState :: State a r -> State (a,b) r
leftState act = state $ \ ~(a,b) -> let
  (r,a') = runState act a
  in (r,(a',b))

rightState :: State b r -> State (a,b) r
rightState act = state $ \ ~(a,b) -> let
  (r,b') = runState act b
  in (r,(a,b'))