- Glasgow-haskell-users

GHC and Haskell Standard wrt floatRange...
by Tyson Whitehead 09 Mar '09

09 Mar '09

I think there might be a difference between C/GHC and the Haskell Standard's idea of the range of the exponential. Specifically, the comment in gcc's float.h (i.e., where GHC appears to gets its definition from) says /* Minimum int x such that FLT_RADIX**(x-1) is a normalized float, emin */ while the Haskell Standard says "...the lowest and highest values the exponent may assume respectively..." This results in (GHC 6.10.1 on Debian) Prelude> (2**128::Float) Infinity Prelude> (2**127::Float) 1.7014119e38 Prelude> floatRange (0::Float) (-125,128) I can file a bug report/patch if nobody is seeing something I missed here... Cheers! -Tyson

1 0

Deep fmap with GADTs and type families.
by Dan Doel 09 Mar '09

09 Mar '09

Greetings, Someone on comp.lang.functional was asking how to map through arbitrary nestings of lists, so I thought I'd demonstrate how his non-working ML function could actually be typed in GHC, like so: --- snip --- {-# LANGUAGE TypeFamilies, GADTs, EmptyDataDecls, Rank2Types, ScopedTypeVariables #-} data Z data S n data Nat n where Z :: Nat Z S :: Nat n -> Nat (S n) type family Nest n (f :: * -> *) a :: * type instance Nest Z f a = f a type instance Nest (S n) f a = f (Nest n f a) deepMap :: Nat n -> (a -> b) -> Nest n [] a -> Nest n [] b deepMap Z f = map f deepMap (S n) f = map (deepMap n f) --- snip --- This works. However, the straight forward generalisation doesn't: --- snip --- deepFMap :: Functor f => Nat n -> (a -> b) -> Nest n f a -> Nest n f b deepFMap Z f = fmap f deepFMap (S n) f = fmap (deepFMap n f) --- snip --- This fails with a couple errors like: Map.hs:25:19: Couldn't match expected type `Nest n1 f b' against inferred type `Nest n1 f1 b' In the expression: fmap (deepFMap n f) In the definition of `deepFMap': deepFMap (S n) f = fmap (deepFMap n f) for reasons I don't really understand. So I tried the following: --- snip --- newtype FuntorD f = F { fdmap :: forall a b. (a -> b) -> f a -> f b } deepFDMap :: FunctorD f -> Nat n -> (a -> b) -> Nest n f a -> Nest n f b deepFDMap d Z f = fdmap d f deepFDMap d (S n) f = fdmap d (deepFDMap d n f) --- snip --- This works, but to my surprise "deepFMap = deepFDMap (F fmap)" gives the exact same error as above. Bringing my situation to #haskell, two solutions were found: --- snip --- deepFMap :: forall n f a b. Functor f => Nat n -> (a -> b) -> Nest n f a -> Nest n f b deepFMap = deepFDMap (F fmap :: FunctorD f) data Proxy (f :: * -> *) = Proxy deepFMap' :: Functor f => Proxy f -> Nat n -> (a -> b) -> Nest n f a -> Nest n f b deepFMap' _ Z f = fmap f deepFMap' p (S n) f = fmap (deepFMap p n f) --- snip --- But we've so far not been able to find a way of merely annotating the original into working. So, I was wondering if any of the more knowledgeable folks here could illuminate what's going wrong here, and whether I should expect my original code to work or not. Thanks in advance. -- Dan

4 4

Re: finally part run twice on Ctrl-C
by Philip K.F. Hölzenspies 09 Mar '09

09 Mar '09

> I've got the following code: > > import Control.Exception > import System.Cmd > main = system "sleep 1m" `finally` putStrLn "goodbye" > > When compiled with GHC 6.10.1.20090225, if I hit Ctrl-C during the > sleep, I get the goodbye printed twice. If I leave evaluation to > finish normally I get goodbye once. Is this a bug? Dear Neil, et al. Just to let you know; I tried it on the release version of 6.10.1 and it worked as expected (first run, I waited; second I pressed Ctrl-C): *Test> main goodbye ExitSuccess *Test> main goodbye ExitFailure 2 *Test> If not coming from system differences, the bug should sit in recent code. Regards, Philip

2 3

Warning about unrecognised pragma
by Colin Paul Adams 06 Mar '09

06 Mar '09

I am getting messages: Board_representation.hs:407:0: Unrecognised pragma Board_representation.hs:442:0: Unrecognised pragma Board_representation.hs:458:0: Unrecognised pragma etc. (GHC 6.10.1) I looked into the documentation to see how to supress these warnings (prefereably for the particular pragma concerned), but I found (from 8.13): any pragma encountered with an unrecognised word is (silently) ignored. -- Colin Adams Preston Lancashire

3 4

my experience with ghci debugger extensions
by Peter Hercek 01 Mar '09

01 Mar '09

Hi users of ghci debugger, This post is going to be a bit longer. Here are few cookies to motivate you to go on: * you will probably like it more than printf debugging for a lot of cases * it can provide a way of implementing Claus Reinke's idea of breakpoints with a list of identifiers which should be available at breakpoint location and doing it without recompilation; here is the link to Claus' message: http://permalink.gmane.org/gmane.comp.lang.haskell.glasgow.user/15900 * it gives some idea to ghc team about importance of ghci debugger related tickets (and whether to implement them just the way they were proposed) A note to ghc developers: Stepping program in ghci debugger sometimes purges top level bindings and sometimes not. Not sure this is a bug or feature (whether there is some logic in it). I do not have a simple example when it purges the bindings. But I did not really look for one. I would probably post later, but some ghci bugs and missing features are badly limiting my progress. There is not much more I can think of to investigate. Maybe somebody will have better ideas how to solve the obstacles I'm hitting. I'm also posting with hope that people will find this interesting and ghc team will fix some of the critical bugs and adds the most critical features, especially if somebody will not have better debugging tips. You can get my extensions here: http://www.hck.sk/users/peter/pub/ghciext-0.1.tar.gz The extensions are not in a single .ghci file now. The new .ghci file needs to install a library. The reason is that without the library it is not manageable any more. And here are arch linux packaging instructions for my custom ghc (if you are an arch linux user just download and run makepkg :) ): http://www.hck.sk/users/peter/pub/ghc-custom-6.10.1.tar.gz The custom ghc is just the same one as ghc 6.10.1 with two more patches: t2740.patch and loglocal.patch. The first one fixes ticket 2740 and you will get it in 6.10.2. The second one adds :loglocal command to ghci. You can extract the patches from the tar file. If you already read ghci scripting tutorial from Claus Reinke then you will know how to customize ghciext (that is if you would feel like doing so). The tutorial is here: http://www.haskell.org/pipermail/haskell-cafe/2007-September/032260.html Here is the list of custom commands in ghciext package: :defs -- list user-defined commands :. <file> -- source commands from <file> :redir <var> <cmd>... -- execute <cmd> redirecting stdout to <var> :grep <pat> <cmd>... -- filter lines matching <pat> from <cmd> output :* <count> <cmd>... -- run <cmd> <count> times :x <cmd>... -- run <cmd> with stdout suppressed :bp <bpArgs> -- put breakpoint at location <bpArgs> (adds hit count) :inject <cc> <c> <sc> <b> -- at location <b> execute <c> if <cc>, and stop if <sc> :monitor ["<c>"] <vs> <b> -- show comma separated variables at location <b> if <c> :watch <cond> <bpArgs> -- break at location <bpArgs> when <cond> is True :count (_|<N>) [<bpArgs>] -- count/query/stop execution at location <bpArgs> :find <var> <cmd>... -- step with <cmd> until <var> is found :findex <str> <cmd>... -- step with <cmd> until <str> is found :next [lazy] -- step over; lazy version forces only the top constructor :xout -- redirect ghci stdout to /dev/null :out -- redirect ghci stdout back to console :defs, :., :redir, :grep, are the same as the commands in Claus' tutorial. The only differences I recall now are: * grep pattern can be in quotation marks (easier search for spaces) * grep merges :browse output more nicely * redir can accept :step, :steplocal etc; i.e. also the commands which sometimes remove top level bindings * the commands do not pollute top level bindings so much The rest will describe my custom commands and now they relate to tickets in ghci track. If you want to check the tickets mentioned here then the most easy way is probably selecting them from this list: http://hackage.haskell.org/trac/ghc/search?q=phercek&noquickjump=1&ticket=on The initial big problem was how to limit the amount of information ghci debugger spits at you when breakpoints with custom scripts are used. This is also mentioned in forth point of the "unknown" section of ticket #1377: /We can disable a breakpoint with ":set stop N :continue", but this still prints out the breakpoint info when we stop. Should we print the info only if there were no commands?/ So I say: yes do it! Just disable any ghci output related to a breakpoint when the breakpoint has a custom code attached. We can disable the output ourselves, but then we disable all the output (including the output of the debugged program). People who are debugging console applications are busted (especially if the applications are interactive). This is not an issue for me since my application is not using console almost at all. I'm solving the problem by prefixing commands like /:main/ and /:continue /with my command /:x/. This makes output by default disabled and ghciExt enables it just before a breakpoint code is run. If the breakpoint continues execution it disables it again. If the debugged function finishes the output is enabled by /:x/ itself. A small problem happens when you forget to use /:x/ e.g. with your /:main/. Then you do not get a prompt when the program finishes. It's time to notice it and use /:out/ to switch it on. This is the only minor disadvantage for a gui application debugging. /:xout /in not that useful (it is mostly used internally by /:x/). It could be a hidden command (i.e. not registered in defs). Now when we have ghci "muted" we can get to real goodies: /:monitor/, /:watch/, and /:count/. If you like printf debugging, then /:monitor/ can help you. It can monitor only free variables in the selected expression (on which a breakpoint is hit) but that was always enough for me during debug sessions I had. Write a script file (lets say it is named *ghciInit* (I'll also call it this way later on in this text)) which is like this example: /:monitor var1,var2 ModuleName 23 :monitor var3 ModuleName 40 :x :main mainArgument/ Then open ghci with your program and run *:. ghciInit* And you will get nice log like this: /(0): var1 = <value01> var2 = <value02> (1): var3 = <value03> (0): var1 = <value11> var2 = <value12> (1): var3 = <value13> ... etc/ Moreover /:monitor/ allows condition in quotation marks to be specified as the first argument. If you do it then the variable values will be printed only when the condition is True. Of course the condition can contain only free variables in the selected expression. Mostly it is not a problem. /:watch/ is a conditional breakpoint which stops when the specified condition is True. /:count/ has 3 forms: /:count _ ModuleName 23/ This never breaks just counts number of times the execution reached position ModuleName 23 /:count 5 ModuleNmae 23/ This breaks when we reach position ModuleName 23 fifth time /:count 0/ This tells how many times breakpoint number 0 was hit (it can report the number of hits for any breakpoint created with /:bp/, /:inject/, /:monitor/, /:watch/, and /:count/). The first form of /:count/ is interesting when you want to stop earlier than something bad happens so that you can see why the bad think happened. Put the first form of /:count/ at the start of the function with the bug and then put a break in the function which is hit when the bad think happens maybe with /:watch/. When you stop at the bug place, check hit count at the start of the function. Add the hit count in your /:count/ breakpoint in your *ghciInt* file restart and you can use /:steplocal/ or /:loglocal/ to find out what went wrong. /:loglocal/ is implemented directly in ghc source code. It does exactly the same as /:steplocal/ but makes sure that the trace history does not contain anything outside of the function we step with /:steplocal/. The problem is that /:steplocal/ works like the code was traced while it is executing. Mostly the result is that your trace history is loaded with crap outside of the scope you are interested in. I'll return to /:loglocal/ later again. /:inject/ is there when you need something special (/:monitor/, /:watch/, and /:count/ are implemented with something very like /:inject/). E.g. when you want to do monitoring of a value but do not want the associated breakpoint number printed. /:find/ and /:findex/ are there primary to search trace history. /:find var1 :back/ will find the variable var1 in your trace history by back stepping it /:find var1 :step/ will single step forward till variable var1 is in the list of free variables /:findex BL/Logic.hs:23 :loglocal/ will fill in your trace history will all the local breakpoints till location BL/Logic.hs:23 is hit. Having the trace history filled in with the right stuff is useful for checking out why you got bad results later. Now lets return to Claus' idea of breakpoints with a list of identifiers which should be available at the breakpoint location. You can make sure the identifiers are available with the first form of /:count/. It never stops but it puts records to the trace history. So the trace history will contain free variables at the locations where you put /:count/. This will be even more useful when automatic search of trace history is built in (see ticket #2737). So a weaker form of Claus' idea can be implemented by carefully selecting what should bet to the trace history. Why a weaker form only? Well, in some cases, the variable instances in trace log may not be the expected ones (they may be from a different lexical scope). Experience with my code indicates this should be rare. /:next/ is an idea how to implement a kind of step over. That is if by step over you mean something else than steplocal. The non-lazy form of /:next/ forces _result and does a /:step/. The lazy form forces only the top level constructor of _result before the step. Hey, I even had a case when it worked just like I expected. But typically it does not work because of bug #1531. _result is not correctly bound to the result of selected expression in most of the practical cases. This bug is also critical for all the forms of conditional breakpoints. It would be cool if we could specify the condition based on _result or some part of it. The implementation of ghciExt conditional breakpoints would need to be extended to support conditions on _result (in particular the breakpoint would need to be disabled during the condition execution) but that is easy to do. Even more worrying thing about bug #1531 is that it has the milestone set to _|_. It is easy to add /:enable/ and /:disable/ to support enabling and disabling breakpoints. I just did not need it yet. Here is how a GhciExt breakpoint looks like: *Main> :show breaks [0] Main a.hs:4:2-8 ":cmd return$GhciExt.getStopCode 0 (True) "putStr \"(0): \"\n:force x" "False"" *Main> Just replace getStopCode with getDisabledStopCode and you have it disabled. Return back to enable. Yeah, and implement getDisabledStopCode which will just continue. I added :/loglocal/ mostly to simulate how /:tracelocal/ in ticket #2737 would help. I was also trying how full tracing is helping. In both cases the answer is: full tracing almost never helps. /:tracelocal/ from ticket #2737 as proposed originally would rarely help. The problem is that trace log gets overwhelmed with crap when we cannot control what can be saved in it and what cannot be saved. My idea is that user should be able to specify what can go in it and also what should not go in it. Here is an alternative solution to the ones I proposed in tickets #2737 and #2946. I think this one would be best. The command to control the tracing should look like: -- should everything be traced? :set trace (True|False) -- scopes which should be traced (or should not be traced when ! is present) :set trace ( (!)? scopeid )* -- add/remove individual scopeids to/from the trace specification :set trace (+|-) (!)? scopeid where scopeid = ( conid . )* ( varid . )* varid Notice how scopeid looks. It can have a sequence of varids at the end. The reason is so that user can leave out a scope of a function which is defined in a where clause. The scope specification is similar to the proposal in ticket #3000. E.g. for this code: fn s = 'a' : add s where add = (++"z") it could look like :set trace Main.fn !Main.fn.add meaning trace whole scope of *fn* but not the stuff in the scope of *add. *Order should not be important, requests for not tracing should have precedence before requests to trace. The scopes which we want typically exclude are the ones which contain loops. The loop content often fills in the trace log forcing the interesting stuff out of it. It is better to investigate functions with loops separately in nested context. Notice that there is a bit difference between this proposal of controlling trace content and the one in ticket #2737. #2737 assumes usage of breakpoint arguments to specify a scope. The breakpoint arguments give an ability to define scopes at finer level but there is no option to define exclude scopes which I find important now. The summary is: Trace log is as useful as much you can control what can get in it. The :trace command looks to me like an error. It is better to control it by allowing/disallowing scopes. I also changed my opinion a bit about ticket #2945. :mergetrace would be better than global trace history. Being able to investigate something separately in a nested context is useful. If I should order the ghci debugger related tickets then the order would be like (more important first): #1531 (_result can get bound to the wrong value in a breakpoint) #2737 and #2946 (add :tracelocal to ghci debugger... and add command :mergetrace...) #3000 (:break command should recognize also nonexported top level symbols...) #2803 (bring full top level of a module in scope when a breakpoint is hit in the ...) #1377 (the task: "We should print breakpoint related info only if breakpoint has no commands set") but people debugging interactive console applications would like to have this one the very top; *IIRC* this may be easy to do, looks like all the printing is done in one function (something like afterCmd???); also #2950 looked like trivial to do (like 15 mins without the compile time???) And the last thing: my first time experiences hacking in the /:loglocal/ into ghc. I cannot tell much, I spend with it only one long Sunday afternoon, but here are my two points: * I needed to extend ghc interface. The type of function GHC.resume changed from: resume :: GhcMonad m => SingleStep -> m RunResult to: resume :: GhcMonad m => (SrcSpan->Bool) -> SingleStep -> m RunResult ... plus the corresponding implementation change. The added argument is a filtering function to limit source spans which can recorded in the trace history. * It would be cool if ghci has its own dir in the souce tree where only the ghci source files are. It would encourage people to hack it more since it would be easier to maintain private patches and merging upstream. It would be also easier to make sure one modifies only ghci source code so that it works with other ghc releases. Hopefully this helps somebody, Peter.

7 18

Int vs Word performance?
by Claus Reinke 01 Mar '09

01 Mar '09

Looking at prelude/PrelRules.hs has reminded me of an old conundrum: if I switch from Int to Word, should I expect any performance differences? A while ago, I needed lots of fairly small positive numbers, together with a small number of flags for each, so I thought I'd switch from Int to Word, and map the flags to bits. But the performance dropped so drastically that I went back to Int, slightly complicating the bitmaps. I didn't expect that, and I can't see any builtin rules for Int that would have no Word counterpart. Here is a trivial example with drastic difference between T = Int and T = Word (~2.5x here): main = print $ foldl' (+) 0 [1..100000000::T] What am I missing here? Also, in the real code I ended up seeing things like this in the -ddump-simpl output for the bit-fiddling code: GHC.Prim.word2Int# (GHC.Prim.and# (GHC.Prim.int2Word# wild13_XbE) (GHC.Prim.int2Word# y#_a4EZ)) Is that likely to cost me a lot or are these conversions cheap? Claus

5 12

ghc crashes on strange foreign import
by Ben Franksen 27 Feb '09

27 Feb '09

This is the code: {-# OPTIONS -fglasgow-exts #-} import Foreign type X u = Ptr () foreign import ccall bla :: (forall u. X u) -> IO () I know of course that I must not use fancy types in foreign imports. I forgot for a moment and instead of an error message got: ben@sarun> ghci Bug3 GHCi, version 6.10.1: http://www.haskell.org/ghc/ :? for help Loading package ghc-prim ... linking ... done. Loading package integer ... linking ... done. Loading package base ... linking ... done. [1 of 1] Compiling Main ( Bug3.hs, interpreted ) ghc: panic! (the 'impossible' happened) (GHC version 6.10.1 for i386-unknown-linux): unboxArg: Bug3.hs:4:0-51 forall u{tv aht} [tv]. main:Main.X{tc rhp} u{tv aht} [tv] Please report this as a GHC bug: http://www.haskell.org/ghc/reportabug Cheers Ben

1 0

Suggestion for bang patterns documentation
by Brian Bloniarz 27 Feb '09

27 Feb '09

I got confused by the GHC documentation recently, I was wondering how it could be improved. From: http://www.haskell.org/ghc/docs/latest/html/users_guide/bang-patterns.html > A bang only really has an effect if it precedes a variable or wild-card pattern: > f3 !(x,y) = [x,y] > f4 (x,y) = [x,y] > Here, f3 and f4 are identical; putting a bang before a pattern that > forces evaluation anyway does nothing. The first sentence is true, but only in settings where the pattern is being evaluated eagerly -- the bang in: > f3 a = let !(x,y) = a in [1,x,y] > f4 a = let (x,y) = a in [1,x,y] has an effect. The first time I read this, I took the first sentence to be a unqualified truth and ended up thinking that !(x,y) was equivalent to (x,y) everywhere. Stuff that comes later actually clarifies this, but I missed it. What about making the distinction clear upfront? Something like: > A bang in an eager pattern match only really has an effect if it precedes a variable > or wild-card pattern: > f3 !(x,y) = [x,y] > f4 (x,y) = [x,y] > Because f4 _|_ will force the evaluation of the pattern match anyway, f3 and f4 > are identical; the bang does nothing. It also might be a good idea to immediately follow this with the let/where usage: > A bang can also preceed a let/where binding to make the pattern match strict. For example: > let ![x,y] = e in b > is a strict pattern... (in the existing docs, let comes a bit later): Just a thought. Hopefully someone can come up with a better way of wording what I'm getting at. Thanks, -Brian _________________________________________________________________ Windows Live™ Hotmail®…more than just e-mail. http://windowslive.com/howitworks?ocid=TXT_TAGLM_WL_t2_hm_justgotbetter_how…

3 5

Type (class) recursion + families = exponential compile time?
by Ben Franksen 27 Feb '09

27 Feb '09

Hi the attached module is a much reduced version of some type-level assurance stuff (inspired by the Lightweight Monadic Regions paper) I am trying to do. I am almost certain that it could be reduced further but it is late and I want to get this off my desk. Note the 4 test functions, test11 .. test14. The following are timings for compiling the module only with all test functions commented out, except respectively, test11, test12, test13, and test14: ben@sarun[1] > time ghc -c Bug2.hs ghc -c Bug2.hs 1,79s user 0,04s system 99% cpu 1,836 total ben@sarun[1] > time ghc -c Bug2.hs ghc -c Bug2.hs 5,87s user 0,14s system 99% cpu 6,028 total ben@sarun[1] > time ghc -c Bug2.hs ghc -c Bug2.hs 23,52s user 0,36s system 99% cpu 23,899 total ben@sarun[1] > time ghc -c Bug2.hs ghc -c Bug2.hs 102,20s user 1,32s system 97% cpu 1:45,89 total It seems something is scaling very badly. You really don't want to wait for a version with 20 levels of nesting to compile... If anyone has a good explanation for this, I'd be grateful. BTW, I am not at all certain that this is ghc's fault, it may well be my program, i.e. the constraints are too complex, whatever. I have no idea how hard it is for the compiler to do all the unification. Also, the problem is not of much practical relevance, as no sensible program will use more than a handfull levels of nesting. Cheers Ben

3 2

optimization and rewrite rules questions
by Claus Reinke 26 Feb '09

26 Feb '09

In the recently burried haskell-cafe thread "speed: ghc vs gcc", Bulat pointed out some of the optimizations that GHC doesn't do, such as loop unrolling. I suggested a way of experimenting with loop unrolling, using template haskell to bypass GHC's blindspot (it usually doesn't unfold recursive definitions http://www.haskell.org/pipermail/glasgow-haskell-users/2007-July/012936.html , but if we unfold a loop combinator at compile time, GHC's normal optimizations can take over from there): http://www.haskell.org/pipermail/haskell-cafe/2009-February/056241.html While this is fine as far as it goes (it should really be handled within GHC), and does offer some initial speedup, Bulat pointed out that GCC does further optimizations after unrolling, such as reassociating sums to expose potential for constant folding: http://www.haskell.org/pipermail/haskell-cafe/2009-February/056367.html (since the ghc -ddump-simpl output doesn't show this optimization, I assume that gcc handles it, and the "*ghc*" in that message is a typo, but haven't checked - how would I do that, btw?). In this case, GHC optimizations following the loop unrolling leave a sum like (note the repeated variable interspersed with constants) (GHC.Prim.+# (GHC.Prim.+# ww_s1lN 3) (GHC.Prim.+# (GHC.Prim.+# ww_s1lN 2) (GHC.Prim.+# (GHC.Prim.+# ww_s1lN 1) (GHC.Prim.+# (GHC.Prim.+# ww_s1lN 0) ww_s1lR)))))))) which can be simplified (assuming associativity and commutativity of + here..) after sorting the variable references and constants into separate groups. We currently inherit such optimizations when using -fvia-C, even though GHC sometimes produces C code that GCC can't handle optimally. If I understand correctly, -fvia-C is on its way out - is that correct, and what plans are there for recovering the optimizations previously left to GCC? The next thing I was looking at was rewrite rules, the obvious GHC tool for implementing this kind of rule (var+const1)+(var+const2) ==> 2*var + const3 and I ran into more questions: - can RULES left-hand sides test for variables (I don't want to reassociate sums randomly, that wouldn't terminate; instead, I want to float out subterms that are non-variable, and group repeated variables)? - is there any way to control the rewrite strategy, similar to strategy combinators (if rules are applied all over the place, they introduce new structure not covered by rules; if I could limit the strategy to top-down, or bottom-up, I could at least cover some special cases)? - how would one handle this kind of optimization in GHC in full generality? wait for compiler plugins? are there features of rewrite rules that I'm missing? would it make sense to flag rewrite rules system improvements as a GHC GSoC project, given that GHC will have to pull its weight there when moving away from GCC? Claus

3 5