Estou escrevendo um servidor web simples em Haskell e colocando um pouco de log. Eu tenho algumas chamadas para uma função de registro em uma cadeia de IO >>= . Tudo parece um pouco manual. Existe uma maneira melhor / mais "Haskelish"?
log :: (Show a) => String -> a -> IO a
log label val = getCurrentTime >>= \time ->
putStrLn ("[" ++ show time ++ "] [" ++ label ++ "] " ++ (take maxLogLength $ show val)) >>
return val
handle :: Socket -> IO ()
handle conn = recv conn incomingBufferSize >>=
log "request" >>=
log "path" . extractPath . unpack >>=
response >>= log "response" >>=
send conn >>
close conn
A Programação Orientada a Aspectos é a abordagem usual para isso. Em java, você intercepta os métodos que deseja registrar. Para o desenvolvedor, parece que nada está acontecendo, mas toda vez que esse método é chamado, ele é registrado automaticamente.
Não tenho certeza se o idioma que você está usando é compatível com AOP, mas tenho certeza de que pode haver alguma maneira de implementar um sistema semelhante.
O registro em log é um caso de uso comum usado durante a apresentação do chamado Free monads , Freer monads e / ou Efeitos Extensíveis .
Em qualquer caso, a idéia básica é simples - em vez de fazer com que seu programa execute ações diretamente, seu programa produz uma estrutura de dados que descreve abstratamente as ações a serem executadas. A execução real dessas ações é adiada para um intérprete que interpreta a estrutura de dados.
Existem pelo menos duas maneiras pelas quais isso pode ser aplicado ao registro. O primeiro é especificando algum conjunto de operações explícitas de registro. Isso não é muito diferente do que você possui atualmente, exceto que a implementação das operações de log pode ser alterada, fornecendo um interpretador diferente. Por exemplo, você pode alterar para onde o log vai ou até mesmo eliminar o registro em log todos juntos (ou seja, implementar o log como um não operacional).
Outra maneira de aplicar isso é adicionar log à interpretação de certas operações. Se feito corretamente, o registro e a interpretação "real" da operação são completamente ortogonais. Isso é análogo à programação orientada a aspectos, que permite que códigos adicionais sejam "misturados" ao código principal.
Em vários idiomas, você pode implementar funções de log como decoradores. Isso pode valer a pena investigar, mas no processo me deparei com o pacote hslogger (documentation ).