Simple parser combinators (untested)

Parser.hs

newtype Parser t a = Parser{ runParser :: [t] -> Maybe (a, [t]) }
  deriving (Functor, Applicative, Alternative, Monad)
    via StateT [t] Maybe

parseToken :: (t -> Maybe a) -> Parser t a
parseToken f = Parser \case
  t:ts -> do
    x <- f t
    pure (x, ts)
  _    -> Nothing


token :: Parser t t
token = parseToken Just

readToken :: Read a => Parser String a
readToken = parseToken readMaybe

eat :: Eq t => t -> Parser t ()
eat t = parseToken \t' ->
  guard (t == t')


parseRecords :: String -> Maybe (String, CharacterClass, Int)
parseRecords line
  = fmap fst
  . flip runParser (words line)
  $ (,,) <$> (eat "Character:" *>     token)
         <*> (eat "Class:"     *> readToken)
         <*> (eat "Kills:"     *> readToken)