Now your consumers can write:

getSourceLoc assert :: String

And you will have a value that describes where you are. You can then use this to implement logging, throw errors etc. The annoying part is that you have to explicitly pass in assert from the call site to make sure that you get the right source location reported.

Yes, in fact the 'loch' package does this. Initially I thought that having a dummy argument on every single log call and throw (quite a few of those) would be too much hassle, but if I have to keep fixing the preprocessor I might start reconsidering. Another thing is that performance in logging is pretty critical. When I profile, logging functions wind up in the expensive list if I'm not careful. I don't know bad an unsafePerformIO plus a catch for every log msg is going to be, but it's not going to be as fast as doing the work at compile time.

On Thu, Jan 20, 2011 at 12:47 AM, Max Bolingbroke wrote:

On 19 January 2011 23:59, Evan Laforge wrote:

...

Another thing is that performance in logging is pretty critical.  When I profile, logging functions wind up in the expensive list if I'm not careful.  I don't know bad an unsafePerformIO plus a catch for every log msg is going to be, but it's not going to be as fast as doing the work at compile time.

It is possible that GHC's optimiser will let-float the "getSourceLoc assert" application to the top level, which would ensure that you only take the hit the first time. However, I'm not sure about this - do an experiment!

I don't read core very well, but with a simple example it appears it does, and I wind up with the unsafePerformIO stuff in a top level CAF of type String. However, when I switch to a more realistic example with an intermediary function, as in: warn assert msg = tell (getSourceLoc assert ++ msg) it looks like each call to 'warn' calls getSourceLoc as a function, so it should take the performance hit each time. So it might be possible to get this to work by embedding all logging logic into the second argument of 'catch' and being careful to check the core.

Since logging is in IO anyway, perhaps GHC could provide a new magic primitive, (location :: IO String), which was replaced by the compiler with an expression like (return "MyLocation:42:1"). Your consumer could then look like

Not necessarily! None of my logging or exceptions are in IO, so it wouldn't work for me. I still like the pragma...

On 20 January 2011 14:33, Bas van Dijk wrote:

On 20 January 2011 10:48, Evan Laforge wrote:

...

I still like the pragma...

Maybe Template Haskell can help:

module Location where

import Language.Haskell.TH import Data.Functor ((<$>))

loc :: Q Exp loc = LitE . StringL . show . loc_start <$> location

{-# LANGUAGE TemplateHaskell #-}

module Main where

import Location main = do  putStrLn $loc  putStrLn $loc  putStrLn $loc

*Main> main (7,12) (8,12) (9,12)

Regards,

Bas

You should also take a look at the control-monad-exception package which provides, among other things, support for exception call traces (with source locations). Take a look at the description to see an example: http://hackage.haskell.org/package/control-monad-exception Regards, Bas