государственная монада haskell

Код, который вы предоставили, дает эту ошибку:

Couldn't match expected type `Double'
       against inferred type `m Double'
In the expression:
      get >>= \ s0 -> let (x, s1) = ... in put s1 >> return x
In the definition of `getAverage':
    getAverage s c = get >>= \ s0 -> let ... in put s1 >> return x

Все это означает, что тип, полученный из выражения («выведенный»), не согласуется с сигнатурой типа («ожидаемый»). В этом случае getAverage работает в монаде State, так что неверна сигнатура типа, поскольку она не может вычисляться как немонадный тип.

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

• getAverage имеет неиспользуемый параметр, который предположительно является значением в монаде State, что в любом случае не имеет смысла.
• Использование нотации do обычно понятнее, чем использование (>>=) и лямбда-выражений, особенно для чего-то вроде State.
• Отступ второй строки сбивает с толку, так как in идет с let, который находится внутри лямбды.

Внося эти изменения, мы имеем следующее:

getAverage s = do
    s0 <- get
    let (x, s1) = media s s0
    put s1 
    return x

… что облегчает обнаружение следующей ошибки: второй аргумент media представляет собой двойку, а s1 — всего лишь одно число, но вы пытаетесь использовать оба значения для значения состояния. Вероятно, вы хотели установить состояние (x, s1), но вернуть только x.

getAverage s = do
    s0 <- get
    let (x,s1) = media s s0
    put (x,s1)
    return x

Это компилируется просто отлично, но все еще нуждается в некоторой уборке:

• media необходимо обновить все значение состояния, поэтому вместо getting и putting просто используйте функцию modify.
• Возвращаемое значение — это первая часть значения состояния, поэтому просто fmapобъединить fst поверх get проще.

Итак, теперь у нас есть что-то вроде этого:

media :: Double -> MyState -> MyState
media s (a, n) = ((a * n + s) / (n + 1), n + 1)

getAverage:: Double -> State MyState Double
getAverage s = do
    modify (media s)
    fmap fst get

Мы также можем отметить, что getAverage делает две разные вещи и разделяет их на отдельные функции:

updateAverage:: Double -> State MyState ()
updateAverage s = modify (media s)

currentAverage :: State MyState Double
currentAverage = fmap fst get

getAverage:: Double -> State MyState Double
getAverage s = updateAverage s >> currentAverage

Редактировать: и поскольку я забыл о незначительной детали фактического получения результатов обратно из монады, замена updateAverage на getAverage в функции getAverages Трэвиса Брауна позволит ей работать с моим кодом выше.

Примечание: ответ camccann лучше моего, но мой использует немного другой подход и дает пример того, как оценивать монаду состояния, поэтому я оставляю его здесь для справки.

Мы можем начать пытаться выяснить проблему, удалив сигнатуру типа для getAverage и аргумент (c), который не появляется в функции:

getAverage s=get >>= \s0 -> let (x,s1) =media s s0
            in put s1 >> return x

Это все еще не компилируется, потому что мы пытаемся put что-то, что не имеет правильного типа: s1 это Double, а не MyState. Это легко поправимо:

getAverage s=get >>= \s0 -> let s1@(x,_) =media s s0
            in put s1 >> return x

Мы также можем оставить шаблон let без изменений и просто сказать put (x,s1): вместо этого я делаю это так, чтобы наш s1 имел тот же тип, что и s0.

Это компилируется, так что теперь мы можем исправить сигнатуру типа. Если мы запросим у GHCi тип, он вернет следующее:

getAverage :: (Fractional t, MonadState (t, t) m) => t -> m t

Double — это экземпляр Fractional, а State MyState — экземпляр MonadState (Double, Double), поэтому мы можем использовать что-то очень похожее на исходный тип для getAverage:

getAverage :: Double -> State MyState Double

Эта функция на самом деле не «получает» среднее значение: она обновляет его после добавления нового значения, поэтому давайте переименуем его соответствующим образом:

updateAverage :: Double -> State MyState Double
updateAverage s=get >>= \s0 -> let s1@(x,_) =media s s0
            in put s1 >> return x

Теперь мы можем определить функцию getAverages, которая берет список Double, пропускает их через updateAverage и возвращает список промежуточных средних значений на каждом шаге:

getAverages :: [Double] -> [Double]
getAverages ss = evalState (mapM updateAverage ss) (0, 0)

Это делает то, что мы ожидаем:

*Main> getAverages [1..10]
[1.0,1.5,2.0,2.5,3.0,3.5,4.0,4.5,5.0,5.5]

Обратите внимание: чтобы сделать что-нибудь полезное с монадой State, вам всегда придется использовать evalState (или тесно связанные runState и execState).