February 2019 - ghc-tickets

[GHC] #16278: Exhaustivity checking GADT with free variables
by GHC 04 Feb '19

04 Feb '19

#16278: Exhaustivity checking GADT with free variables -------------------------------------+------------------------------------- Reporter: andrewthad | 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 the following example: {{{#!hs {-# language DataKinds #-} {-# language TypeFamilies #-} {-# language GADTs #-} {-# language KindSignatures #-} {-# OPTIONS_GHC -Wall -fforce-recomp #-} module GadtException where import Data.Kind (Type) import GHC.Exts data Send = Send data SocketException :: Send -> Type where LocalShutdown :: SocketException 'Send OutOfMemory :: SocketException a someSocketException :: SocketException a someSocketException = OutOfMemory foo :: Int foo = case someSocketException :: SocketException Any of LocalShutdown -> 2 OutOfMemory -> 1 }}} In `foo`, GHC's exhaustivity checker requires a pattern match on `LocalShutdown`. However, `LocalShutdown` is not an inhabitant of `SocketException Any`. What I would really like is for this to go one step further. I shouldn't even need to write the type annotation. That is, with the above code otherwise unchanged, GHC should recognize that {{{#!hs foo :: Int foo = case someSocketException of OutOfMemory -> 1 }}} handles all possible cases. Since fully polymorphic type variables become `Any` at some point during typechecking, I would expect that if this worked with the `SocketException Any` type signature, it would work without it. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/16278> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 4

[GHC] #15185: Enum instance for IntX / WordX are inefficient
by GHC 04 Feb '19

04 Feb '19

#15185: Enum instance for IntX / WordX are inefficient -------------------------------------+------------------------------------- Reporter: guibou | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: 8.6.1 Component: Core | Version: 8.4.2 Libraries | 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: -------------------------------------+------------------------------------- The following factorial benchmark show high discrepancy in performance between `Int` and `Int64` (and similarly between `Word` and `Word64`) when using `product [1..n]` to compute factorial: {{{#!haskell {-# LANGUAGE TypeApplications #-} import Criterion.Main import Data.Int import Data.Word import Numeric.Natural fact :: Integral t => t -> t fact n = product [1..n] fact2 :: Integral t => t -> t fact2 n = go 1 n where go acc 1 = acc go acc n = go (acc * n) (n - 1) main :: IO () main = defaultMain [ bgroup "fact 20" [ bench "Int" $ whnf (fact @Int) 20 , bench "Word" $ whnf (fact @Word) 20 , bench "Int64" $ whnf (fact @Int64) 20 , bench "Word64" $ whnf (fact @Word64) 20 , bench "Integer" $ whnf (fact @Integer) 20 , bench "Natural" $ whnf (fact @Natural) 20 ] , bgroup "fact2 20" [ bench "Int" $ whnf (fact @Int) 20 , bench "Word" $ whnf (fact @Word) 20 , bench "Int64" $ whnf (fact @Int64) 20 , bench "Word64" $ whnf (fact @Word64) 20 , bench "Integer" $ whnf (fact @Integer) 20 , bench "Natural" $ whnf (fact @Natural) 20 ] ] }}} {{{ benchmarking fact 20/Int time 17.33 ns (17.22 ns .. 17.41 ns) 1.000 R² (1.000 R² .. 1.000 R²) mean 17.21 ns (17.16 ns .. 17.29 ns) std dev 222.4 ps (184.5 ps .. 282.3 ps) variance introduced by outliers: 15% (moderately inflated) benchmarking fact 20/Word time 17.25 ns (17.01 ns .. 17.63 ns) 0.999 R² (0.997 R² .. 1.000 R²) mean 17.19 ns (17.11 ns .. 17.36 ns) std dev 358.6 ps (199.4 ps .. 674.3 ps) variance introduced by outliers: 32% (moderately inflated) benchmarking fact 20/Int64 time 166.7 ns (165.4 ns .. 168.5 ns) 0.999 R² (0.997 R² .. 1.000 R²) mean 166.8 ns (166.0 ns .. 168.5 ns) std dev 4.077 ns (1.854 ns .. 6.592 ns) variance introduced by outliers: 35% (moderately inflated) benchmarking fact 20/Word64 time 560.5 ns (550.6 ns .. 575.0 ns) 0.995 R² (0.989 R² .. 1.000 R²) mean 556.5 ns (549.1 ns .. 575.9 ns) std dev 36.08 ns (9.195 ns .. 60.69 ns) variance introduced by outliers: 78% (severely inflated) benchmarking fact 20/Integer time 421.9 ns (419.8 ns .. 425.3 ns) 1.000 R² (0.999 R² .. 1.000 R²) mean 427.7 ns (425.5 ns .. 431.3 ns) std dev 9.238 ns (6.311 ns .. 16.19 ns) variance introduced by outliers: 28% (moderately inflated) benchmarking fact 20/Natural time 534.5 ns (532.6 ns .. 536.3 ns) 1.000 R² (1.000 R² .. 1.000 R²) mean 533.7 ns (532.6 ns .. 535.3 ns) std dev 4.535 ns (3.652 ns .. 6.226 ns) benchmarking fact2 20/Int time 17.14 ns (17.07 ns .. 17.23 ns) 1.000 R² (1.000 R² .. 1.000 R²) mean 17.15 ns (17.10 ns .. 17.24 ns) std dev 227.1 ps (167.4 ps .. 286.9 ps) variance introduced by outliers: 16% (moderately inflated) benchmarking fact2 20/Word time 16.93 ns (16.86 ns .. 17.02 ns) 1.000 R² (1.000 R² .. 1.000 R²) mean 16.90 ns (16.86 ns .. 16.95 ns) std dev 149.8 ps (107.4 ps .. 192.5 ps) benchmarking fact2 20/Int64 time 165.1 ns (164.6 ns .. 165.7 ns) 1.000 R² (1.000 R² .. 1.000 R²) mean 164.8 ns (164.5 ns .. 165.1 ns) std dev 1.033 ns (778.6 ps .. 1.363 ns) benchmarking fact2 20/Word64 time 545.3 ns (542.8 ns .. 547.9 ns) 1.000 R² (1.000 R² .. 1.000 R²) mean 543.6 ns (542.4 ns .. 545.2 ns) std dev 4.741 ns (3.736 ns .. 5.824 ns) benchmarking fact2 20/Integer time 419.1 ns (417.2 ns .. 421.1 ns) 1.000 R² (1.000 R² .. 1.000 R²) mean 418.2 ns (416.8 ns .. 420.2 ns) std dev 5.415 ns (4.094 ns .. 7.147 ns) variance introduced by outliers: 12% (moderately inflated) benchmarking fact2 20/Natural time 533.8 ns (532.2 ns .. 536.1 ns) 1.000 R² (1.000 R² .. 1.000 R²) mean 533.2 ns (532.1 ns .. 534.8 ns) std dev 4.428 ns (3.217 ns .. 5.741 ns) }}} In `fact`, `Int` and `Word` are efficient, `Int64` and `Word64` are respectively 10x and 20x slowers, when they should be identical on 64 bit platform. `Word64` is even slower than `Integer`! Replacing `fact` by a handwritten recursion, in `fact2` gives something more coherent where all the 64 bits types have roughly the same efficiency. I observed in the source code that `Int` and `Int64` are not implemented as type synonym. Using `-ddump-rule-firings`, I observed that a rule `fold/build` fired and removed the `fold` for the `Int` case, and not for the `Int64`, I don't understand much ;( This is not dramatic because most people will use `Int` instead of `Int64`, but it is a surprising behavior. I also observed that smaller integral (such as `Int8`, `Int16`, `Int32`) behaves as badly as `Int64`) and this is much more important because there is no other default and more efficient type synonym. Note that I'll be interested to provide a patch myself if mentored a bit. Especially, I'm thinking about merging the `Int` and `Int64` implementation (with respect to the architecture default word size). Tested on GHC 8.4.2 -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/15185> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 4

[GHC] #16283: StaticPointers pragma changes generated code even when the feature is not used
by GHC 04 Feb '19

04 Feb '19

#16283: StaticPointers pragma changes generated code even when the feature is not used -------------------------------------+------------------------------------- Reporter: osa1 | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 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: -------------------------------------+------------------------------------- Tried with GHC HEAD. Program: {{{ module Main where import Control.Concurrent import System.Mem nats :: [Int] nats = [0 .. ] main = do let z = nats !! 400 print z performGC threadDelay 1000000 print (nats !! 900) }}} Compile without any flags: {{{ ==================== Tidy Core ==================== 2019-02-04 09:16:26.121849511 UTC Result size of Tidy Core = {terms: 45, types: 26, coercions: 0, joins: 0/0} -- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0} $trModule1_r1zg :: GHC.Prim.Addr# [GblId, Caf=NoCafRefs, Unf=OtherCon []] $trModule1_r1zg = "main"# -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} $trModule2_r1zt :: GHC.Types.TrName [GblId, Caf=NoCafRefs, Unf=OtherCon []] $trModule2_r1zt = GHC.Types.TrNameS $trModule1_r1zg -- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0} $trModule3_r1zu :: GHC.Prim.Addr# [GblId, Caf=NoCafRefs, Unf=OtherCon []] $trModule3_r1zu = "Main"# -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} $trModule4_r1zv :: GHC.Types.TrName [GblId, Caf=NoCafRefs, Unf=OtherCon []] $trModule4_r1zv = GHC.Types.TrNameS $trModule3_r1zu -- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0} Main.$trModule :: GHC.Types.Module [GblId, Caf=NoCafRefs, Unf=OtherCon []] Main.$trModule = GHC.Types.Module $trModule2_r1zt $trModule4_r1zv -- RHS size: {terms: 4, types: 1, coercions: 0, joins: 0/0} nats :: [Int] [GblId] nats = enumFrom @ Int GHC.Enum.$fEnumInt (GHC.Types.I# 0#) -- RHS size: {terms: 22, types: 13, coercions: 0, joins: 0/0} main :: IO () [GblId] main = >> @ IO GHC.Base.$fMonadIO @ () @ () (print @ Int GHC.Show.$fShowInt (!! @ Int nats (GHC.Types.I# 400#))) (>> @ IO GHC.Base.$fMonadIO @ () @ () performGC (>> @ IO GHC.Base.$fMonadIO @ () @ () (threadDelay (GHC.Types.I# 1000000#)) (print @ Int GHC.Show.$fShowInt (!! @ Int nats (GHC.Types.I# 900#))))) -- RHS size: {terms: 2, types: 1, coercions: 0, joins: 0/0} :Main.main :: IO () [GblId] :Main.main = GHC.TopHandler.runMainIO @ () main }}} Compile with `-XStaticPointers`: {{{ ==================== Tidy Core ==================== 2019-02-04 09:16:35.678350955 UTC Result size of Tidy Core = {terms: 67, types: 42, coercions: 0, joins: 0/0} -- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0} $trModule1_r1zg :: GHC.Prim.Addr# [GblId, Caf=NoCafRefs, Unf=OtherCon []] $trModule1_r1zg = "main"# -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} $trModule2_r1zF :: GHC.Types.TrName [GblId, Caf=NoCafRefs, Unf=OtherCon []] $trModule2_r1zF = GHC.Types.TrNameS $trModule1_r1zg -- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0} $trModule3_r1zG :: GHC.Prim.Addr# [GblId, Caf=NoCafRefs, Unf=OtherCon []] $trModule3_r1zG = "Main"# -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} $trModule4_r1zH :: GHC.Types.TrName [GblId, Caf=NoCafRefs, Unf=OtherCon []] $trModule4_r1zH = GHC.Types.TrNameS $trModule3_r1zG -- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0} Main.$trModule :: GHC.Types.Module [GblId, Caf=NoCafRefs, Unf=OtherCon []] Main.$trModule = GHC.Types.Module $trModule2_r1zF $trModule4_r1zH -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} lvl_r1zI :: Int [GblId, Caf=NoCafRefs, Unf=OtherCon []] lvl_r1zI = GHC.Types.I# 0# -- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0} nats :: [Int] [GblId] nats = enumFrom @ Int GHC.Enum.$fEnumInt lvl_r1zI -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} lvl1_r1zJ :: Int [GblId, Caf=NoCafRefs, Unf=OtherCon []] lvl1_r1zJ = GHC.Types.I# 400# -- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0} lvl2_r1zK :: Int [GblId] lvl2_r1zK = !! @ Int nats lvl1_r1zJ -- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0} lvl3_r1zL :: IO () [GblId] lvl3_r1zL = print @ Int GHC.Show.$fShowInt lvl2_r1zK -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} lvl4_r1zM :: Int [GblId, Caf=NoCafRefs, Unf=OtherCon []] lvl4_r1zM = GHC.Types.I# 1000000# -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} lvl5_r1zN :: IO () [GblId] lvl5_r1zN = threadDelay lvl4_r1zM -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} lvl6_r1zO :: Int [GblId, Caf=NoCafRefs, Unf=OtherCon []] lvl6_r1zO = GHC.Types.I# 900# -- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0} lvl7_r1zP :: Int [GblId] lvl7_r1zP = !! @ Int nats lvl6_r1zO -- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0} lvl8_r1zQ :: IO () [GblId] lvl8_r1zQ = print @ Int GHC.Show.$fShowInt lvl7_r1zP -- RHS size: {terms: 4, types: 3, coercions: 0, joins: 0/0} lvl9_r1zR :: IO () [GblId] lvl9_r1zR = >> @ IO GHC.Base.$fMonadIO @ () @ () lvl5_r1zN lvl8_r1zQ -- RHS size: {terms: 4, types: 3, coercions: 0, joins: 0/0} lvl10_r1zS :: IO () [GblId] lvl10_r1zS = >> @ IO GHC.Base.$fMonadIO @ () @ () performGC lvl9_r1zR -- RHS size: {terms: 4, types: 3, coercions: 0, joins: 0/0} main :: IO () [GblId] main = >> @ IO GHC.Base.$fMonadIO @ () @ () lvl3_r1zL lvl10_r1zS -- RHS size: {terms: 2, types: 1, coercions: 0, joins: 0/0} :Main.main :: IO () [GblId] :Main.main = GHC.TopHandler.runMainIO @ () main }}} Diff: {{{ --- no_static_ptrs/GcStaticPointers.dump-simpl 2019-02-04 12:16:26.120066655 +0300 +++ static_ptrs/GcStaticPointers.dump-simpl 2019-02-04 12:16:35.675924328 +0300 @@ -1,9 +1,9 @@ ==================== Tidy Core ==================== -2019-02-04 09:16:26.121849511 UTC +2019-02-04 09:16:35.678350955 UTC Result size of Tidy Core - = {terms: 45, types: 26, coercions: 0, joins: 0/0} + = {terms: 67, types: 42, coercions: 0, joins: 0/0} -- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0} $trModule1_r1zg :: GHC.Prim.Addr# @@ -11,55 +11,91 @@ $trModule1_r1zg = "main"# -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} -$trModule2_r1zt :: GHC.Types.TrName +$trModule2_r1zF :: GHC.Types.TrName [GblId, Caf=NoCafRefs, Unf=OtherCon []] -$trModule2_r1zt = GHC.Types.TrNameS $trModule1_r1zg +$trModule2_r1zF = GHC.Types.TrNameS $trModule1_r1zg -- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0} -$trModule3_r1zu :: GHC.Prim.Addr# +$trModule3_r1zG :: GHC.Prim.Addr# [GblId, Caf=NoCafRefs, Unf=OtherCon []] -$trModule3_r1zu = "Main"# +$trModule3_r1zG = "Main"# -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} -$trModule4_r1zv :: GHC.Types.TrName +$trModule4_r1zH :: GHC.Types.TrName [GblId, Caf=NoCafRefs, Unf=OtherCon []] -$trModule4_r1zv = GHC.Types.TrNameS $trModule3_r1zu +$trModule4_r1zH = GHC.Types.TrNameS $trModule3_r1zG -- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0} Main.$trModule :: GHC.Types.Module [GblId, Caf=NoCafRefs, Unf=OtherCon []] -Main.$trModule = GHC.Types.Module $trModule2_r1zt $trModule4_r1zv +Main.$trModule = GHC.Types.Module $trModule2_r1zF $trModule4_r1zH --- RHS size: {terms: 4, types: 1, coercions: 0, joins: 0/0} +-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} +lvl_r1zI :: Int +[GblId, Caf=NoCafRefs, Unf=OtherCon []] +lvl_r1zI = GHC.Types.I# 0# + +-- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0} nats :: [Int] [GblId] -nats = enumFrom @ Int GHC.Enum.$fEnumInt (GHC.Types.I# 0#) +nats = enumFrom @ Int GHC.Enum.$fEnumInt lvl_r1zI + +-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} +lvl1_r1zJ :: Int +[GblId, Caf=NoCafRefs, Unf=OtherCon []] +lvl1_r1zJ = GHC.Types.I# 400# + +-- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0} +lvl2_r1zK :: Int +[GblId] +lvl2_r1zK = !! @ Int nats lvl1_r1zJ + +-- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0} +lvl3_r1zL :: IO () +[GblId] +lvl3_r1zL = print @ Int GHC.Show.$fShowInt lvl2_r1zK + +-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} +lvl4_r1zM :: Int +[GblId, Caf=NoCafRefs, Unf=OtherCon []] +lvl4_r1zM = GHC.Types.I# 1000000# + +-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} +lvl5_r1zN :: IO () +[GblId] +lvl5_r1zN = threadDelay lvl4_r1zM + +-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} +lvl6_r1zO :: Int +[GblId, Caf=NoCafRefs, Unf=OtherCon []] +lvl6_r1zO = GHC.Types.I# 900# + +-- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0} +lvl7_r1zP :: Int +[GblId] +lvl7_r1zP = !! @ Int nats lvl6_r1zO + +-- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0} +lvl8_r1zQ :: IO () +[GblId] +lvl8_r1zQ = print @ Int GHC.Show.$fShowInt lvl7_r1zP + +-- RHS size: {terms: 4, types: 3, coercions: 0, joins: 0/0} +lvl9_r1zR :: IO () +[GblId] +lvl9_r1zR + = >> @ IO GHC.Base.$fMonadIO @ () @ () lvl5_r1zN lvl8_r1zQ + +-- RHS size: {terms: 4, types: 3, coercions: 0, joins: 0/0} +lvl10_r1zS :: IO () +[GblId] +lvl10_r1zS + = >> @ IO GHC.Base.$fMonadIO @ () @ () performGC lvl9_r1zR --- RHS size: {terms: 22, types: 13, coercions: 0, joins: 0/0} +-- RHS size: {terms: 4, types: 3, coercions: 0, joins: 0/0} main :: IO () [GblId] -main - = >> - @ IO - GHC.Base.$fMonadIO - @ () - @ () - (print - @ Int GHC.Show.$fShowInt (!! @ Int nats (GHC.Types.I# 400#))) - (>> - @ IO - GHC.Base.$fMonadIO - @ () - @ () - performGC - (>> - @ IO - GHC.Base.$fMonadIO - @ () - @ () - (threadDelay (GHC.Types.I# 1000000#)) - (print - @ Int GHC.Show.$fShowInt (!! @ Int nats (GHC.Types.I# 900#))))) +main = >> @ IO GHC.Base.$fMonadIO @ () @ () lvl3_r1zL lvl10_r1zS -- RHS size: {terms: 2, types: 1, coercions: 0, joins: 0/0} :Main.main :: IO () }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/16283> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 2

[GHC] #9693: Reloading GHCi with Template Haskell names can panic GHC
by GHC 03 Feb '19

03 Feb '19

#9693: Reloading GHCi with Template Haskell names can panic GHC -------------------------------------+------------------------------------- Reporter: maxs | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.8.3 Keywords: | Operating System: Architecture: Unknown/Multiple | Unknown/Multiple Difficulty: Unknown | Type of failure: GHC Blocked By: | rejects valid program Related Tickets: | Test Case: | Blocking: | Differential Revisions: -------------------------------------+------------------------------------- First, load the following program into GHCi. '''Fun.hs''' {{{#!hs module Fun where import Language.Haskell.TH stuff = do -- let x = mkName "X" x <- newName "X" sequence $ [dataD (return []) x [] [ normalC x [] ] []] }}} '''thbug.hs''' {{{#!hs {-# LANGUAGE TemplateHaskell #-} import Fun stuff }}} Then comment out the newName, un comment the mkName and reload GHCi. {{{ ghc: panic! (the 'impossible' happened) (GHC version 7.8.3 for x86_64-apple-darwin): kcLookupKind APromotionErr RecDataConPE Please report this as a GHC bug: http://www.haskell.org/ghc/reportabug }}} It is important to note this is a valid program, if you then close GHCi and start it again with the modified file, it will load correctly. Reloading after attempting to compile the newName version will cause a panic. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/9693> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 11

[GHC] #11084: Some type families don't reduce with :kind!
by GHC 03 Feb '19

03 Feb '19

#11084: Some type families don't reduce with :kind! -------------------------------------+------------------------------------- Reporter: goldfire | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.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: -------------------------------------+------------------------------------- Sadly, I'm unable to reproduce this without `singletons`. :( Observe: {{{ > ghci GHCi, version 7.10.2: http://www.haskell.org/ghc/ :? for help Prelude> import Data.Promotion.Prelude -- singletons-2.0.1 Prelude Data.Promotion.Prelude> :kind! Lookup 'True '[ '(True, True) ] Lookup 'True '[ '(True, True) ] :: Maybe Bool = Data.Singletons.Prelude.List.Case_1628035408 'True 'True 'True '[] (Data.Singletons.Apply (Data.Singletons.Apply (:==$) 'True) 'True) Prelude Data.Promotion.Prelude> :kind! Lookup 'True '[ '(True, True) ] Lookup 'True '[ '(True, True) ] :: Maybe Bool = JustSym1 'True }}} Note that the exact same command run twice yields different results. I tried peeking at `-ddump-tc-trace` but got nothing of use. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/11084> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 2

[GHC] #16280: Update Latest page of User's Guide to GHC 8.6.3
by GHC 03 Feb '19

03 Feb '19

#16280: Update Latest page of User's Guide to GHC 8.6.3 -------------------------------------+------------------------------------- Reporter: wataru86 | Owner: (none) Type: task | 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: -------------------------------------+------------------------------------- Latest version of GHC is 8.6.3. However, latest page of User's Guide is 8.6.2(https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/index…. Please Update to GHC 8.6.3. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/16280> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 0

[GHC] #12001: RFC: Add pattern synonyms to base
by GHC 02 Feb '19

02 Feb '19

#12001: RFC: Add pattern synonyms to base -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: Type: feature | Status: new request | Priority: normal | Milestone: Component: | Version: 7.10.3 libraries/base | 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: -------------------------------------+------------------------------------- Since we have pattern synonyms it's worth considering if some belong in base: [https://hackage.haskell.org/package/lens-4.14/docs/Data-Complex-Lens.html Data.Complex.Lens] contains patterns that could be defined in base, here are some more suggestions: === Data.Array === {{{#!hs pattern ArrayIx :: Ix i => (i, i) -> [(i, e)] -> Array i e pattern ArrayIx low'high xs <- ((\arr -> (bounds arr, assocs arr)) -> (low'high, xs)) where ArrayIx low'high xs = array low'high xs }}} === Data.Bits === {{{#!hs pattern ZeroBits :: (Eq a, Bits a) => a pattern ZeroBits <- ((== zeroBits) -> True) where ZeroBits = zeroBits pattern BitSize :: Bits a => Int -> a pattern BitSize n <- (bitSizeMaybe -> Just n) pattern Signed :: Bits a => a pattern Signed <- (isSigned -> True) pattern Unsigned :: Bits a => a pattern Unsigned <- (isSigned -> False) pattern PopCount :: Bits a => Int -> a pattern PopCount n <- (popCount -> n) }}} === Data.Char === {{{#!hs pattern ControlChar :: Char pattern ControlChar <- (isControl -> True) pattern SpaceChar :: Char pattern SpaceChar <- (isSpace -> True) }}} === Data.Complex === {{{#!hs pattern Conjugate :: Num a => Complex a -> Complex a pattern Conjugate a <- (conjugate -> a) where Conjugate a = conjugate a pattern Polar :: RealFloat a => a -> a -> Complex a pattern Polar m theta <- (polar -> (m, theta)) where Polar m theta = mkPolar m theta -- See https://github.com/ekmett/lens/issues/653 pattern Real :: Num a => a -> Complex a pattern Real r <- r :+ _ where Real r = r :+ 0 pattern Imaginary :: Num a => a -> Complex a pattern Imaginary i <- _ :+ i where Imaginary i = 0 :+ i }}} === GHC.Float === {{{#!hs pattern NegativeZero :: RealFloat a => a pattern NegativeZero <- (isNegativeZero -> True) where NegativeZero = -0 pattern Denormalized :: RealFloat a => a pattern Denormalized <- (isDenormalized -> True) pattern NaN :: RealFloat a => a pattern NaN <- (isNaN -> True) where NaN = 0 / 0 -- How ever negative infinity is handled pattern Infinity :: RealFloat a => a pattern Infinity <- ((== 1 / 0) -> True) where Infinity = 1 / 0 }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/12001> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 16

[GHC] #16277: Make JUnit report stdout/stderr in more cases
by GHC 02 Feb '19

02 Feb '19

#16277: Make JUnit report stdout/stderr in more cases -------------------------------------+------------------------------------- Reporter: mpickering | Owner: (none) Type: task | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.6.3 Keywords: newcomer | 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 https://gitlab.haskell.org/ghc/ghc/merge_requests/210 we made a start to improve the junit output to also include stderr/stdout when appropriate. However, the patch only handles a few cases, it is reasonably straightforward to handle more cases but the refactoring was a bit more involved than I was prepared to do at the time. To find more places, look in `testlib.py` and grep for `failBecause`. There are examples such as `bad stderr` and `bad stdout` which would also benefit from reporting the stderr. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/16277> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 0

[GHC] #16240: Core visible conditional compilation/static definition/code selection based upon static key values
by GHC 02 Feb '19

02 Feb '19

#16240: Core visible conditional compilation/static definition/code selection based upon static key values -------------------------------------+------------------------------------- Reporter: carter | Owner: (none) Type: feature | Status: new request | Priority: normal | Milestone: Component: Compiler | Version: 8.7 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: -------------------------------------+------------------------------------- currently the way we write haskell code to handle multiple platforms or configurations use the C preprocessor (CPP) in traditional mode. there are several challenges with this 1) tooling dependency 2) not actually designed for haskell code 3) no compiler support for checking the syntax / name / type well- formedness of each alternative code fragment under the associated environment assumptions. Abstractly, CPP uses a mapping from Names to Maybe (Either String Integer) or something to that effect. theres two ways we could then treat a "HPP" design: 1) just like CPP traditional mode, its just splicing tokens together. a) One implication of this design choice would be that to be able to check/ parse the different combinations of compilation, you'd need to be able to enumerate the set of maps of key value pairs of interest, and then you'd roughly want to have each Module be actually a {{{ Map (Map String (Maybe (Either String Integer))) Module) }}} this would have some pretty obvious code blowup issues, at least if you wanted to full on type check each combination in full. 2) only allow "HPP" to work on valid syntactic units, eg expressions, right hand sides, patterns, top level definition, etc, and provide a magic primop or several that would look roughly like NOTE: it could also just be at the Haskell post type inference phase, not necessarily at core level {{{ DefinitionDispatchTermLevel :: [(Map String (Maybe (Either String Integer)) , CoreTerm)] -> --- set of all #if/else/ifdef etc conditionals? Map (String) (Maybe (Either String Integer)) -> -- actual CPP flag combination used CoreTerm -> --- actual term ghc / optimizer works with and manipulates CoreTerm }}} this sketched out constructor representation overlooks a few things, eg the ability to do interval predicates and various boolean algebra operations, which WOULD be expressible in a fully fleshed out approch to this, but i'm elliding to keep simple. i think approach (1) or something like it would have the benefit of mostly working "today" wrt how we use CPP, and checking/coverage could be done via some package level or module level enumeration of cpp value mappings that you wnat to be checked or even generated approach (2) adds a funny looking operation to core/haskell terms/types representation where you could carry around "alternative expressions" plus the "selected expression". and thus you could do some amount of syntax/type checking for those altnerative platforms? either way, this is just me jotting down some thoughts on this because its been discussed on and off for a while now as an eventual nice to have for ghc. Also quite a complicated design space! :) -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/16240> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 8

[GHC] #16255: Visible kind application defeats type family with higher-rank result kind
by GHC 01 Feb '19

01 Feb '19

#16255: Visible kind application defeats type family with higher-rank result kind -------------------------------------+------------------------------------- Reporter: RyanGlScott | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.7 (Type checker) | Keywords: | Operating System: Unknown/Multiple TypeApplications, TypeFamilies | Architecture: | Type of failure: GHC accepts Unknown/Multiple | invalid program Test Case: | Blocked By: Blocking: | Related Tickets: #15740 Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- After #15740, GHC now (correctly) rejects this program: {{{#!hs {-# LANGUAGE DataKinds #-} {-# LANGUAGE PolyKinds #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeFamilies #-} module Bug where import Data.Kind data SBool :: Bool -> Type type family F :: forall k. k -> Type where F = SBool }}} {{{ $ ~/Software/ghc5/inplace/bin/ghc-stage2 --interactive Bug.hs GHCi, version 8.7.20190115: https://www.haskell.org/ghc/ :? for help Loaded GHCi configuration from /home/rgscott/.ghci [1 of 1] Compiling Bug ( Bug.hs, interpreted ) Bug.hs:12:7: error: • Expected kind ‘forall k. k -> *’, but ‘SBool’ has kind ‘Bool -> *’ • In the type ‘SBool’ In the type family declaration for ‘F’ | 12 | F = SBool | ^^^^^ }}} However, there's a very simple way to circumvent this: add a visible kind application to `F`'s equation. {{{#!hs type family F :: forall k. k -> Type where F @Bool = SBool }}} If I understand things correctly, GHC shouldn't allow this. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/16255> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 7