Início / coding / Perguntas / 79549419
Accepted
planarian
Asked: 2025-04-02 08:29:03 +0800 CST

Como atualizações mais recentes na mônada de estado não são substituídas por atualizações anteriores?

  • 772

Aqui está a definição da mônada de estado do capítulo 13 de Learn You a Haskell

instance Monad (State s) where
    return x = State $ \s -> (x,s)
    (State h) >>= f = State $ \s -> let (a, newState) = h s
                                        (State g) = f a
                                    in  g newState

Com base nessa definição, parece-me que o estado na tupla retornada por f aserá substituído por newStatemesmo que seja a versão mais recente. Para pegar um exemplo específico do capítulo 10 do Real World Haskell, onde isso claramente não é o que os autores pretendem (observe o uso de em vez de porque eles ainda não introduziram formalmente as mônadas)==>>>=

parseByte :: Parse Word8
parseByte =
    getState ==> \initState ->
    case L.uncons (string initState) of
      Nothing ->
          bail "no more input"
      Just (byte,remainder) ->
          putState newState ==> \_ ->
          identity byte
        where newState = initState { string = remainder,
                                     offset = newOffset }
              newOffset = offset initState + 1

Onde

newtype Parse a = Parse {
      runParse :: ParseState -> Either String (a, ParseState)
    }

identity :: a -> Parse a
identity a = Parse (\s -> Right (a, s))
 
(==>) :: Parse a -> (a -> Parse b) -> Parse b
firstParser ==> secondParser  =  Parse chainedParser
  where chainedParser initState   =
          case runParse firstParser initState of
            Left errMessage ->
                Left errMessage
            Right (firstResult, newState) ->
                runParse (secondParser firstResult) newState

Em parseByte, não vejo como initStatenão substitui newState.

haskell

1 respostas

  1. Best Answer

    Dê uma outra olhada na definição:

    (State h) >>= f = State $ \s -> let (a, newState) = h s
                                    (State g) = f a
                                in  g newState

    A g newStatechamada não define o estado final para newState. Ela passa o newStatepara a segunda goperação como seu estado inicial . Se galterar o estado, o estado final da operação combinada será um novo estado sem nome retornado pela gchamada.

    Pode ajudar renomear algumas variáveis ​​e dar um nome temporário ao valor de retorno da gchamada. Ao fazer isso, você pode escrever isso como a implementação funcionalmente idêntica:

    (State op1) >>= f = State $ \firstState -> let (a, secondState) = op1 firstState
                                               (State op2) = f a
                                               (b, thirdState) = op2 secondState
                                           in (b, thirdState)

    Isso ajuda a explicar o que está acontecendo? No lado direito desta definição, a operação composta que é construída aplica a primeira operação op1 :: s -> (a, s)que pega o PRIMEIRO estado e produz um valor do tipo ae um SEGUNDO estado. Então, o valor do tipo apode ser passado para fpara calcular a segunda operação op2 :: s -> (b, s). Então, esta operação é passada para o SEGUNDO estado e produz um valor do tipo be um TERCEIRO estado. Então, o estado final será o TERCEIRO estado, depois de ter sido transformado por ambas as operações, em ordem.

    A ideia é a mesma para ==>. O initStateé passado para o chainedParser, mas a maneira como o chainedParserfunciona é que ele aplica o firstParserpara aquele initState, obtendo um newState, e então ele passa isso newStatepara o secondParser, que quando ele é executado por runParserretornará um estado final sem nome. Então, initStatee newStatesão o estado inicial e final respectivamente de firstParser, e newStatee algum "estado sem nome" são o estado inicial e final respectivamente de secondParser.

    • 5

relate perguntas