- ghc-tickets - Haskell.org

[GHC] #16352: Hadrian: generation of PDF documents doesn't work
by GHC 22 Feb '19

22 Feb '19

#16352: Hadrian: generation of PDF documents doesn't work -------------------------------------+------------------------------------- Reporter: alpmestan | Owner: (none) Type: bug | Status: new Priority: high | Milestone: Component: Build System | Version: 8.7 (Hadrian) | Keywords: | Operating System: Linux Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- 1) With [https://github.com/alpmestan/ghc.nix ghc.nix] While trying to produce `_build/docs/pdfs/Haddock.pdf`: {{{ kpathsea: Running mktexmf pcrr8t ! I can't find file `pcrr8t'. <*> ...:=ljfour; mag:=1; nonstopmode; input pcrr8t Please type another input file name ! Emergency stop. <*> ...:=ljfour; mag:=1; nonstopmode; input pcrr8t Transcript written on mfput.log. grep: pcrr8t.log: No such file or directory }}} 2) With the CI docker images (e.g [https://gitlab.haskell.org/ghc/ghc/blob/master/.circleci/images/x86_64 -linux-deb8/Dockerfile this x86_64 debian8 one]) Agian, while trying to product the PDF version of the haddock manual: {{{ | Run Xelatex: Haddock.tex => /tmp/extra-dir-87721391039866 This is XeTeX, Version 3.14159265-2.6-0.99992 (TeX Live 2015/dev/Debian) (preloaded format=xelatex) restricted \write18 enabled. entering extended mode (./Haddock.tex LaTeX2e <2014/05/01> Babel <3.9l> and hyphenation patterns for 2 languages loaded. (./sphinxmanual.cls Document Class: sphinxmanual 2009/06/02 Document class (Sphinx manual) (/usr/share/texlive/texmf-dist/tex/latex/base/report.cls Document Class: report 2014/09/29 v1.4h Standard LaTeX document class (/usr/share/texlive/texmf-dist/tex/latex/base/size10.clo))) (/usr/share/texlive/texmf-dist/tex/latex/base/inputenc.sty Package inputenc Warning: inputenc package ignored with utf8 based engines. ) ! Undefined control sequence. <recently read> \DeclareUnicodeCharacter l.5 \DeclareUnicodeCharacter {00A0}{\nobreakspace} No pages of output. Transcript written on Haddock.log. }}} [https://tex.stackexchange.com/a/378643 This StackExchange post] that Matthew pointed me to gives a clue as to as why this happens. --- I am going to comment out the `need`s that make us produce these files in Hadrian when we ask for the docs, for now, leaving a comment pointing to this ticket. Then as we figure out solutions to these issues (especially 2), since that's GHC's CI system), we can put those PDFs back in and mark this ticket as solved. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/16352> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 0

[GHC] #16351: Extend constant folding operations to bit manipulations
by GHC 22 Feb '19

22 Feb '19

#16351: Extend constant folding operations to bit manipulations -------------------------------------+------------------------------------- Reporter: Fuuzetsu | Owner: (none) Type: feature | Status: new request | Priority: normal | Milestone: Component: Compiler | Version: 8.6.3 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: -------------------------------------+------------------------------------- In #9136 GHC has greatly improved how it folds expressions for Int/Word when the basic arithmetic operations {{{+, -, *}}} are involved. I think that somewhat analogously this extend should be extended to binary manipulation operations. For example, consider the below snippet: {{{#!hs {-# OPTIONS_GHC -O2 -ddump-simpl -ddump-to-file -ddump-asm #-} module G (bar, baz) where import Data.Bits ((.|.)) import Data.Word (Word16) bar :: Word16 -> Int bar w = -9223372036854775808 .|. (281474976710656 .|. fromIntegral w) baz :: Word16 -> Int baz w = -9223372036854775808 + (281474976710656 + fromIntegral w) }}} Let's peek into the Core: {{{#!hs bar = \ (w_a1hX :: Word16) -> case w_a1hX of { GHC.Word.W16# x#_a1Lu -> GHC.Types.I# (GHC.Prim.orI# -9223372036854775808# (GHC.Prim.orI# 281474976710656# (GHC.Prim.word2Int# x#_a1Lu))) } baz = \ (w_a1sr :: Word16) -> case w_a1sr of { GHC.Word.W16# x#_a1Lu -> GHC.Types.I# (GHC.Prim.+# -9223090561878065152# (GHC.Prim.word2Int# x#_a1Lu)) } }}} Due to #9136, {{{bar}}} gets nicely folded away into a single addition. {{{baz}}} however is still in its "naive" form. The above example was extracted from an actual program where there may be long such chains of {{{orI#}}} and similar operations. I think it's worth pointing out that if we peek in the ASM, {{{baz}}} seems to get folded away eventually but I don't trust it to always happen properly at that level and I don't particularly fancy trawling through the ASM output every time. https://stackoverflow.com/a/45909278 has some laws we could use. I'm sure we could pick in LLVM source &c. too if we want to. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/16351> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 3

[GHC] #14198: Inconsistent treatment of implicitly bound kind variables as free-floating
by GHC 21 Feb '19

21 Feb '19

#14198: Inconsistent treatment of implicitly bound kind variables as free-floating -------------------------------------+------------------------------------- Reporter: RyanGlScott | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.2.1 (Type checker) | Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: #7873 Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- (Spun off from the discussion starting at https://phabricator.haskell.org/D3872#109927.) This program is accepted: {{{#!hs {-# LANGUAGE ExistentialQuantification #-} {-# LANGUAGE PolyKinds #-} {-# LANGUAGE RankNTypes #-} import Data.Proxy data Foo = MkFoo (forall a. Proxy a) }}} There's something interesting going on here, however. Because `PolyKinds` is enabled, the kind of `a` is generalized to `k`. But where does `k` get quantified? It turns out that it's implicitly quantified as an existential type variable to `MkFoo`: {{{ λ> :i Foo data Foo = forall k. MkFoo (forall (a :: k). Proxy a) }}} This was brought up some time ago in #7873, where the conclusion was to keep this behavior. But to make things stranger, it you write out the kind of `a` explicitly: {{{#!hs {-# LANGUAGE ExistentialQuantification #-} {-# LANGUAGE PolyKinds #-} {-# LANGUAGE RankNTypes #-} import Data.Proxy data Foo2 = MkFoo2 (forall (a :: k). Proxy a) }}} Then GHC will reject it: {{{ Bug.hs:7:1: error: Kind variable ‘k’ is implicitly bound in data type ‘Foo2’, but does not appear as the kind of any of its type variables. Perhaps you meant to bind it (with TypeInType) explicitly somewhere? | 7 | data Foo2 = MkFoo2 (forall (a :: k). Proxy a) | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ }}} So GHC's treatment is inconsistent. What should GHC do? We could: * Have both be an error. * Have both be accepted, and implicitly quantify `k` as an existential type variable * Have both be accepted, and implicitly quantify `k` in the `forall` itself. That is: {{{#!hs MkFoo :: (forall {k} (a :: k). Proxy k a) -> Foo }}} * Something else. When you try a similar trick with type synonyms: {{{#!hs {-# LANGUAGE ExistentialQuantification #-} {-# LANGUAGE PolyKinds #-} {-# LANGUAGE RankNTypes #-} import Data.Proxy type Foo3 = forall a. Proxy a }}} Instead of generalizing the kind of `a`, its kind will default to `Any`: {{{ λ> :i Foo3 type Foo3 = forall (a :: GHC.Types.Any). Proxy a }}} Would that be an appropriate trick for data types as well? -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14198> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 11

[GHC] #15227: Add PrelRules for par#
by GHC 21 Feb '19

21 Feb '19

#15227: Add PrelRules for par# -------------------------------------+------------------------------------- Reporter: dfeuer | Owner: (none) Type: bug | Status: new Priority: low | Milestone: 8.6.1 Component: Compiler | Version: 8.4.3 Keywords: Newcomer | 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: -------------------------------------+------------------------------------- `seq#` and `spark#` are elided when their arguments are known to be evaluated. `par#`, however, is not. Presumably this leads to sparks being created and then immediately going away. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/15227> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 4

[GHC] #16140: Cannot create type synonym for quantified constraint without ImpredicativeTypes
by GHC 21 Feb '19

21 Feb '19

#16140: Cannot create type synonym for quantified constraint without ImpredicativeTypes -------------------------------------+------------------------------------- Reporter: Ashley | Owner: (none) Yakeley | Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.6.3 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: GHC rejects Unknown/Multiple | valid program Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- {{{#!hs {-# LANGUAGE KindSignatures, RankNTypes, ConstraintKinds, QuantifiedConstraints, FlexibleInstances, UndecidableInstances #-} module Bug where type F1 (f :: * -> *) = forall a. Eq (f a) class (Functor f, F1 f) => C f instance (Functor f, F1 f) => C f type F2 f = (Functor f, F1 f) }}} {{{ Bug.hs:7:1: error: • Illegal polymorphic type: F1 f GHC doesn't yet support impredicative polymorphism • In the type synonym declaration for ‘F2’ | 7 | type F2 f = (Functor f, F1 f) | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ }}} (GHC accepts the program with ImpredicativeTypes.) `(Functor f, F1 f)` is allowed as a superclass constraint, and as an instance constraint, but a type synonym cannot be made for it. Not sure if this really counts as a bug ("just switch on ImpredicativeTypes"), but I think it's worth discussing. I prefer to keep ImpredicativeTypes switched off, but if something can be a constraint, shouldn't I be able to create a type synonym of it? -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/16140> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 20

[GHC] #16141: StrictData and TypeFamilies regression
by GHC 20 Feb '19

20 Feb '19

#16141: StrictData and TypeFamilies regression -------------------------------------+------------------------------------- Reporter: RyanGlScott | Owner: (none) Type: bug | Status: new Priority: highest | Milestone: 8.8.1 Component: Compiler | Version: 8.6.3 (Type checker) | Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: GHC rejects Unknown/Multiple | valid program Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- The credit goes to wuzzeb for originally discovering this bug [https://www.reddit.com/r/haskell/comments/ad9a7k/strictdata_typefamilies_an… here]. I've minimized their test case slightly below: {{{#!hs {-# LANGUAGE StrictData #-} {-# LANGUAGE TypeFamilies #-} module Bug where data family T newtype instance T = MkT Int deriving Eq }}} With optimization enabled, this program compiles with GHC 8.0.2 through 8.4.4, but not with 8.6.3 or HEAD: {{{ $ /opt/ghc/8.4.4/bin/ghc -fforce-recomp -O Bug.hs [1 of 1] Compiling Bug ( Bug.hs, Bug.o ) $ /opt/ghc/8.6.3/bin/ghc -fforce-recomp -O Bug.hs [1 of 1] Compiling Bug ( Bug.hs, Bug.o ) Bug.hs:6:39: error: • Couldn't match a lifted type with an unlifted type arising from the coercion of the method ‘==’ from type ‘GHC.Prim.Int# -> GHC.Prim.Int# -> Bool’ to type ‘T -> T -> Bool’ • When deriving the instance for (Eq T) | 6 | newtype instance T = MkT Int deriving Eq | ^^ }}} Based on the error message, it appears as if GHC mistakenly believes that the representation type of the `T` instance is `Int#`, rather than `Int`. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/16141> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 13

[GHC] #12564: Type family in type pattern kind
by GHC 20 Feb '19

20 Feb '19

#12564: Type family in type pattern kind -------------------------------------+------------------------------------- Reporter: int-index | Owner: Type: bug | Status: new Priority: normal | Milestone: 8.2.1 Component: Compiler | Version: 8.0.1 (Type checker) | Keywords: TypeInType, | Operating System: Unknown/Multiple TypeFamilies | Architecture: | Type of failure: GHC rejects Unknown/Multiple | valid program Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- I want to write a type family that is analogous to `!!` for lists but requires the index to be no bigger than the length of the list. Usually, in dependently typed languages finite sets are used for this purpose, here's an attempt to do so in Haskell: {{{#!haskell {-# LANGUAGE TypeInType, TypeFamilies, GADTs, TypeOperators #-} import Data.Kind data N = Z | S N type family Len (xs :: [a]) :: N where Len '[] = Z Len (_ ': xs) = S (Len xs) data Fin :: N -> Type where FZ :: Fin (S n) FS :: Fin n -> Fin (S n) type family At (xs :: [a]) (i :: Fin (Len xs)) :: a where At (x ': _) FZ = x At (_ ': xs) (FS i) = At xs i }}} It fails to compile with this error: {{{ FinAt.hs:16:3: error: • Illegal type synonym family application in instance: 'FZ • In the equations for closed type family ‘At’ In the type family declaration for ‘At’ }}} That's because the kind of the `FZ` pattern (first clause of `At`) has the kind `Fin (Len xs)` and the application of `Len` cannot reduce completely. `checkValidTypePat` then disallows the pattern, as it contains a type family application. I tried to suppress `checkValidTypePat` and the definition of `At` has compiled; however, it's of little use, since `At` doesn't reduce: {{{#!haskell x :: At '[Bool] FZ x = True }}} results in {{{ FinAt.hs:20:5: error: • Couldn't match expected type ‘At * ((':) * Bool ('[] *)) ('FZ 'Z)’ with actual type ‘Bool’ • In the expression: True In an equation for ‘x’: x = True }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/12564> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 16

[GHC] #16345: Duplicated allocation
by GHC 20 Feb '19

20 Feb '19

#16345: Duplicated allocation -------------------------------------+------------------------------------- Reporter: simonpj | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.6.3 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 {{{ x = reverse "hello" y = x `seq` Just True f p = y `seq` (p, y) }}} You'd expect that we'd end up iwth {{{ f = \p -> case y of DEFAULT -> (p, y) }}} or just possibly {{{ f = \p -> case x of DEFAULT -> (p, y) }}} But we don't. We get {{{ Foo3.f = \ (@ a_a13D) (p_a13b [Occ=Once] :: a_a13D) -> case Foo3.x of { __DEFAULT -> (p_a13b, Just @ Bool True) } }}} Yikes. Look at that completely-wasted `Just True` allocation, which will happen in every call to `f`. There's nothing special about the top level here; this could happen for nested bindings too. The culprit is this code in `Simplify`: {{{ rebuildCase env scrut case_bndr alts cont | Just (wfloats, con, ty_args, other_args) <- exprIsConApp_maybe (getUnfoldingInRuleMatch env) scrut = do { case findAlt (DataAlt con) alts of Nothing -> missingAlt env case_bndr alts cont Just (DEFAULT, bs, rhs) -> let con_app = Var (dataConWorkId con) `mkTyApps` ty_args `mkApps` other_args in simple_rhs wfloats con_app bs rhs Just (_, bs, rhs) -> knownCon env scrut wfloats con ty_args other_args case_bndr bs rhs cont } }}} If we try to simplify {{{ case y of y' { DEFAULT -> (p, y') } }}} then `exprIsConApp_maybe` succeeds (with a floated case on `x`), effectively inlining `y` bodily, and we transform to {{{ case x of DEFAULT -> let y' = Just True in blah }}} Sigh. If making `exprIsConApp_maybe` to fire requires duplicating an allocation (here by inlining `y`), then perhaps we only want this `rebuildCase` transformation to fire if the case-binder `y'` is dead. What happens in the `knownCon` case? {{{ f = \p -> case y of y' Just t -> (y',p) Nothing -> (p,p) }}} Here we correctly inline `y`, cancel the `Just` and end up with {{{ f = \p -> case x of DEFAUT -> let y' = y in Just p }}} Where did that `y' = y` binding come from? Ah... the clever `bind_case_bndr` in `knownCon`. We should do something like this in the default case too. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/16345> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 1

[GHC] #16341: Standalone deriving for GADTs should avoid impossible cases
by GHC 20 Feb '19

20 Feb '19

#16341: Standalone deriving for GADTs should avoid impossible cases -------------------------------------+------------------------------------- Reporter: mnoonan | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.6.3 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: | https://ghc.haskell.org/trac/ghc/ticket/15398 Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- One solution to bringing recursion schemes to mutually-recursive types is to combine the different types into a single GADT `T`, parameterized by a tag type. To really make this ergonomic, it would be nice to be able to derive instances for individual tags. And this almost works! But not always: {{{#!hs {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE StandaloneDeriving #-} {-# OPTIONS_GHC -Wall -Werror -ddump-deriv #-} module M where data T = T -- no Show instance data Good a where A :: Good Int B :: T -> Good Char data Fine a where P :: Fine Int Q :: Fine Char data Bad a where X :: Bad Int Y :: T -> Bad Char instance Show (Good Int) where -- OK and warning-free show A = "A" deriving instance Show (Fine Int) -- OK, because of suppressed warnings deriving instance Show (Bad Int) -- Fails! }}} This fails with the error {{{ example.hs:25:1: error: • Could not deduce (Show T) arising from a use of ‘showsPrec’ from the context: Int ~ Char bound by a pattern with constructor: Y :: T -> Bad Char, in an equation for ‘showsPrec’ at example.hs:25:1-33 }}} The derived code is as follows: {{{ ==================== Derived instances ==================== Derived class instances: instance GHC.Show.Show (M.Bad GHC.Types.Int) where GHC.Show.showsPrec _ M.X = GHC.Show.showString "X" GHC.Show.showsPrec a_a1cf (M.Y b1_a1cg) = GHC.Show.showParen (a_a1cf GHC.Classes.>= 11) ((GHC.Base..) (GHC.Show.showString "Y ") (GHC.Show.showsPrec 11 b1_a1cg)) instance GHC.Show.Show (M.Fine GHC.Types.Int) where GHC.Show.showsPrec _ M.P = GHC.Show.showString "P" GHC.Show.showsPrec _ M.Q = GHC.Show.showString "Q" }}} Is there a way that the derived `Show` code for `Bad Int` could avoid emitting cases for `Bad Char` terms? A solution that worked even for a limited set of tags would be still be interesting; for example, restricting to situations where the GADT was indexed by a sum kind like `data K = Ix1 | Ix2 | ... | IxN`. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/16341> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 1

[GHC] #15833: Typed template haskell quote fails to typecheck when spliced due to an ambiguous type variable
by GHC 20 Feb '19

20 Feb '19

#15833: Typed template haskell quote fails to typecheck when spliced due to an ambiguous type variable -------------------------------------+------------------------------------- Reporter: mpickering | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.6.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: -------------------------------------+------------------------------------- It should be the case that a code value constructed using typed template haskell should never fail to type check when spliced. Running `ghc Test.hs` with the following two modules produces an error about an ambiguous type variable. https://gist.github.com/5890c14dda73da738d2041c7f677b786 {{{ {-# LANGUAGE TemplateHaskell #-} {-# OPTIONS_GHC -Wall #-} module Compiler where import Language.Haskell.TH data Operator = Scan | Join Operator Operator deriving Show queryJoin :: Operator queryJoin = Join Scan Scan type QTExp a = Q (TExp a) fix :: (a -> a) -> a fix f = let x = f x in x while :: Monoid m => QTExp (IO m -> IO m) -> QTExp (IO m) while b = [|| fix (\r -> whenM True ($$b r)) ||] whenM :: Monoid m => Bool -> m -> m whenM b act = if b then act else mempty execOp :: Monoid m => Operator -> QTExp (IO m) -> QTExp (IO m) execOp op yld = case op of Scan -> while [|| \r -> ($$(yld) >> r)||] Join left right -> execOp left (execOp right yld) runQuery :: QTExp (IO ()) runQuery = execOp (Join Scan Scan) ([|| return () ||]) }}} {{{ {-# LANGUAGE TemplateHaskell #-} {-# OPTIONS_GHC -ddump-splices #-} module Test where import qualified Compiler as C main :: IO () main = do $$(C.runQuery) }}} {{{ Test.hs:9:6: error: • Ambiguous type variable ‘a0’ arising from a use of ‘C.whenM’ prevents the constraint ‘(Monoid a0)’ from being solved. Relevant bindings include r_a5GX :: IO a0 (bound at Test.hs:9:6) Probable fix: use a type annotation to specify what ‘a0’ should be. These potential instances exist: instance Monoid a => Monoid (IO a) -- Defined in ‘GHC.Base’ instance Monoid Ordering -- Defined in ‘GHC.Base’ instance Semigroup a => Monoid (Maybe a) -- Defined in ‘GHC.Base’ ...plus 7 others (use -fprint-potential-instances to see them all) • In the expression: (C.whenM True) ((\ r_a5GY -> ((return ()) >> r_a5GY)) r_a5GX) In the first argument of ‘C.fix’, namely ‘(\ r_a5GX -> (C.whenM True) ((\ r_a5GY -> ((return ()) >> r_a5GY)) r_a5GX))’ In the first argument of ‘(>>)’, namely ‘(C.fix (\ r_a5GX -> (C.whenM True) ((\ r_a5GY -> ((return ()) >> r_a5GY)) r_a5GX)))’ | 9 | $$(C.runQuery) | }}} The generated code {{{ Test.hs:9:6-15: Splicing expression C.runQuery ======> C.fix (\ r_a5GV -> (C.whenM True) ((\ r_a5GW -> ((C.fix (\ r_a5GX -> (C.whenM True) ((\ r_a5GY -> ((return GHC.Tuple.()) >> r_a5GY)) r_a5GX))) >> r_a5GW)) r_a5GV)) }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/15833> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 5