planarian's questions

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.

Em Thinking Functionally with Haskell (p 45), Richard Bird diz que existem seis funções com type Maybe a -> Maybe a, embora ele cite apenas cinco.

Aplicado à Nothingfunção só pode retornar Nothingou undefined. Aplicado à Just xfunção só pode retornar Nothingou Just xou undefined. A questão é que não sabemos absolutamente nada sobre o tipo subjacente, portanto nenhum valor novo pode ser inventado. Isso perfaz seis funções possíveis ao todo.

Eu conto sete:

first, second, third, fourth, fifth, sixth, seventh :: Maybe a -> Maybe a

first (Just x) = Just x
second (Just x) = Nothing
third (Just x) = undefined
fourth Nothing = Nothing
fifth Nothing = undefined
sixth undefined = Nothing
seventh undefined = undefined

Um quebra-cabeça relacionado é que quando tento colocar três dessas definições em uma única função, recebo um erro de compilação "A correspondência de padrão é redundante". Remover qualquer uma das três linhas faz com que ela desapareça

foo :: Maybe a -> Maybe a
foo (Just x) = Nothing
foo Nothing = undefined
foo undefined = Nothing