Что делает команда put в типичной функции, использующей монаду состояния?

Я думаю, тебя смущает

(x, g') <- return $ random g

Это действительно создает новое монадическое действие State StdGen (a, StdGen), которое выполняется для извлечения его результата (a, StdGen).

Путаница возникает не без оснований, потому что код фактически эквивалентен

let (x, g') = random g

где не создается монадическое действие, что приводит к более прямому коду. Это преобразование верно для любой монады, а не только для State.

Во всяком случае, техническая часть: фрагмент (x, g') <- return $ random g означает

(x, g') <- State (\g'' -> (random g, g''))

где мы можем видеть, что монадическое действие принимает текущее состояние g'' (которое имеет то же значение, что и g), а затем не изменяет его (часть (..., g'')), возвращая вместе с ним сгенерированное значение random g (часть (random g, ...)).

Это немного глупо, поскольку нам даже не нужно читать g'', поскольку мы используем random g!

Итак, мы используем

do g       <- State (\g'' -> (g'', g''))
   (x, g') <- State (\g'' -> (random g, g''))
   ...

когда мы могли бы вместо этого использовать

do (x, g') <- State (\g'' -> (random g'', g''))
   ...

который вызывается в библиотеке

do (x, g') <- gets random
   ...

Ладно, похоже, что путаница в do put g' ; return x. Это сокращается в связной нотации следующим образом

{ definitions }
put g'   = State $ \s -> ((), g')
return x = State $ \s -> (x , s )

do put g ; return x 
= { definitions, desugaring }
   (State $ \s -> ((), g'))
   >>= 
   (\_ -> State $ \s -> (x , s ))
= { definition of >>= }
   State $ \s -> let (v,s') = (\s -> ((), g')) s 
                 in runState ((\_ -> State $ \s -> (x , s )) v) s'
= { beta-reduction (application) }
   State $ \s -> let (v,s') = ((), g')
                 in runState (State $ \s -> (x , s )) s'
= { beta-reduction (let) }
   State $ \s -> runState (State $ \s -> (x , s )) g'
= { runState (State y) = y }
   State $ \s -> (\s -> (x , s )) g'
= { beta-reduction }
   State $ \s -> (x , g')

Таким образом, эффект do put g' ; return x заключается в изменении состояния на g' (перезапись предыдущего s) и выдаче x в качестве окончательного значения вычисления (вместе с g').

Предположим, что наше состояние хранится в файле. Вот что делает getAny, как это выражено на языке, подобном Javascript / Python:

function getAny() {
  var g = readStateFromFile("some-path")  // the get call

  var xg  = random(g)    // returns an array with two elements
  var x = xg[0]
  var newg = xg[1]

  writeStateToFile("some-path", newg)  // same as the put function call
  return x
}

Здесь random(g) должен возвращать два значения, поэтому я хочу, чтобы он возвращал массив.

Теперь посмотрим, что происходит во время этой последовательности вызовов:

 a = getAny()       same as:    do a <- getAny
 b = getAny()                      b <- getAny
 c = getAny()                      c <- getAny

для a = getAny():

• состояние читается из файла
• он передается в random, который возвращает два значения
• второе значение записывается в файл
• первое значение возвращается и сохраняется в переменной a

а затем для b = getAny():

• состояние, только что записанное в файл, считывается обратно в
• он подается в random(), производя значение и новое состояние
• новое состояние записывается в файл
• новое значение возвращается и сохраняется в переменной b

и т.д...

Теперь отвечу на ваши вопросы:

что на самом деле делает put g?

Он обновляет состояние новым значением.

Почему бы на самом деле не потерять g?

newg - это просто локальная переменная, поэтому ее значение будет потеряно, если мы не сохраним его где-нибудь.