May 2018 - ghc-tickets

[GHC] #15174: got internal error when running a simple but computationally intensive loop
by GHC 22 May '18

22 May '18

#15174: got internal error when running a simple but computationally intensive loop -------------------------------+--------------------------------- Reporter: rgrover | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: 8.6.1 Component: GHCi | Version: 8.2.2 Keywords: | Operating System: Linux Architecture: ia64 | Type of failure: None/Unknown Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------+--------------------------------- Got the following on the GHCi prompt: {{{ λ> main <interactive>: internal error: Unable to commit 1048576 bytes of memory (GHC version 8.2.2 for x86_64_unknown_linux) Please report this as a GHC bug: http://www.haskell.org/ghc/reportabug Aborted (core dumped) }}} The program being run: {{{#!hs gaussian mean sigma x = exp (-0.5 * (x - mean) ^ 2 / sigma ^ 2) / (sigma * sqrt (2 * pi)) integrate :: (Double -> Double) -> (Double, Double) -> Double -> Double integrate f (low, high) step = step * sum values where xs = [low, low+step .. high] values = f <$> xs main = print $ integrate (gaussian 100 10) (-1 * 1e5, 1e5) 0.001 }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/15174> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 1

[GHC] #14722: Error message points to wrong location
by GHC 21 May '18

21 May '18

#14722: Error message points to wrong location -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: (none) Type: feature | Status: new request | Priority: normal | Milestone: Component: Compiler | Version: 8.5 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: Incorrect Unknown/Multiple | error/warning at compile-time Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- This rightly fails, but I have an issue with the error message. I think points to the visible type application eagerly.. rather than the type annotation `(f_xx :: ())`. {{{#!hs {-# Language RankNTypes, PolyKinds, GADTs, TypeApplications, ScopedTypeVariables #-} import Data.Kind newtype Limit :: (k -> Type) -> Type where Limit :: (forall xx. f xx) -> Limit f foo :: forall f a. Limit f -> f a foo (Limit (f_xx :: ())) = f_xx @a }}} gives {{{ $ ghci -ignore-dot-ghci /tmp/Test.hs GHCi, version 8.5.20180105: http://www.haskell.org/ghc/ :? for help [1 of 1] Compiling Main ( /tmp/Test.hs, interpreted ) /tmp/Test.hs:9:28: error: • Cannot apply expression of type ‘()’ to a visible type argument ‘a’ • In the expression: f_xx @a In an equation for ‘foo’: foo (Limit (f_xx :: ())) = f_xx @a | 9 | foo (Limit (f_xx :: ())) = f_xx @a | ^^^^^^^ Failed, no modules loaded. Prelude> }}} I would have expected: {{{ /tmp/Test.hs:9:13: error: • Couldn't match expected type ‘()’ with actual type ‘f xx0’ • When checking that the pattern signature: () fits the type of its context: forall (xx :: k1). f xx In the pattern: f_xx :: () In the pattern: Limit (f_xx :: ()) • Relevant bindings include foo :: Limit f -> f a (bound at /tmp/Test.hs:9:1) }}} Thoughts -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14722> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 3

[GHC] #14370: non-deferred typed hole despite -fdefer-typed-holes
by GHC 21 May '18

21 May '18

#14370: non-deferred typed hole despite -fdefer-typed-holes -------------------------------------+------------------------------------- Reporter: int-e | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.2.1 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: Incorrect Unknown/Multiple | error/warning at compile-time Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- Consider the following ghci session. {{{ GHCi, version 8.2.1: http://www.haskell.org/ghc/ :? for help Prelude> :set -fdefer-typed-holes -Wno-typed-holes Prelude> :set -fdefer-out-of-scope-variables -Wno-deferred-out-of-scope- variables Prelude> let x = [_]; y = [r] Prelude> (length x, length y) (1,1) Prelude> length [_] <interactive>:4:9: error: • Found hole: _ :: a0 Where: ‘a0’ is an ambiguous type variable • In the expression: _ In the first argument of ‘length’, namely ‘[_]’ In the expression: length [_] • Relevant bindings include it :: Int (bound at <interactive>:4:1) Prelude> length [r] 1 }}} Why does the `length [_]` expression produce a type error immediately instead of being deferred? (I've asked the same question in #14367 but this looks like a real bug.) -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14370> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 6

[GHC] #14325: Erroneous program emits no errors
by GHC 21 May '18

21 May '18

#14325: Erroneous program emits no errors -------------------------------------+------------------------------------- Reporter: simonpj | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.2.1 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- Consider this (which arose in #14323): {{{ class (a~b) => C a b foo :: C a b => a -> b foo x = x hm3 :: C (f b) b => b -> f b hm3 x = foo x }}} With GHC 8.2 it compiles without error, but it definitely has a type error; try `-ddump-simpl`: {{{ hm3 :: forall (f :: * -> *) b. C (f b) b => b -> f b [GblId, Arity=2, Str=<L,U><L,U>x] hm3 = \ (@ (f_a126 :: * -> *)) (@ b_a127) ($dC_a129 :: C (f_a126 b_a127) b_a127) _ [Occ=Dead] -> case GHC.Types.HEq_sc @ * @ * @ (f_a126 b_a127) @ b_a127 ($dC_a129 `cast` ((T14323.N:C[0] ; Data.Type.Equality.N:~[0] <*>_N) <f_a126 b_a127>_N <b_a127>_N :: (C (f_a126 b_a127) b_a127 :: Constraint) ~R# ((f_a126 b_a127 :: *) ~~ (b_a127 :: *) :: Constraint))) of cobox_a12p { __DEFAULT -> case Control.Exception.Base.typeError @ 'GHC.Types.LiftedRep @ (C b_a127 (f_a126 b_a127)) "T14323.hs:28:9: error:\n\ \ \\226\\128\\162 Could not deduce (C b (f b)) arising from a use of \\226\\128\\152foo\\226\\128\\153\n\ \ from the context: C (f b) b\n\ \ bound by the type signature for:\n\ \ hm3 :: forall (f :: * -> *) b. C (f b) b => b -> f b\n\ \ at T14323.hs:27:1-28\n\ \ \\226\\128\\162 In the expression: foo x\n\ \ In an equation for \\226\\128\\152hm3\\226\\128\\153: hm3 x = foo x\n\ \(deferred type error)"# of wild_00 { } } }}} Reason: bug in the error suppression logic in `TcErrors` -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14325> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 5

[GHC] #15172: Undecidable instances slip through
by GHC 21 May '18

21 May '18

#15172: Undecidable instances slip through -------------------------------------+------------------------------------- Reporter: simonpj | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: 8.6.1 Component: Compiler | Version: 8.2.2 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- Consider {{{ {-# LANGUAGE FlexibleInstances, TypeFamilies, ConstraintKinds #-} type family F a :: Constraint class C a where instance (F a) => C [[a]] where }}} This should be rejected because the `F a` constraint could expand to be arbitrarily large, depending on `F`. There's simply a missing check in `checkInstTermination`. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/15172> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 3

[GHC] #15170: GHC HEAD panic (dischargeFmv)
by GHC 21 May '18

21 May '18

#15170: GHC HEAD panic (dischargeFmv) -------------------------------------+------------------------------------- Reporter: RyanGlScott | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: 8.6.1 Component: Compiler | Version: 8.5 (Type checker) | Keywords: TypeInType | Operating System: Unknown/Multiple Architecture: | Type of failure: Compile-time Unknown/Multiple | crash or panic Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- The following program panics on GHC HEAD: {{{#!hs {-# LANGUAGE AllowAmbiguousTypes #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeFamilyDependencies #-} {-# LANGUAGE TypeInType #-} {-# LANGUAGE TypeOperators #-} module Bug where import Data.Kind import Data.Proxy data family Sing (a :: k) data SomeSing :: Type -> Type where SomeSing :: Sing (a :: k) -> SomeSing k class SingKind k where type Demote k = (r :: Type) | r -> k fromSing :: Sing (a :: k) -> Demote k toSing :: Demote k -> SomeSing k withSomeSing :: forall k r . SingKind k => Demote k -> (forall (a :: k). Sing a -> r) -> r withSomeSing x f = case toSing x of SomeSing x' -> f x' newtype instance Sing (f :: k1 ~> k2) = SLambda { applySing :: forall t. Sing t -> Sing (f @@ t) } instance (SingKind k1, SingKind k2) => SingKind (k1 ~> k2) where type Demote (k1 ~> k2) = Demote k1 -> Demote k2 fromSing sFun x = withSomeSing x (fromSing . applySing sFun) toSing = undefined data TyFun :: Type -> Type -> Type type a ~> b = TyFun a b -> Type infixr 0 ~> type family Apply (f :: k1 ~> k2) (x :: k1) :: k2 type f @@ x = Apply f x infixl 9 @@ dcomp :: forall (a :: Type) (b :: a ~> Type) (c :: forall (x :: a). Proxy x ~> b @@ x ~> Type) (f :: forall (x :: a) (y :: b @@ x). Proxy x ~> Proxy y ~> c @@ ('Proxy :: Proxy x) @@ y) (g :: forall (x :: a). Proxy x ~> b @@ x) (x :: a). SingKind (c @@ ('Proxy :: Proxy x) @@ (g @@ ('Proxy :: Proxy x))) => (forall (xx :: a) (yy :: b @@ xx). Sing (f @@ ('Proxy :: Proxy xx) @@ ('Proxy :: Proxy yy))) -> Sing g -> Sing a -> Demote (c @@ ('Proxy :: Proxy x) @@ (g @@ ('Proxy :: Proxy x))) dcomp _sf _ _ = undefined }}} {{{ $ /opt/ghc/head/bin/ghc Bug2.hs [1 of 1] Compiling Bug ( Bug2.hs, Bug2.o ) ghc: panic! (the 'impossible' happened) (GHC version 8.5.20180501 for x86_64-unknown-linux): dischargeFmv [D] _ {0}:: (Apply (f_a1ih[sk:2] xx_a1iA[tau:3] yy_a1iB[tau:3] |> Sym ((TyFun <Proxy xx_a1iA[tau:3]>_N ((TyFun (Proxy (Sym {co_a1jm}) (Coh <yy_a1iB[tau:3]>_N {co_a1jm}))_N (Sym {co_a1jB} ; (Apply (Sym {co_a1jm}) <*>_N (Coh ((Coh <s_a1jn[fmv:0]>_N ((TyFun (Sym {co_a1jm}) <*>_N)_N ->_N <*>_N) ; Sym {co_a1jA}) ; (Apply <Proxy xx_a1iA[tau:3]>_N ((TyFun (Sym {co_a1jm}) <*>_N)_N ->_N <*>_N) (Coh <c_a1ig[sk:2] xx_a1iA[tau:3]>_N (Sym ((TyFun <Proxy xx_a1iA[tau:3]>_N ((TyFun (Sym {co_a1jm}) <*>_N)_N ->_N <*>_N))_N ->_N <*>_N))) <'Proxy>_N)_N) (Sym ((TyFun (Sym {co_a1jm}) <*>_N)_N ->_N <*>_N))) (Coh <yy_a1iB[tau:3]>_N {co_a1jm}))_N))_N ->_N <*>_N))_N ->_N <*>_N)) 'Proxy :: (Proxy (yy_a1iB[tau:3] |> {co_a1jm}) ~> s_a1jp[fmv:0])) ~# (s_a1jQ[fmv:0] :: (Proxy (yy_a1iB[tau:3] |> {co_a1jm}) ~> s_a1jp[fmv:0])) Call stack: CallStack (from HasCallStack): callStackDoc, called at compiler/utils/Outputable.hs:1162:37 in ghc:Outputable pprPanic, called at compiler/typecheck/TcSMonad.hs:3047:25 in ghc:TcSMonad }}} On GHC 8.4.2, it simply throws an error: {{{ $ /opt/ghc/8.4.2/bin/ghci Bug2.hs GHCi, version 8.4.2: http://www.haskell.org/ghc/ :? for help Loaded GHCi configuration from /home/rgscott/.ghci [1 of 1] Compiling Bug ( Bug2.hs, interpreted ) Bug2.hs:53:71: error: • Expected kind ‘Apply b xx’, but ‘y’ has kind ‘b @@ x’ • In the first argument of ‘Proxy’, namely ‘y’ In the first argument of ‘(~>)’, namely ‘Proxy y’ In the second argument of ‘(~>)’, namely ‘Proxy y ~> c @@ ( 'Proxy :: Proxy x) @@ y’ | 53 | (f :: forall (x :: a) (y :: b @@ x). Proxy x ~> Proxy y ~> c @@ ('Proxy :: Proxy x) @@ y) | ^ }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/15170> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 6

[GHC] #15143: Passing an IO value through several functions results in program hanging.
by GHC 21 May '18

21 May '18

#15143: Passing an IO value through several functions results in program hanging. -------------------------------------+------------------------------------- Reporter: Burtannia | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: 8.6.1 Component: Compiler | Version: 8.4.2 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: Runtime Unknown/Multiple | performance bug Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- I came across this rather interesting bug while writing my dissertation. The following function takes an IO Obs and if it is an observable of time (ObsTime) it increments the contained Int. Otherwise it leaves it unchanged: {{{#!hs incTime :: IO Obs -> IO Obs incTime o = do obs <- o case obs of ObsTime t -> return $ ObsTime (t+1) _ -> o }}} The case for ObsTime works as expected however, the wildcard case gets progressively slower the more times a value is passed through. At 30 iterations I waited 10 seconds before aborting execution, the function had still not returned. This issue does not occur with the following change to the wildcard case: {{{#!hs _ -> return obs }}} This issue occurs both in GHCi and after compiling with GHC. I have attached a file with the necessary code to demonstrate the issue. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/15143> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 12

[GHC] #15171: Add HeapView functionality breaks validate (stage 0 ghc is 8.4.2)
by GHC 21 May '18

21 May '18

#15171: Add HeapView functionality breaks validate (stage 0 ghc is 8.4.2) -------------------------------------+------------------------------------- Reporter: jrp | Owner: (none) Type: bug | Status: new Priority: high | Milestone: 8.6.1 Component: Runtime | Version: 8.5 System | Keywords: | Operating System: Linux Architecture: x86_64 | Type of failure: Building GHC (amd64) | failed Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: https://phabricator.haskell.org/D3055| -------------------------------------+------------------------------------- {{{ "/opt/ghc/bin/ghc" -hisuf hi -osuf o -hcsuf hc -static -O0 -H64m -Wall -package-db libraries/bootstrapping.conf -this-unit-id mtl-2.2.2 -hide- all-packages -i -ilibraries/mtl/. -ilibraries/mtl/dist-boot/build -Ilibraries/mtl/dist-boot/build -ilibraries/mtl/dist-boot/build/./autogen -Ilibraries/mtl/dist-boot/build/./autogen -Ilibraries/mtl/. -optP- include -optPlibraries/mtl/dist-boot/build/./autogen/cabal_macros.h -package-id base-4.11.1.0 -package-id transformers-0.5.5.0 -Wall -fno- warn-unused-imports -fno-warn-warnings-deprecations -Wcompat -Wnoncanonical-monad-instances -Wnoncanonical-monadfail-instances -XHaskell2010 -no-user-package-db -rtsopts -fno-warn-deprecated-flags -odir libraries/mtl/dist-boot/build -hidir libraries/mtl/dist-boot/build -stubdir libraries/mtl/dist-boot/build -c libraries/mtl/./Control/Monad/RWS/Lazy.hs -o libraries/mtl/dist- boot/build/Control/Monad/RWS/Lazy.o libraries/ghc-heap/GHC/Exts/Heap.hs:119:48: error: • Couldn't match expected type ‘ByteArray#’ with actual type ‘Array# b0’ • In the first argument of ‘sizeofByteArray#’, namely ‘dat’ In the first argument of ‘I#’, namely ‘(sizeofByteArray# dat)’ In the first argument of ‘div’, namely ‘(I# (sizeofByteArray# dat))’ • Relevant bindings include dat :: Array# b0 (bound at libraries/ghc-heap/GHC/Exts/Heap.hs:115:18) | 119 | let nelems = (I# (sizeofByteArray# dat)) `div` wORD_SIZE | ^^^ libraries/ghc-heap/GHC/Exts/Heap.hs:121:47: error: • Couldn't match expected type ‘ByteArray#’ with actual type ‘Array# b0’ • In the first argument of ‘indexWordArray#’, namely ‘dat’ In the first argument of ‘W#’, namely ‘(indexWordArray# dat i)’ In the expression: W# (indexWordArray# dat i) • Relevant bindings include dat :: Array# b0 (bound at libraries/ghc-heap/GHC/Exts/Heap.hs:115:18) | 121 | rawWds = [W# (indexWordArray# dat i) | I# i <- [0.. end] ] | ^^^ libraries/ghc-heap/GHC/Exts/Heap.hs:122:43: error: • Couldn't match expected type ‘Array# a0’ with actual type ‘ByteArray#’ • In the first argument of ‘sizeofArray#’, namely ‘pointers’ In the first argument of ‘I#’, namely ‘(sizeofArray# pointers)’ In the expression: I# (sizeofArray# pointers) | 122 | pelems = I# (sizeofArray# pointers) | ^^^^^^^^ libraries/ghc-heap/GHC/Exts/Heap.hs:123:67: error: • Couldn't match expected type ‘Array# Any’ with actual type ‘ByteArray#’ • In the fourth argument of ‘Array’, namely ‘pointers’ In the second argument of ‘($)’, namely ‘Array 0 (pelems - 1) pelems pointers’ In the expression: amap' Box $ Array 0 (pelems - 1) pelems pointers | 123 | ptrList = amap' Box $ Array 0 (pelems - 1) pelems pointers | ^^^^^^^^ libraries/ghc-heap/ghc.mk:3: recipe for target 'libraries/ghc-heap/dist- boot/build/GHC/Exts/Heap.o' failed make[1]: *** [libraries/ghc-heap/dist-boot/build/GHC/Exts/Heap.o] Error 1 }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/15171> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 3

[GHC] #15127: Unbox around runRW#
by GHC 21 May '18

21 May '18

#15127: Unbox around runRW# -------------------------------------+------------------------------------- Reporter: dfeuer | Owner: (none) Type: bug | Status: new Priority: low | Milestone: 8.8.1 Component: Compiler | Version: 8.4.2 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: Runtime Unknown/Multiple | performance bug Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- Because `runRW#` inlines so late, we don't end up unboxing around it. For example, suppose we write {{{#!hs f x = runST $ do mar <- newArray 100 x unsafeFreeze mar }}} This will compile to something like {{{#!hs f x = case runRW# (\s -> case newArray# 100# x s of { (# s', mar #) -> case unsafeFreezeArray# mar s' of { (# s'', ar# #) -> (# s'', Array ar# #) }}) of (# _, ar #) -> ar }}} We generally want to pull the constructor application out of the `runRW#` argument: {{{#!hs f x = case runRW# (\s -> case newArray# 100# x s of { (# s', mar #) -> unsafeFreezeArray# mar s' }) of (# _, ar# #) -> Array ar# }}} This exposes the `Array` constructor to case-of-case. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/15127> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 1

[GHC] #10241: BlockedIndefinitelyOnMVar thrown to the thread which is not blocked indefinitely
by GHC 21 May '18

21 May '18

#10241: BlockedIndefinitelyOnMVar thrown to the thread which is not blocked indefinitely -------------------------------------+------------------------------------- Reporter: asukamirai | Owner: simonmar Type: bug | Status: new Priority: normal | Milestone: Component: Runtime | Version: 7.8.3 System | Operating System: Unknown/Multiple Keywords: | Type of failure: Incorrect result Architecture: x86_64 | at runtime (amd64) | Blocked By: Test Case: | Related Tickets: Blocking: | Differential Revisions: | -------------------------------------+------------------------------------- BlockedIndefinatelyOnMVar exception is thrown to the main thread in below source code although the thread is not blocked indefinitely. {{{#!hs module Main where import qualified Control.Concurrent.MVar as MV import qualified Control.Concurrent as CC import qualified Control.Exception as E main :: IO () main = do -- call this thread "threadA" mvar1 <- MV.newEmptyMVar :: IO (MV.MVar ()) mvar2 <- MV.newEmptyMVar :: IO (MV.MVar ()) _ <- CC.forkIO $ do -- call this thread "threadB" MV.takeMVar mvar1 `E.catch` errorHandler1 putStrLn "after error catch" CC.threadDelay 1000000 MV.putMVar mvar2 () putStrLn "after putMVar" MV.readMVar mvar2 `E.catch` errorHandler2 putStrLn "after readMVar" CC.threadDelay 5000000 where errorHandler1 :: E.BlockedIndefinitelyOnMVar -> IO () errorHandler1 e = putStrLn $ "errorHandler1 : " ++ show e errorHandler2 :: E.BlockedIndefinitelyOnMVar -> IO () errorHandler2 e = putStrLn $ "errorHandler2 : " ++ show e }}} Save above as "mvar.hs" and run by ghc as below. {{{ > runhaskell mvar.hs errorHandler1 : thread blocked indefinitely in an MVar operation errorHandler2 : thread blocked indefinitely in an MVar operation after error catch after readMVar after putMVar }}} BlockedIndefinitelyOnMVar thrown for mvar1 is correct. It will be caught by errorHandler1 and "threadB" can continue to put the value to mvar2. It means that "threadA" can wait for the value of mvar2 and it is not blocked indefinately. However, BlockedIndefinitelyOnMVar is thrown for mvar2 on "threadA" before "threadB" puts value to the mvar2. I think it is incorrect. ---- I tested another case that adding "CC.threadDelay 10000000" before "readMVar" as below. {{{#!hs module Main where import qualified Control.Concurrent.MVar as MV import qualified Control.Concurrent as CC import qualified Control.Exception as E main :: IO () main = do -- call this thread "threadA" mvar1 <- MV.newEmptyMVar :: IO (MV.MVar ()) mvar2 <- MV.newEmptyMVar :: IO (MV.MVar ()) _ <- CC.forkIO $ do -- call this thread "threadB" MV.takeMVar mvar1 `E.catch` errorHandler1 putStrLn "after error catch" CC.threadDelay 1000000 MV.putMVar mvar2 () putStrLn "after putMVar" CC.threadDelay 10000000 -- <-- this line is added MV.readMVar mvar2 `E.catch` errorHandler2 putStrLn "after readMVar" CC.threadDelay 5000000 where errorHandler1 :: E.BlockedIndefinitelyOnMVar -> IO () errorHandler1 e = putStrLn $ "errorHandler1 : " ++ show e errorHandler2 :: E.BlockedIndefinitelyOnMVar -> IO () errorHandler2 e = putStrLn $ "errorHandler2 : " ++ show e }}} And it will run correctly (BlockedIndefinitelyOnMVar is not thrown for mvar2). {{{ > runhaskell mvar.hs errorHandler1 : thread blocked indefinitely in an MVar operation after error catch after putMVar after readMVar }}} ---- I found this behavior is same on STM / BlockedIndefinitelyOnSTM. {{{#!hs module Main where import qualified Control.Concurrent.STM as STM import qualified Control.Concurrent as CC import qualified Control.Exception as E main :: IO () main = do tmv1 <- STM.newEmptyTMVarIO :: IO (STM.TMVar ()) tmv2 <- STM.newEmptyTMVarIO :: IO (STM.TMVar ()) _ <- CC.forkIO $ do STM.atomically (STM.takeTMVar tmv1) `E.catch` errorHandler1 putStrLn "after error catch" CC.threadDelay 1000000 STM.atomically $ STM.putTMVar tmv2 () putStrLn "after putTMVar" STM.atomically (STM.readTMVar tmv2) `E.catch` errorHandler2 putStrLn "after readTMVar" CC.threadDelay 5000000 where errorHandler1 :: E.BlockedIndefinitelyOnSTM -> IO () errorHandler1 e = putStrLn $ "errorHandler1 : " ++ show e errorHandler2 :: E.BlockedIndefinitelyOnSTM -> IO () errorHandler2 e = putStrLn $ "errorHandler2 : " ++ show e }}} {{{ > runhaskell stm.hs errorHandler1 : thread blocked indefinitely in an STM transaction errorHandler2 : thread blocked indefinitely in an STM transaction after error catch after readTMVar after putTMVar }}} ---- I tested this in below versions/OSs and got same result (exception thrown for mvar2/tmv2). ghc7.8.3 on Windows7 ghc7.8.3 on lubuntu14.04 on VirtualBox on Windows7 ghc7.8.4 on lubuntu14.04 on VirtualBox on Windows7 ghc7.10.1 on lubuntu14.04 on VirtualBox on Windows7 Similar report https://ghc.haskell.org/trac/ghc/ticket/8804 found but not the same. (In this case, the reference to the MVar is not weak) -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/10241> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 7