May 2018 - ghc-tickets

[GHC] #13114: UniqSet definition seems shady
by GHC 13 Nov '18

13 Nov '18

#13114: UniqSet definition seems shady -------------------------------------+------------------------------------- Reporter: dfeuer | Owner: dfeuer Type: task | Status: new Priority: low | Milestone: 8.4.1 Component: Compiler | Version: 8.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: -------------------------------------+------------------------------------- Currently, {{{#!hs type UniqSet a = UniqFM a }}} The key invariant of `UniqSet` is expressed in the somewhat-poorly-named `Note [Unsound mapUniqSet]`, and not enforced by the types. It seems likely that the clean thing is {{{#!hs newtype UniqSet a = US (UniqFM a) }}} Unfortunately there's an awful lot of code using `UniqSet` and assuming it's the same as `UniqFM`. To make this work, we'd need to expand the `UniqSet` API somewhat and figure out what to do at use sites using it interchangeably with `UniqFM`. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/13114> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 3

[GHC] #15054: ghc internal error appeared in GHCI
by GHC 12 Nov '18

12 Nov '18

#15054: ghc internal error appeared in GHCI -------------------------------------+------------------------------------- Reporter: radrow | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: 8.6.1 Component: GHCi | Version: 8.2.2 Keywords: | Operating System: Unknown/Multiple Architecture: x86_64 | Type of failure: None/Unknown (amd64) | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- After playing with vectors in ghci I got following error: {{{ ghc: internal error: Unable to commit 1048576 bytes of memory }}} It happened randomly, on empty prompt while no query was being evaluated I am using latest version of GHC on Arch Linux Here is my whole session: {{{ >λ= import Criterion Criterion Criterion.IO.Printf Criterion.Main.Options Criterion.Report Criterion.Analysis Criterion.Internal Criterion.Measurement Criterion.Types Criterion.IO Criterion.Main Criterion.Monad >λ= import Criterion.Main >λ= import Data.Vector >λ= import Data.Vector as V >λ= main = default defaultConfig defaultMain defaultMainWith >λ= defaultMain [bench "TESTXD" $ whnf ([1..100000]!!) 9999] benchmarking TESTXD time 19.81 μs (19.66 μs .. 19.99 μs) 0.999 R² (0.999 R² .. 1.000 R²) mean 13.47 μs (12.93 μs .. 14.11 μs) std dev 853.8 ns (542.7 ns .. 1.249 μs) variance introduced by outliers: 65% (severely inflated) >λ= defaultMain [bench "TESTXD" $ whnf ([1..100000]!!) 9999] benchmarking TESTXD time 19.62 μs (19.39 μs .. 19.99 μs) 0.999 R² (0.998 R² .. 1.000 R²) mean 13.49 μs (12.85 μs .. 14.51 μs) std dev 1.154 μs (524.9 ns .. 1.704 μs) variance introduced by outliers: 77% (severely inflated) >λ= v = V.fromList [1..100000] Display all 192 possibilities? (y or n) V.! V.fold1M' V.indexed V.prescanl V.unsafeDrop V.!? V.fold1M'_ V.init V.prescanl' V.unsafeFreeze V.++ V.fold1M_ V.iscanl V.prescanr V.unsafeHead V.// V.foldM V.iscanl' V.prescanr' V.unsafeHeadM V.MVector V.foldM' V.iscanr V.product V.unsafeIndex V.Vector V.foldM'_ V.iscanr' V.replicate V.unsafeIndexM V.accum V.foldM_ V.iterateN V.replicateM V.unsafeInit V.accumulate V.foldl V.iterateNM V.reverse V.unsafeLast V.accumulate_ V.foldl' V.izipWith V.scanl V.unsafeLastM V.all V.foldl1 V.izipWith3 V.scanl' V.unsafeSlice V.and V.foldl1' V.izipWith4 V.scanl1 V.unsafeTail V.any V.foldr V.izipWith5 V.scanl1' V.unsafeTake V.backpermute V.foldr' V.izipWith6 V.scanr V.unsafeThaw V.break V.foldr1 V.izipWithM V.scanr' V.unsafeUpd V.concat V.foldr1' V.izipWithM_ V.scanr1 V.unsafeUpdate V.concatMap V.forM V.last V.scanr1' V.unsafeUpdate_ V.cons V.forM_ V.lastM V.sequence V.unstablePartition V.constructN V.force V.length V.sequence_ V.unzip V.constructrN V.freeze V.map V.singleton V.unzip3 V.convert V.fromList V.mapM V.slice V.unzip4 V.copy V.fromListN V.mapM_ V.snoc V.unzip5 V.create V.generate V.mapMaybe V.span V.unzip6 V.createT V.generateM V.maxIndex V.splitAt V.update V.drop V.head V.maxIndexBy V.sum V.update_ V.dropWhile V.headM V.maximum V.tail V.zip V.elem V.ifilter V.maximumBy V.take V.zip3 V.elemIndex V.ifoldM V.minIndex V.takeWhile V.zip4 V.elemIndices V.ifoldM' V.minIndexBy V.thaw V.zip5 V.empty V.ifoldM'_ V.minimum V.toList V.zip6 V.enumFromN V.ifoldM_ V.minimumBy V.unfoldr V.zipWith V.enumFromStepN V.ifoldl V.modify V.unfoldrM V.zipWith3 V.enumFromThenTo V.ifoldl' V.notElem V.unfoldrN V.zipWith4 V.enumFromTo V.ifoldr V.null V.unfoldrNM V.zipWith5 V.filter V.ifoldr' V.or V.uniq V.zipWith6 V.filterM V.imap V.partition V.unsafeAccum V.zipWithM V.find V.imapM V.postscanl V.unsafeAccumulate V.zipWithM_ V.findIndex V.imapM_ V.postscanl' V.unsafeAccumulate_ V.findIndices V.imapMaybe V.postscanr V.unsafeBackpermute V.fold1M V.indexM V.postscanr' V.unsafeCopy >λ= defaultMain [bench "TESTXD" $ whnf ([1..100000]!!) 9999, bench "TESTV" $ whnf (\x -> (V.!) v x)] <interactive>:8:93: error: parse error (possibly incorrect indentation or mismatched brackets) ] λ= defaultMain [bench "TESTXD" $ whnf ([1..100000]!!) 9999, bench "TESTV" $ whnf (\x -> (V.!) v x) <interactive>:9:74: error: • Couldn't match expected type ‘Benchmarkable’ with actual type ‘Int -> Benchmarkable’ • Probable cause: ‘whnf’ is applied to too few arguments In the second argument of ‘($)’, namely ‘whnf (\ x -> (!) v x)’ In the expression: bench "TESTV" $ whnf (\ x -> (!) v x) In the first argument of ‘defaultMain’, namely ‘[bench "TESTXD" $ whnf ([1 .. 100000] !!) 9999, >λ= defaultMain [bench "TESTXD" $ whnf ([1..100000]!!) 9999, bench "TESTV" $ whnf (\x -> (V.!) v x) 9999] benchmarking TESTXD time 20.61 μs (20.47 μs .. 20.80 μs) 0.999 R² (0.999 R² .. 1.000 R²) mean 14.41 μs (13.85 μs .. 14.88 μs) std dev 805.2 ns (588.3 ns .. 1.036 μs) variance introduced by outliers: 59% (severely inflated) benchmarking TESTV time 1.796 ms (1.768 ms .. 1.831 ms) 0.997 R² (0.995 R² .. 0.999 R²) mean 1.426 ms (1.367 ms .. 1.481 ms) std dev 153.6 μs (123.2 μs .. 190.1 μs) variance introduced by outliers: 69% (severely inflated) (V.!) >λ= >λ= (V.!) v 999 1000 >λ= (V.!) v 9999 10000 >λ= l = [1..100000]) <interactive>:13:16: error: parse error on input ‘)’ >λ= l = [1..100000] >λ= l !! 9999 10000 >λ= l !! 99999 100000 >λ= l !! 999999 *** Exception: Prelude.!!: index too large >λ= l = [1..10000000] >λ= l !! 999999 1000000 >λ= l !! 9999999 10000000 >λ= l !! 99999999 *** Exception: Prelude.!!: index too large >λ= sum l <interactive>:22:1: error: Ambiguous occurrence ‘sum’ It could refer to either ‘Data.Vector.sum’, imported from ‘Data.Vector’ or ‘Prelude.sum’, imported from ‘Prelude’ (and originally defined in ‘Data.Foldable’) >λ= Prelude.sum l 50000005000000 >λ= Prelude.sum l 50000005000000 >λ= v = V.fr V.freeze V.fromList V.fromListN >λ= v = V.fromList l >λ= V.last v 10000000 >λ= :sprint v v = _ Display all 1088 possibilities? (y or n) >λ= V.sum v 50000005000000 >λ= V.sum v 50000005000000 >λ= V.last v 10000000 >λ= relast l read readIO readLn reads realToFrac rem replicate return readFile readList readParen readsPrec recip repeat replicateM reverse >λ= Prelude.last l 10000000 >λ= Prelude.last l 10000000 >λ= V.last v 10000000 >λ= :t (//) (//) :: Vector a -> [(Int, a)] -> Vector a >λ= :t v v :: (Enum a, Num a) => Vector a >λ= l = [1..10000000] :: [Int] >λ= last l <interactive>:37:1: error: Ambiguous occurrence ‘last’ It could refer to either ‘Data.Vector.last’, imported from ‘Data.Vector’ or ‘Prelude.last’, imported from ‘Prelude’ (and originally defined in ‘GHC.List’) >λ= import Prelude as P >λ= P.last l 10000000 >λ= v = from fromEnum fromInteger fromIntegral fromList fromListN fromRational >λ= v = fromList l >λ= :t v v :: Vector Int >λ= V.last v 10000000 >λ= V.last v 10000000 >λ= V.last v 10000000 >λ= v = fromList l >λ= P.last l 10000000 >λ= P.last l 10000000 >λ= V.last v 10000000 >λ= V.last v 10000000 >λ= V.last v 10000000 >λ= P.last l 10000000 >λ= P.last l 10000000 >λ= l = [1..100000000] :: [Int] >λ= v = fromList l >λ= P.last l 100000000 >λ= V.last v 100000000 >λ= V.last v 100000000 >λ= :t v v :: Vector Int >λ= :t v v :: Vector Int >λ= :sprint v v = Data.Vector.Vector 0 100000000 _ >λ= ghc: 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 [1] 12349 killed stack ghci }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/15054> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 7

[GHC] #11647: GHCi does not honour implicit `module Main (main) where` for re-exported `main`s
by GHC 11 Nov '18

11 Nov '18

#11647: GHCi does not honour implicit `module Main (main) where` for re-exported `main`s -------------------------------------+------------------------------------- Reporter: hvr | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: GHCi | Version: 7.10.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: -------------------------------------+------------------------------------- Haskell2010 states: > An abbreviated form of module, consisting only of the module body, is permitted. If this is used, the header is assumed to be `module Main(main) where`. Consider the following two modules: {{{#!hs -- module Main (main) where import Main2 (main) }}} {{{#!hs module Main2 (main) where main :: IO () main = return () }}} A non-interactive GHC happily compiles `ghc --make Main`, however, GHCi fails with {{{ $ ghci Main.hs GHCi, version 7.10.3: http://www.haskell.org/ghc/ :? for help unknown option: 'c' [1 of 2] Compiling Main2 ( Main2.hs, interpreted ) [2 of 2] Compiling Main ( Main.hs, interpreted ) Main.hs:1:1: The IO action ‘main’ is not exported by module ‘Main’ Failed, modules loaded: Main2. }}} For GHCi we need to uncomment the explicit `module Main (main) where` line to make it work. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/11647> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 6

[GHC] #9692: Template Haskell reification for Data Families is buggy?
by GHC 08 Nov '18

08 Nov '18

#9692: Template Haskell reification for Data Families is buggy? -------------------------------------+------------------------------------- Reporter: hpacheco | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.8.3 Keywords: TemplateHaskell | Operating System: MacOS X Architecture: Unknown/Multiple | Type of failure: Difficulty: Unknown | None/Unknown Blocked By: | Test Case: Related Tickets: | Blocking: | Differential Revisions: -------------------------------------+------------------------------------- I have found an example where I think that the TH reification for data/newtype families is incorrect, in that if forgets non-instantiated type variables in instance declarations. For the attached example, it will infer the Info: {{{#!hs FamilyI (FamilyD DataFam TyFamReifyDefs.F [PlainTV a_1627399879,PlainTV b_1627399880] (Just StarT)) [DataInstD [] TyFamReifyDefs.F [ConT GHC.Types.Int] [NormalC TyFamReifyDefs.FInt [(NotStrict,VarT x_1627399881)]] []] }}} Note how the variable x is not declared in the body of the DataInstD. Since it does not need to have the same name as the family-declared variable, substituing is non-trivial this way... -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/9692> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 8

[GHC] #14179: "Conflicting family instance" error pretty prints data family instances poorly
by GHC 08 Nov '18

08 Nov '18

#14179: "Conflicting family instance" error pretty prints data family instances poorly -------------------------------------+------------------------------------- Reporter: RyanGlScott | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.2.1 (Type checker) | Keywords: TypeFamilies | Operating System: Unknown/Multiple Architecture: | Type of failure: Poor/confusing Unknown/Multiple | error message Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- This can be observed on GHC 8.0.1 or later: {{{#!hs {-# LANGUAGE TypeFamilies #-} module Bug where data family Fam a data instance Fam Int data instance Fam Int }}} {{{ $ /opt/ghc/8.2.1/bin/ghci Bug.hs GHCi, version 8.2.1: http://www.haskell.org/ghc/ :? for help Loaded GHCi configuration from /home/rgscott/.ghci [1 of 1] Compiling Bug ( Bug.hs, interpreted ) Bug.hs:5:15: error: Conflicting family instance declarations: Fam Int = -- Defined at Bug.hs:5:15 Fam Int = -- Defined at Bug.hs:6:15 | 5 | data instance Fam Int | ^^^ }}} Notice how GHC attempts to pretty-print the RHS by using a `=` symbol, but there is no RHS! This gets even more confusing with this program, which requires GHC HEAD: {{{#!hs {-# LANGUAGE PolyKinds #-} {-# LANGUAGE TypeFamilies #-} module Bug where data family Fam :: k -> * data instance Fam :: * -> * data instance Fam :: * -> * }}} {{{ $ ghc5/inplace/bin/ghc-stage2 --interactive Bug.hs GHCi, version 8.3.20170818: http://www.haskell.org/ghc/ :? for help Loaded GHCi configuration from /home/rgscott/.ghci [1 of 1] Compiling Bug ( Bug.hs, interpreted ) Bug.hs:6:15: error: Conflicting family instance declarations: Fam = -- Defined at Bug.hs:6:15 Fam = -- Defined at Bug.hs:7:15 | 6 | data instance Fam :: * -> * | ^^^ }}} Not only is there no RHS, but the kind signatures of each instance aren't printed either. This is an issue, since the entire reason why the two instances conflict are because of their kinds! We should rethink how data family instances are pretty printer here to avoid this issue. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14179> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 7

[GHC] #11335: Add instance (Ix a, Read a, Read b) => Read (UArray a b)
by GHC 08 Nov '18

08 Nov '18

#11335: Add instance (Ix a, Read a, Read b) => Read (UArray a b) -------------------------------------+------------------------------------- Reporter: rwbarton | Owner: Type: feature | Status: new request | Priority: normal | Milestone: Component: libraries | Version: 7.8.3 (other) | Keywords: array | Operating System: Unknown/Multiple Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- `Array` has `Eq`, `Ord`, `Show` and `Read` instances but `UArray` only has `Eq`, `Ord` and `Show`. Add the missing `Read` instance. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/11335> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 3

[GHC] #13933: Support Typeable instances for types with coercions
by GHC 07 Nov '18

07 Nov '18

#13933: Support Typeable instances for types with coercions -------------------------------------+------------------------------------- Reporter: goldfire | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.3 Keywords: TypeInType, | Operating System: Unknown/Multiple Typeable | Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- If I say {{{#!hs {-# LANGUAGE GADTs, TypeApplications, TypeInType #-} module Bug where import Type.Reflection data G a where MkG :: a ~ Bool => G a rep = typeRep @MkG }}} I get {{{ Bug.hs:10:7: error: • No instance for (Typeable <>) arising from a use of ‘typeRep’ • In the expression: typeRep @MkG In an equation for ‘rep’: rep = typeRep @MkG | 10 | rep = typeRep @MkG | }}} First off, the error message is confusing, mentioning the mysterious `<>`. But more importantly, it would be nice if the `Typeable` mechanism supported coercions. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/13933> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 2

[GHC] #11008: GND with Type Families
by GHC 07 Nov '18

07 Nov '18

#11008: GND with Type Families -------------------------------------+------------------------------------- Reporter: crockeea | 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: -------------------------------------+------------------------------------- In the following code: {{{ {-# LANGUAGE TypeFamilies, FlexibleContexts, UndecidableInstances #-} class C r type family F r newtype Foo r = Foo r instance (C (F r), Eq r) => Eq (Foo r) newtype Bar r = Bar (Foo r) deriving (Eq) }}} GHC produces the error {{{ No instance for (C (F r)) arising from the 'deriving' clause of a data type declaration Possible fix: use a standalone 'deriving instance' declaration, so you can specify the instance context yourself When deriving the instance for (Eq (Bar r)) }}} If I enable `StandaloneDeriving`, I am able to derive the instance: `deriving instance (Eq (Foo r)) => Eq (Bar r)` [https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/deriving.ht… #newtype-deriving The docs] indicate that this is exactly the instance that should be generated by GND for `newtype T v1..vn = MkT (t vk+1..vn) deriving (C t1..tj)`, where my code uses the following parameters: {{{ T = Bar v1 = r n = 1 MkT = Bar t = Foo r k= 1 C = Eq j = 0 }}} and all of the conditions enumerated in the docs seem to be met. Furthermore, `Bar` seems to fit squarely into the format of `data T1` in section 7.5.1 of the same documentation, which indicates it should not need `StandaloneDeriving`. It seems that the type family constraint on the `Eq` instance for `Foo` is causing the problem, but it's not clear why I'm forced to write a standalone instance that is identical to the one that should be generated by GND. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/11008> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 12

[GHC] #12620: Allow the user to prevent floating and CSE
by GHC 07 Nov '18

07 Nov '18

#12620: Allow the user to prevent floating and CSE -------------------------------------+------------------------------------- Reporter: nomeata | Owner: Type: feature | Status: new request | Priority: normal | Milestone: Component: Compiler | Version: 8.0.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: -------------------------------------+------------------------------------- This is a write-up of a rough idea that Andres Löw and me had at ICFP 2016 in order to address some Real World problems Andres noticed and that are currently hard to avoid. The goal is to give the user more control about expressions that the compiler would like to float out (or CSE), but the programmer knows better. Example (assume no list fusion exists): {{{ enum xs = zip [1..] xs }}} This leads to a horrible space leak, as GHC will float out `[1..]` to the top. Our idea is to have a magic function `nofloat :: a -> a` (magic in the same sense as `inline` and `lazy`) that the programmer would use here: {{{ enum xs = zip (nofloat [1..]) xs }}} With these effects: * Sub expressions are not floated out of a `nofloat`. * An expression of the form `nofloat e` would not be floated beyond the innermost enclosing lambda. * Two expressions of the form `nofloat e` would not be commoned up by CSE. This way, unwanted sharing is prevented. In contrast to a hypothetical `veryCheap` function, it does ''not'' mean that the compiler should float it into lambda (no unwanted duplication either). Two open questions (among many others, I am sure:) * Likely, rule matching should look through `nofloat`. At least in this example (and similar ones like `map (nofloat [1..])`, the rules in question will avoid the spaceleaks). * Possibly, nothing should be floated (inlined) ''into'' a `nofloat`. Rationale: Assume the library is changed so that {{{ [n..] = nofloat (realEnumFrom n) {-# INLINE [n..] #-} }}} Then `zip [fib 1000..]` would be rewritten by the inliner to `zip (let x = fib 1000 in (nofloat [x..]))`. Moving the `fib 1000` into the `nofloat` would change the behaviour in a possibly surprising way. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/12620> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 34

[GHC] #13080: Constant values are not floated out of the loop
by GHC 07 Nov '18

07 Nov '18

#13080: Constant values are not floated out of the loop -------------------------------------+------------------------------------- Reporter: Feuerbach | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.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: -------------------------------------+------------------------------------- See this stackoverflow post: http://stackoverflow.com/a/41521876/110081 Basically, the following program leaks memory on ghc 7.10.3 and ghc 8.0.1. {{{#!hs import Control.Monad (forever) main :: IO () main = worker {-# NOINLINE worker #-} worker :: (Monad m) => m () worker = forever $ poll () poll :: (Monad m) => () -> m a poll action = do return () poll action }}} Could ghc do better there? -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/13080> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 24