Можно ли эмулировать поведение StateT без использования пользовательских типов?

Конечно, вы можете сделать всю сантехнику самостоятельно. Монады не добавляют ничего нового в Haskell, они просто позволяют повторно использовать массу кода и сокращать шаблоны. Так что все, что вы можете сделать с монадой, вы можете с трудом сделать вручную.

manyOperations :: Int -> IO ()
manyOperations n0 = do
    let n1 = n0 + 2
    print n1
    let n2 = n1 - 3
    print n2
    let n3 = n2 + 5
    print n3

Если количество повторений в приведенной выше функции слишком велико для вас (это для меня!), вы можете попытаться уменьшить его с помощью функции «комбинированных вычислений и печати», но на данный момент вы наклоняясь назад, чтобы избежать StateT.

-- a bad function, never write something like this!
printAndCompute :: a -> (a -> b) -> IO b
printAndCompute a f = let b = f a in print b >> return b

-- seriously, don't do this!
manyOperations n0 = do
    n1 <- printAndCompute (+2) n0
    n2 <- printAndCompute (-3) n1
    n3 <- printAndCompute (+5) n2
    return ()

Я не уверен, что это именно то, что вы ищете, но вы можете определить операцию, которая берет операцию с отслеживанием состояния, которая у вас уже есть, и распечатывает состояние после выполнения операции -

withPrint :: (Show s) => State s a -> StateT s IO a
withPrint operation = do
    s <- get
    let (a, t) = runState operation s
    liftIO (print t)
    put t
    return a

а затем сделать

manyOperations :: StateT Int IO ()
manyOperations = do
    withPrint (add 2)
    withPrint (subtract 3)
    withPrint (add 5)
    -- etc

Это не избегает использования StateT, но абстрагирует преобразование ваших обычных операций с состоянием, не связанных с вводом-выводом, в операции с полным вводом-выводом, поэтому вам не нужно беспокоиться о деталях (кроме добавления withPrint когда вы хотите, чтобы состояние было напечатано.

Если вы не хотите, чтобы состояние печаталось для конкретной операции, вы можете определить

withoutPrint :: State s a -> StateT s IO a
withoutPrint operation = do
    s <- get
    let (a, t) = runState operation s
    put t
    return a

что на самом деле эквивалентно

import Control.Monad.Morph

withoutPrint :: State s a -> StateT s IO a
withoutPrint = hoist (\(Identity a) -> return a)

используя hoist из Control.Monad.Morph для преобразования монады, лежащей в основе StateT, из Identity в IO.

Вы можете полностью избежать этих типов данных, используя s -> IO (a, s) напрямую, заменяя a и s соответствующим образом. Хотя это точно будет не так красиво.

Это будет выглядеть примерно так:

-- This makes StateIO s act as a shorthand for s -> IO (a, s)
type StateIO s a = s -> IO (a, s)

add :: Int -> StateIO Int ()
add n = \x -> print (x+n) >> return ((),x+n)

sub :: Int -> StateIO Int ()
sub n = \x -> print (x-n) >> return ((),x-n)

manyOperations :: StateIO Int ()
manyOperations =   -- Using the definition of (>>=) for StateT
  \s1 -> do        -- and removing a lambda that is immediately applied
      (a, s2) <- add 2 s1
      (a, s3) <- sub 3 s2
      add 5 s3

result :: IO ((), Int)
result = manyOperations 5

Состояние должно быть явно пропущено через все операции. Это главное преимущество, которое мы получаем от использования типа данных StateT: метод (>>=) его экземпляра Monad делает все это за нас! Однако из этого примера видно, что в StateT нет ничего волшебного. Это просто очень хороший способ абстрагироваться от потока состояния.

Кроме того, отношения между StateT и State противоположны отношениям между MaybeT и Maybe: State определяется в терминах StateT. Мы видим, что этот факт выражен в синоним этого типа:

type State s = StateT s Identity

Это преобразователь над Identity type (который имеет тривиальный экземпляр Monad).