Haskell STM not giving output or deriving Show not giving any output

I am writing a telnet console in haskell with this code

module Main (main) where

import qualified Data.ByteString.Char8 as C

import Control.Concurrent (forkFinally)
import qualified Control.Exception as E
import Control.Monad (unless, forever, void)
import Control.Monad.STM (STM, atomically)
import Control.Concurrent.STM.TVar (TVar, newTVar, writeTVar, readTVar)

import qualified Data.ByteString as S
import Network.Socket (close, setSocketOption)
import Network.Socket (HostName)
import Network.Socket (ServiceName, AddrInfo)
import Network.Socket (Socket, SocketType(Stream))
import Network.Socket (addrFlags, getAddrInfo, gracefulClose, accept, listen, addrAddress, bind, setCloseOnExecIfNeeded, openSocket, withFdSocket, SocketOption(ReuseAddr))
import Network.Socket (addrSocketType, defaultHints, AddrInfoFlag(AI_PASSIVE))
import Network.Socket.ByteString (recv, sendAll)

data Störm = An | Aus deriving Show

someFunc :: IO ()
someFunc = runTCPServer Nothing "3000" (talk $ newTVar Aus)
  where
    talk :: STM (TVar Störm) -> Socket -> IO ()
    talk state' s = recv s 1024 >>= \msg -> unless (S.null msg) $
      case C.unpack msg of
        "exit\r\n" -> sendAll s (C.pack "Auf Widerhoren")
        "an\r\n" -> sendAll s (C.pack "Am An\n") >> putStrLn "Am An" >> write state' An >> talk state' s
        "aus\r\n" -> sendAll s (C.pack "Am Aus\n") >> putStrLn "Am Aus" >> write state' Aus >> talk state' s
        "anzeigen\r\n" -> sendAll s <$> (atomically $ C.pack <$> show <$> (state' >>= readTVar)) >> putStrLn "Am Anzeigen State" >> talk state' s
        otherwise -> sendAll s (C.pack "Unbekannte Befehl\n") >> putStrLn (show msg) >> (talk (state') s)
    write :: STM (TVar Störm) -> Störm -> IO ()
    write state new = atomically $ state >>= \s -> writeTVar s new

runTCPServer :: Maybe HostName -> ServiceName -> (Socket -> IO a) -> IO a
runTCPServer mhost port server = resolve >>= \addr -> (E.bracket (open addr) close loop)
  where
    resolve :: IO AddrInfo
    resolve = do
        let hints = defaultHints {
                addrFlags = [AI_PASSIVE]
              , addrSocketType = Stream
              }
        head <$> getAddrInfo (Just hints) mhost (Just port)

    open :: AddrInfo -> IO Socket
    open addr = E.bracketOnError (openSocket addr) close $ \sock -> do
        setSocketOption sock ReuseAddr 1
        withFdSocket sock setCloseOnExecIfNeeded
        bind sock $ addrAddress addr
        listen sock 1024
        return sock

    loop :: Socket -> IO b0
    loop sock = forever $ E.bracketOnError (accept sock) (close . fst)
        $ \(conn, _peer) -> void $
            -- 'forkFinally' alone is unlikely to fail thus leaking @conn@,
            -- but 'E.bracketOnError' above will be necessary if some
            -- non-atomic setups (e.g. spawning a subprocess to handle
            -- @conn@) before proper cleanup of @conn@ is your case
            forkFinally (server conn) (const $ gracefulClose conn 5000)

which uses the packages

base ^>=4.16.4.0
, network ^>=3.1.4.0
, bytestring
, stm

When connect to the telnet to the console from a telnet session, and run an or aus and then anzeigen or just directly the console not returns the corresponding An or Aus message to the telnet client but only an space, meanwhile I know that the case is being properly selected because the message Am Anzeigen State is being showed in the server's stdout.

I have not idea why this is happening.

The problem is that you're not sending anything.

In your "anzeigen" handler, you have this code (renaming partThatDoesntMatter = (atomically $ C.pack <$> show <$> (state' >>= readTVar))

sendAll s <$> partThatDoesntMatter >> putStrLn "Am Anzeigen State" 

This just an alternate spelling of

fmap (sendAll s) partThatDoesntMatter >> putStrLn "Am Anzeigen State"

You want to send something using sendAll here, but your fmap call here is just producing a sendAll action that never gets executed (and immediately discarded by the >> afterwards).

What you need here is

partThatDoesntMatter >>= sendAll s >> putStrLn "Am Anzeigen State"

Compare:

fmap :: (a -> b) -> m a -> m b
(>>=) :: m a -> (a -> m b) -> m b

applied to our example this is the difference between

sendAll s :: ByteString -> IO ()
partThatDoesntMatter :: IO ByteString
fmap (sendAll s) partThatDoesntMatter :: IO (IO ())
partThatDoesntMatter >>= sendAll s :: IO ()