#13370: exprIsBottom inconsistent with strictness analyser -------------------------------------+------------------------------------- Reporter: simonpj | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by dfeuer): All this looks to me like a piece of a bigger puzzle we need to solve relating to strictness in the presence of: 1. Imprecise exceptions (which we have a whole paper about) 2. Precise exceptions (which I think we ''don't'' have a good story around at all--see #13380) 3. `catch` and friends. I had a (crazy?) thought last night. This may or may not make any sense at all, but it's driven by the fundamentally simple idea that ''precise'' exceptions should be modeled by something that looks vaguely similar to `ExceptT SomeException (State (State# RealWorld))`, but that fits into the `IO` type we're pretty much stuck with. Right now, `State# RealWorld` is terrifically boring for its entire life. But I don't know if it needs to be. Imagine if we had instead (very, very approximately) {{{#!hs data OK = OK State# RealWorld = (# OK | SomeException #) }}} where the "state of the real world" includes what precise exception (if any) we have encountered. Now we could talk about ''precise'' exceptions in Core in an entirely different fashion: {{{#!hs instance Monad IO where return x = IO $ \s -> (# s, x #) -- If the state has become exceptional, then performing additional -- actions is useless. m >>= f = IO $ \s -> case unIO m s of (# (# | e #), _ #) -> (# (# | e #), undefined #) (# s', r #) -> unIO (f r) s' throwIO e = IO $ \s -> (# (# | e #), undefined #) -- Function for catching only precise exceptions catchIO m f = IO $ \s -> case unIO m s of (# (# | e #), _ #) -> unIO (f e) realWorld# }}} Then `seq#` could take on the "magical" job of turning imprecise exceptions into precise ones, allowing us to implement `catch`. {{{#!hs catch# m f s = case seq# (m s) of (# (# | e #), _ #) -> f e realWorld# --Imprecise exception executing (m s) (# _, (# (# | e #), _ #) #) -> f e realWorld# --Precise exception executing (m s) (# _, res #) -> res }}} We'd need to perform some sort of magic in code generation to get rid of this wacky `State#` and implement exceptions in the usual fashion (I have no idea what that would look like myself). But in Core, I think we'd greatly confine the weirdness. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/13370#comment:3 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler