April 2008 - Glasgow-haskell-users

partially applied type synonyms
by Arie Peterson 05 Mar '12

05 Mar '12

Dear list, Is there a good reason that partially applied type synonyms cannot be made instances of classes? - A simple example would be making the identity type 'Id' ("type Id x = x") instance of 'Monad'. This would eliminate the need for some silly occurrences of 'runIdentity', and perhaps narrow the gap between monads and monad transformers. - The reason I complain about this now is a more involved example, where introducing a newtype to work around the restriction is not an option. Well, not as far as I can see now, anyway. Partially applied type synonyms are, in a sense, the anonymous functions at the type level, and one might argue that they deserve the same 'first-class member status' as the lambda at the value level. Kind regards, Arie Peterson

3 2

ghci and ghc -threaded broken with pipes & forking
by John Goerzen 29 Dec '08

29 Dec '08

Hi, I've been hitting my head against a wall for the past couple of days trying to figure out why my shell-like pipeline code kept hanging. I found fd leakage (file descriptors not being closed), which disrupts EOF detection and can lead to deadlocks. I just couldn't find the problem. I finally tried compiling my test with ghc instead of running it in ghci. And poof, it worked fine the first time. I tried asking on #haskell, and got the suggestion that ghci uses -threaded. I tried compiling my test program with ghc -threaded, and again, same deadlock. My program never calls forkIO or forkOS or any other threading code. You can see my test case with: darcs get '--tag=glasgow ml' http://darcs.complete.org/hsh ghc -fglasgow-exts --make -o test2 test2.hs That'll run fine. If you add -threaded, it will hang. Ideas? Thanks, -- John

13 44

Arrow without `>>>'
by Valery V. Vorotyntsev 03 Sep '08

03 Sep '08

Hi, friends, I've built GHC from darcs, and... Could anybody tell me, what's the purpose of Arrow[1] not having `>>>' method? 1. http://darcs.haskell.org/packages/base/Control/Arrow.hs $ ghci GHCi, version 6.9.20080104: http://www.haskell.org/ghc/ :? for help Loading package base ... linking ... done. Prelude> :m + Control.Arrow Prelude Control.Arrow> :i Arrow class (Control.Category.Category a) => Arrow a where arr :: (b -> c) -> a b c pure :: (b -> c) -> a b c first :: a b c -> a (b, d) (c, d) second :: a b c -> a (d, b) (d, c) (***) :: a b c -> a b' c' -> a (b, b') (c, c') (&&&) :: a b c -> a b c' -> a b (c, c') -- Defined in Control.Arrow instance Arrow (->) -- Defined in Control.Arrow instance (Monad m) => Arrow (Kleisli m) -- Defined in Control.Arrow Prelude Control.Arrow> Leaving GHCi. I can't build[2] arrows-0.3 package without `>>>' in Arrow. 2. vvv@fun:~/src/arrows$ darcs w { hunk ./Control/Arrow/Operations.hs 36 +import Control.Category ((>>>)) hunk ./Control/Arrow/Transformer/CoState.hs 23 +import Control.Category ((>>>)) } vvv@fun:~/src/arrows$ runhaskell Setup build Preprocessing library arrows-0.3... Building arrows-0.3... [ 3 of 12] Compiling Control.Arrow.Transformer.CoState ( Control/Arrow/Transformer/CoState.hs, dist/build/Control/Arrow/Transformer/CoState.o ) Control/Arrow/Transformer/CoState.hs:29:7: `>>>' is not a (visible) method of class `Arrow' The question arises "should I?", but this is one of lambdabot's[3] depencies. 3. http://code.haskell.org/lambdabot/ Thanks a lot! -- vvv

3 3

ANN: ghc 6.8.2 from MacPorts
by Gregory Wright 06 May '08

06 May '08

After what many would consider an unconscionable delay, I am happy to announce that ghc 6.8.2 is available from MacPorts. The ghc 6.8.2 port is available for Tiger/ppc, Tiger/intel and Leopard/ intel. Users with Leopard/ppc are out of luck until for now, for reason discussed earlier on this list. In partial recompense for their patience, users will get a ghc with more patches than any previous MacPorts ghc. A few notes: The file locking bugs #1992 and #2134 are fixed. Bug #1992 was a simple lock logic error and should be killed dead. Bug #2134 was the result of a lazy readFile holding a lock for an unpredictable time. There may be more cases like this one, and I would appreciate a note from anyone who come across a lock error during building. Users on Leopard/intel must upgrade to 10.5.2 to avoid an OS bug which under unusual circumstances would repeatably (and mysteriously) crash the build. This was first noticed running the building in an eshell under Aquamacs. Archives were built without tables of contents because ranlib wasn't being run or wasn't running to completion. Builds in the usual Terminal.app didn't trip over this bug. OpenGL support is built by default. It can be turned off using the no_opengl variant. OpenAL support is disabled. Apple's OpenAL framework lacks ALUT support (needed for the ghc binding) but has name clashes with the freealut library from the OpenAL.org website. Fixing this is probably straightforward. If someone is interested, I can give them some pointers on getting started. MacPort's ghc ought to always link with the correct libgmp (the one provided by the gmp port). The latest versions of alex, happy, haddock and hs-Edison are also available. Best Wishes, Greg

10 20

instance export decls
by Serge D. Mechveliani 03 May '08

03 May '08

Dear GHC developers, people, Do you agree that there exists such a problem for a programmer as recalling exported instances? Have Haskell and/or GHC some constructs and tools to help the programmer to recall the exported instances for a module? Could GHC support the instance export messages for each module? In Haskell-98, the exported instances cannot be named explicitly in the export list. Right? But for easier understanding of a program, it is desirable to allow to name (in a short form) instances in the export list. For this reason, I add comments, and write the export like this: module Poly (WithHead(..), WithTail(..), -- classes Mon(..), Polynomial(..), lc, polMons -- , instances -- for Mon: WithHead, List; -- for Polynomial: WithHead, Cast Polynomial Mon ) The comment of kind "-- , instances ..." helps to recall which instances are exported, without inspecting all the (lengthy) module source. But when the programmer changes the source, one often forgets to add/remove the needed comments about instances. I often forget them (maybe, lazy to recall) when I move pieces of code between modules. So, I suggest the following feature for GHC. 1. To allow the export declarations of kind instance {<type>} (maybe to suggest this for Haskell ?) 2. If the module under compilation has the word `instance' in its export list, then ghc finds the difference set diff for the exported instance kinds eKinds and the instance kinds nKinds named in the export list. If not $ null diff, it issues the message: "Warning: the exported instance kinds and the instance kinds named in the export differ in the following items: ...". Seeing such a message, the user corrects the export list in the source according to diff. For the export list and for their messages, it is probably better to use a short denotation: the instance kind rather than full instance declaration. In the instance kind, the part of "(...) =>" is skipped. What people think of this suggestion? Thank you in advance for your notes and help, ----------------- Serge Mechveliani mechvel(a)botik.ru

3 4

RE: Unexpected lack of optimisation
by Simon Peyton-Jones 01 May '08

01 May '08

| The situation in Neil's code is almost identical, except that the | top-level case expression is on a value passed by environment, not by | function argument. Interesting thought. I think you're describing a possible extension to the SpecConstr transformation described in "Call pattern specialisation for Haskell" (http://research.microsoft.com/%7Esimonpj/papers/spec-constr) f x = let g y = ...case x of { z:zs -> e1; [] -> e2 } ... in ...case x of z:zs -> if ... then g 3 else g 4 [] -> ... Here 'x' is free in 'g', but x's value is known at g's call sites. It's not enough just to know "x is a cons" inside g; we must also have access to z,zs. So perhaps the thing to do is to imagine lambda-lifting 'g' to become 'gl' thus: gl x y = ...case x of { z:zs -> e1; [] -> e2 } ... f x = ...case x of z:zs -> if ... then gl x 3 else gl x 4 [] -> ... Now the SpecConstr transformation will apply nicely. And it's arguably a bad shortcoming that currently the mere act of lambda lifting can affect how effective SpecConstr is. Of course, we only want to lambda-lift wrt the parameters that'll be specialised, so this transformation probably wants to be done at the same time as the rest of SpecConstr. I don't have much idea of how hard that'd be, but it's a nice idea. Simon

2 1

Re: Unexpected lack of optimisation
by Neil Mitchell 30 Apr '08

30 Apr '08

Hi > > Yes, something like that is exactly what I'd like to do. I'm somewhat > hopeful that we might manage this as part of Max Bolingbroke's SoC project, > if it's approved. > > > > Hmmm, I thought it had been approved. Was I mistaken? Yes, it has been approved. http://code.google.com/soc/2008/haskell/about.html Thanks Neil

1 0

Optimisation of unpackCString#
by Neil Mitchell 30 Apr '08

30 Apr '08

Hi (All these results are from GHC 6.9.20071226, but suspect they hold for 6.9.* and 6.8) The following code: test = head "neil" Produces (with -O2): Text.HTML.TagSoup.Development.Sample.test = case GHC.Base.unpackCString# "neil" of wild_aaU { [] -> GHC.List.badHead @ GHC.Base.Char; : x_aaY ds1_aaZ -> x_aaY } However: test = head ['n','e','i','l'] Produces: Text.HTML.TagSoup.Development.Sample.test = GHC.Base.C# 'n' The packing of the string has damaged the optimisation. Is there anyway to mitigate this? I ideally want to do this in RULES to derive an efficient parser from a set of parser combinators, and the unpackCString# really gets in the way of future optimisations. I could imagine adding two rules to the simplifier: case unpackCString# "" of ==> case [] of case unpackCString# "xyz" of ==> case (C# 'x': unpackCString# "yz") of Then the simplifier could recover the optimised version. Thanks Neil

5 21

ghci: can't load module BitSet, and some others
by Marc Weber 30 Apr '08

30 Apr '08

Hi. I'm totally puzzled: ghc-pkg describe ghc shows BitSet as exposed module. When grepping the whole ghc source code the only occurance I can find is in the package.in file for the ghc package. But that't it Trying to load it using GHC-api or ghci fails ? Is this module depreceated and only there for compatibility reasons? darcs changes reveals: Wed Oct 11 15:16:14 CEST 2006 Simon Marlow <simonmar(a)microsoft.com> * remove BitSet, it isn't used So is it time to remove it completely? I can't load all these modules: BitSet FieldLabel IlxGen Java JavaGen PrintJava RegisterAlloc So what's wrong here? Sincerly MarcWeber

2 2

Unexpected lack of optimisation
by Neil Mitchell 30 Apr '08

30 Apr '08

Hi Using GHC 6.9.20071226: The following code: ------------------------------------------------------- test s | begin2 'n' 'a' s = "test" | begin2 'n' 'b' s = "test2" begin2 :: Char -> Char -> String -> Bool begin2 x1 x2 (y:ys) | x1 == y = begin1 x2 ys begin2 _ _ _ = False begin1 :: Char -> String -> Bool begin1 x1 (y:ys) | x1 == y = True ------------------------------------------------------- You might expect the head of the list s to be tested for equality with 'n' only once. Something like: test s = case s of s1:ss -> case s1 of 'n' -> .... choose 'a' or 'b' .... _ -> fail Unfortunately, GHC can't common up these two tests. It inserts a State# RealWorld in the middle, giving a result of: test s = case s of s1:ss -> case s1 of 'n' -> case ss of s2:ss -> case s2 of 'a' -> .... _ -> retry state _ -> retry state retry dummy = case s of s1:ss -> case s1 of 'n' -> .... If GHC was to inline the "retry" (which is a local let-bound lambda) it should have no problem merging these two cases. I'm not entirely sure why the State# gets inserted, but was wondering if it is necessary? The complete -ddump-simpl is at the end of this message. Thanks Neil -------------------------------------------------------------- Text.HTML.TagSoup.Development.Sample.test :: GHC.Base.String -> [GHC.Base.Char] [GlobalId] [Arity 1] Text.HTML.TagSoup.Development.Sample.test = \ (s_a6g :: GHC.Base.String) -> let { $j_s7l :: GHC.Prim.State# GHC.Prim.RealWorld -> [GHC.Base.Char] [Arity 1] $j_s7l = \ (w_s7m :: GHC.Prim.State# GHC.Prim.RealWorld) -> let { $j1_s7d :: GHC.Prim.State# GHC.Prim.RealWorld -> [GHC.Base.Char] [Arity 1] $j1_s7d = \ (w1_s7e :: GHC.Prim.State# GHC.Prim.RealWorld) -> GHC.Err.patError @ [GHC.Base.Char] "Text/HTML/TagSoup/Development/Sample.hs:(48,0)-(49,34)|function test" } in case s_a6g of wild_Xl { [] -> $j1_s7d GHC.Prim.realWorld#; : y_a6o ys_a6q -> case GHC.Base.$f4 of tpl_Xr { GHC.Base.:DEq tpl1_B2 tpl2_B3 -> case tpl1_B2 (GHC.Base.C# 'n') y_a6o of wild1_Xp { GHC.Base.False -> $j1_s7d GHC.Prim.realWorld#; GHC.Base.True -> let { fail_d6S :: GHC.Base.Bool [] fail_d6S = GHC.Err.patError @ GHC.Base.Bool "Text/HTML/TagSoup/Development/Sample.hs:57:0-32|function begin1" } in case ys_a6q of wild2_XB { [] -> case fail_d6S of wild3_Xj { GHC.Base.False -> $j1_s7d GHC.Prim.realWorld#; GHC.Base.True -> GHC.Base.unpackCString# "test2" }; : y1_a6y ys1_a6A -> case GHC.Base.$f4 of tpl3_XH { GHC.Base.:DEq tpl4_XL tpl5_XN -> case tpl4_XL (GHC.Base.C# 'b') y1_a6y of wild3_Xo { GHC.Base.False -> case fail_d6S of wild4_Xj { GHC.Base.False -> $j1_s7d GHC.Prim.realWorld#; GHC.Base.True -> GHC.Base.unpackCString# "test2" }; GHC.Base.True -> GHC.Base.unpackCString# "test2" } } } } } } } in case s_a6g of wild_B1 { [] -> $j_s7l GHC.Prim.realWorld#; : y_a6o ys_a6q -> case GHC.Base.$f4 of tpl_Xp { GHC.Base.:DEq tpl1_B2 tpl2_B3 -> case tpl1_B2 (GHC.Base.C# 'n') y_a6o of wild1_XT { GHC.Base.False -> $j_s7l GHC.Prim.realWorld#; GHC.Base.True -> let { fail_d6S :: GHC.Base.Bool [] fail_d6S = GHC.Err.patError @ GHC.Base.Bool "Text/HTML/TagSoup/Development/Sample.hs:57:0-32|function begin1" } in case ys_a6q of wild2_Xz { [] -> case fail_d6S of wild3_XD { GHC.Base.False -> $j_s7l GHC.Prim.realWorld#; GHC.Base.True -> GHC.Base.unpackCString# "test" }; : y1_a6y ys1_a6A -> case GHC.Base.$f4 of tpl3_XF { GHC.Base.:DEq tpl4_XJ tpl5_XL -> case tpl4_XJ (GHC.Base.C# 'a') y1_a6y of wild3_Xo { GHC.Base.False -> case fail_d6S of wild4_XN { GHC.Base.False -> $j_s7l GHC.Prim.realWorld#; GHC.Base.True -> GHC.Base.unpackCString# "test" }; GHC.Base.True -> GHC.Base.unpackCString# "test" } } } } } }

5 9