О выборе места применения монадного параметра монадного преобразователя

Возьмем монадный преобразователь MaybeT:

newtype MaybeT m a = MaybeT { runMaybeT :: m (Maybe a) }

Я бы не ожидал другого определения, потому что Maybe — это просто своего рода блок с (необязательным) содержимым (типа a выше), так что же MaybeT может делать с параметром m, если не обертывать все Maybe в нем? Написание :: Maybe (m a) не имело бы смысла, поскольку это всего лишь тип someaction <$> theMaybe.

Но в других случаях мог быть и другой выбор.

Возьмем монадный преобразователь StateT, определяемый как

newtype StateT s m a = StateT { runStateT :: s -> m (a, s) }

Это определение, если я посмотрю на него в свете определения монады State (как это было бы, если бы оно не было определено поверх StateT через Identity, очевидно),

newtype State s a = State { runState :: s -> (a, s) }

кажется, соответствует интерпретации «функции a -> b как контейнера с содержимым b», именно так я изначально понял, что означает экземпляр Functor(->) r. Итак, справедливо: m оборачивает «содержимое» функции (т. е. «содержимое» вычислений с сохранением состояния).

Но это (или мне кажется!) совершенно отличается от случая MaybeT, где m охватывает не внутреннюю часть Maybe, которая есть a, а всю Maybe a.

Если бы StateT должен был напоминать MaybeT (в данном случае использование m для обертывания всего), это было бы так

newtype StateT' s m a = StateT' { runStateT' :: m (s -> (a,s)) }

По этому поводу приходят на ум некоторые мысли:

• Что в этом плохого?
• Если бы все было в порядке, разве такой преобразователь монады принес бы мало пользы?
• Что я вижу в этом неправильного, так это то, что он кажется слишком неограниченным в том смысле, что запуск такого монадного преобразователя поверх IO будет означать, что можно выбрать целое произвольное вычисление с состоянием s -> (a, s) из монады IO, тогда как если фактический StateT накладывается поверх IO, IO можно использовать только для получения нового sсостояния и результата a; но все же я не уверен, что полностью понимаю разницу.

И, наконец, что насчет этого?

newtype StateT'' s m a = StateT'' { runStateT'' :: s -> (m a,s) }

Это кажется немного бесполезным, потому что... такое ощущение, что вычисление с сохранением состояния не имеет смысла, потому что, опять же, в примере с m, являющимся IO, a будет происходить от IO, но... О, я действительно не понимаю.

Дело в том, что у меня есть опыт полезности StateT как такового, но я не очень понимаю причины, почему он полезен, и других альтернатив не было бы. Или они бы это сделали?