- Glasgow-haskell-users

Newtype wrappers
by Simon Peyton-Jones 22 Jan '13

22 Jan '13

Friends I'd like to propose a way to "promote" newtypes over their enclosing type. Here's the writeup http://hackage.haskell.org/trac/ghc/wiki/NewtypeWrappers Any comments? Below is the problem statement, taken from the above page. I'd appreciate * A sense of whether you care. Does this matter? * Improvements to the design I propose Simon The problem Suppose we have newtype Age = MkAge Int Then if n :: Int, we can convert n to an Age thus: MkAge n :: Age. Moreover, this conversion is a type conversion only, and involves no runtime instructions whatsoever. This cost model -- that newtypes are free -- is important to Haskell programmers, and encourages them to use newtypes freely to express type distinctions without introducing runtime overhead. Alas, the newtype cost model breaks down when we involve other data structures. Suppose we have these declarations data T a = TLeaf a | TNode (Tree a) (Tree a) data S m a = SLeaf (m a) | SNode (S m a) (S m a) and we have these variables in scope x1 :: [Int] x2 :: Char -> Int x3 :: T Int x4 :: S IO Int Can we convert these into the corresponding forms where the Int is replaced by Age? Alas, not easily, and certainly not without overhead. * For x1 we can write map MkAge x1 :: [Age]. But this does not follow the newtype cost model: there will be runtime overhead from executing the map at runtime, and sharing will be lost too. Could GHC optimise the map somehow? This is hard; apart from anything else, how would GHC know that map was special? And it it gets worse. * For x2 we'd have to eta-expand: (\y -> MkAge (x2 y)) :: Char -> Age. But this isn't good either, because eta exapansion isn't semantically valid (if x2 was bottom, seq could distinguish the two). See #7542<http://hackage.haskell.org/trac/ghc/ticket/7542> for a real life example. * For x3, we'd have to map over T, thus mapT MkAge x3. But what if mapT didn't exist? We'd have to make it. And not all data types have maps. S is a harder one: you could only map over S-values if m was a functor. There's a lot of discussion abou this on #2110<http://hackage.haskell.org/trac/ghc/ticket/2110>.

18 40

Global constant propagation
by C Rodrigues 21 Jan '13

21 Jan '13

I'm curious about global constant propagation in GHC. It's a fairly basic optimization in the CFG-based compiler domain, and it's similar to constructor specialization, but it doesn't seem to be in GHC's repertoire. Perhaps it's usually subsumed by other optimizations or it's more complicated than I am thinking. Is this optimization worth implementing? This optimization can help when a case expression returns a product, some fields of which are the same in all branches. The following program is a minimal example of an optimizable situation that GHC doesn't exploit. {-# OPTIONS_GHC -O3 -funbox-strict-fields #-} data D = D !Int !Int foo n = if n > 0 then D 0 0 else D 0 n main = case foo $ read "7" of D x y -> if x == 0 then return () else print y >> putStrLn "A" After inlining and case-of-case transformation, GHC produces main = let n = read "7" k x y = case x of {0 -> return (); _ -> print y >> putStrLn "A"} in if n > 0 then k 0 0 else k 0 n If the simplifier could discover that x is always 0, it could eliminate one parameter of 'k' and the case expression.

2 1

Updating/understanding code from implicit configurations paper
by Eric M. Pashman 19 Jan '13

19 Jan '13

Reading the implicit configurations paper (Kiselyov & Shan), I couldn't figure out how this bit of code (section 3.2) was meant to work: class Modular s a | s -> a where modulus :: s -> a normalize :: (Modular s a, Integral a) => a -> M s a normalize a :: M s a = M (mod a (modulus (undefined :: s))) Here, `M` is just a type representing a modulus, with a phantom parameter that's going to make the magic happen: data M s a = M a deriving (Eq, Show) Running this in GHC 7.4.2, with the extensions for scope typed variables, multi parameter type classes, and functional dependencies enabled, I get a parse error on the type signature on the LHS of the definition of `normalize`. Having moved the deprecated LHS result annotation to the RHS, I think this should be equivalent: normalize :: (Modular s a, Integral a) => a -> M s a normalize x = (M (mod x (modulus (undefined :: s)))) :: M s a But indeed this won't type-check. I've tried annotating the argument (x :: a) and the result of `modulus` (modulus (undefined :: s) :: a), as well as various other terms, but GHC always tells me the phantom type is ambiguous or the type of the argument of `normalize` can't be unified with the parameter `a` in the result type. Now, like I said, I didn't see how this could work in the first place, so I'm at a loss as to what the problem is. Can someone show me how to get this to compile with a recent version of GHC? I'd also appreciate any insight into what `normalize` is meant to do, if the working code turns out to differ in just a type annotation or two. ... Regards, Eric PS: The literate Haskell version of the paper is here.

2 2

RULES map (\x -> x) = id
by Joachim Breitner 18 Jan '13

18 Jan '13

Hi, I am experimenting with rewrite rules, but found that they do not fire as often as I wanted them. Here is a small example: module MapId where myMap f [] = [] myMap f (x:xs) = f x : myMap f xs {-# RULES "map id" myMap id = id #-} {-# RULES "map id2" myMap (\x -> x) = id #-} mapId = myMap id mapIdApp x = myMap id x mapLamId = myMap (\x -> x) mapLamIdApp x = myMap (\x -> x) x This works as expected, i.e. the latter four functions become some kind of identity. But I am a bit surprised that I do need two rules to catch all cases, as I thought that the simplifier „looks through“ definitions like "id". But when I remove the "map id" rule, the functions "mapId" and "mapIdApp" are not optimized. So I wonder: Why is rule "map id2" not enough here? Thanks, Joachim -- Joachim "nomeata" Breitner mail(a)joachim-breitner.de | nomeata(a)debian.org | GPG: 0x4743206C xmpp: nomeata(a)joachim-breitner.de | http://www.joachim-breitner.de/

2 1

Should ghc -msse imply gcc -msse
by Johan Tibell 17 Jan '13

17 Jan '13

Hi all, You can turn on e.g. SSE 4.1 by passing -msse4.2 to ghc. This doesn't currently imply that we compile any C code with -msse4.2 turned on, so if someone really want to use SSE4.2, they have to do: ghc -msse4,2 -optc-msse4.2 Do we want to change this so it's enough to pass -msse4.2 to ghc? -- Johan

3 5

Irritating compilation error on Windows32.
by Caitlin 17 Jan '13

17 Jan '13

Hi all. I wrote the following test program: bar x = x * x on a Win32 (SP3) machine using the Haskell Platform and GHC-7.6.1 (standalone) and I have noticed the same frustrating errors. Any suggestions would be most appreciated. Thanks, ~Caitlin C:\>ghci GHCi, version 7.4.2: http://www.haskell.org/ghc/ :? for help Loading package ghc-prim ... linking ... done. Loading package integer-gmp ... linking ... done. Loading package base ... linking ... done. Prelude> Prelude> :l bar [1 of 1] Compiling Main ( bar.hs, interpreted ) *** Exception: CreateDirectory ".": permission denied (Access is denied.) > > :l bar.hs [1 of 1] Compiling Main ( bar.hs, interpreted ) *** Exception: CreateDirectory ".": permission denied (Access is denied.) > > :l "C:\\bar.hs" [1 of 1] Compiling Main ( C:\bar.hs, interpreted ) *** Exception: CreateDirectory "C:\\": permission denied (Access is denied.) > >

1 0

What is the scheduler type of GHC?
by Magicloud Magiclouds 16 Jan '13

16 Jan '13

Hi, Just read a post about schedulers in erlang and go lang, which informed me that erlang is preemptive and go lang is cooperative. So which is used by GHC? From ghc wiki about rts, if the question is only within haskell threads, it seems like cooperative. -- 竹密岂妨流水过山高哪阻野云飞 And for G+, please use magiclouds#gmail.com.

3 2

Master thesis
by Vikraman 16 Jan '13

16 Jan '13

Hi, I am looking to hack on ghc/haskell for my master thesis. What are some areas that I should be looking into? Any suggestions are welcome.

2 1

Newtype wrappers
by Krzysztof Gogolewski 15 Jan '13

15 Jan '13

The idea can be extended to other situations where unsafeCoerce is justified: empty types and phantom types. Given declarations data Void data Void' data Const a b = Const a we can create O(1) wrappers: f :: F Void -> F Void' -- empty datatypes are exchangeable g :: F (Const a Int) -> F (Const a Bool) -- phantom parameter is insignificant assuming they do not mess with invariants of F. >From this perspective I prefer proposal 2 (a new constraint): new types of coercions might be added by adding special cases in the constraint solver. It is also a reuse of syntax: we can write foo = newtypeCast :: [Int] -> [Age] instead of adding a new form of declaration. _____________________ As for safety, in some sense Map a b is parametric in a and b except the Ord instance of a. We can coerce Map a b into Map c d if we can coerce a into c, b into d and the Ord a instance matches Ord c instance (for example, one is derived from the other). This could be implemented via an instance like this: instance (a ~~ c, b ~~ d, Ord a ~~ Ord c) => Map a b ~~ Map c d where ~~ is kind-polymorphic "equality up to newtypes". If Map was, say, indexed (nonparametric) in the first argument, that would be: instance b ~~ d => Map a b ~~ Map a d etc. Krzysztof Gogolewski

1 0

chao!
by asyropoulos＠aol.com 15 Jan '13

15 Jan '13

http://www.orthopaedie-nickles.de/tmp/yahoo.php

1 0