May 2007 - Glasgow-haskell-users

Re: Wanted: warning option for usages of unary minus
by John Meacham 18 May '07

18 May '07

On Thu, May 17, 2007 at 06:40:04PM +0200, Twan van Laarhoven wrote: > Simon Marlow wrote: > >... > > > >Really? I'm beginning to have second thoughts about the proposed change > >to negation for Haskell'. The main reason, and this isn't pointed out > >as well as it should be on the wiki, is that "x-1" will cease to be an > >infix application of (-), it will parse as x applied to the literal > >(-1). And this is different from "x - 1" > > There is one other alternative for parsing: > "-" is a unary minus if and only if it is > a) preceded by whitespace or one of "[({;,", and > b) not followed by whitespace. > > So: > x - 1 == (-) x 1 > x-1 == (-) x 1 > x -1 == x (negate 1) > x -(1) == x (negate 1) > x (-1) == x (negate 1) > x (- 1) == x (\y -> y - 1) also (c) has a digit after it. also note that a big point of this is that we can get rid of 'negate' in the translation, so the literal -1 now desugars to (fromInteger -1) rather than the current (negate (fromInteger 1)) (which requires 2 dictionary lookups for a simple constant! sigh. we also have the option of removing negate from the 'Num' class if so desired. John -- John Meacham - ⑆repetae.net⑆john⑈

1 0

Libraries makefile
by Stefan Holdermans 17 May '07

17 May '07

I noticed that the makefile in ghc/libraries is changed recently--- could it be broken? When building GHC HEAD on Mac OS X (Darwin, Power PC), I got: ... make -C libraries boot rm -f -rf bootstrapping.Cabal cp -R Cabal bootstrapping.Cabal bootstrapping.Cabal $ -name "*.o" -o -name "*.hi" $ \ -exec rm -f -f {} \; /bin/sh: line 1: bootstrapping.Cabal: command not found make[1]: *** [stamp/bootstrapping.Cabal] Error 127 make: *** [stage1] Error 2

1 0

Re: Wanted: warning option for usages of unary minus
by Isaac Dupree 17 May '07

17 May '07

-----BEGIN PGP SIGNED MESSAGE----- Hash: SHA1 Twan van Laarhoven wrote: > There is one other alternative for parsing: > "-" is a unary minus if and only if it is > a) preceded by whitespace or one of "[({;,", and > b) not followed by whitespace. > > So: > x - 1 == (-) x 1 > x-1 == (-) x 1 > x -1 == x (negate 1) > x -(1) == x (negate 1) > x (-1) == x (negate 1) > x (- 1) == x (\y -> y - 1) > > Just an idea. Indeed, and in some language syntax designs it would certainly be a good system for prefix operators. Existing parsers may have some difficulty. How about > {-comment-}-1 ? how about > WeirdNumber{value=2,weird=True}-1 ? Although likely to make any actual code work, it seems a bit complicated from the mindset of current Haskell parsing/lexing. "(b) not followed by whitespace." can be replaced by (b) followed by a digit if desired not to allow it for negating arbitrary expressions. Isaac -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.6 (GNU/Linux) Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org iD8DBQFGTJRgHgcxvIWYTTURAqpMAJ9rpCFwzOG/ZSF0qpM/hD/mFKrQ1wCfSRCK 2nKiBzRs/8thmgrdBT+SowA= =lFCl -----END PGP SIGNATURE-----

1 0

All warnings but type signatures
by Joel Reymont 13 May '07

13 May '07

Is there a way to enable all warnings but the following: Hope/Item/DBDesc.hs:6:0: Warning: Definition but no type signature for `item_db' Overall, is there an advantage to type signatures in GHC as opposed to letting the compiler derive them? Thanks, Joel -- http://wagerlabs.com/

3 2

{-# INLINE me_harder #-}
by Duncan Coutts 13 May '07

13 May '07

So I'm trying to program the GHC term rewriting system again (ie the mighty simplifier) and it's not doing what I want it to do without me using unnecessarily large hammers. The crux is that I have a simple function that I want to be inlined early so that my other rules can match on the thing it expands into, however despite the {-# INLINE #-} pragma, it doesn't get inlined until a much later phase when it's too late for the rule to match. So currently I'm forced to use {-# RULES #-} to achieve the same effect, ie expanding the definition in an early phase. This feel like a hack of course. So either the INLINE heuristics could be tweaked to make these cases work or perhaps we should consider adding some other pragma for when we don't want to go by heuristics but are instead deliberately trying to do term rewriting. Anyway, here's the example. It's binary deserialisation. We have a couple important primitives: read :: Int -> (Ptr Word8 -> IO a) -> Get a and the applicative combinators (<$>) (<*>) for Get: fmapGet :: (a -> b) -> Get a -> Get b apGet :: Get (a -> b) -> Get a -> Get b So that we'll be able to match on these, we delay their inlining: {-# INLINE [0] apGet #-} {-# INLINE [0] fmapGet #-} {-# INLINE [0] read #-} The important rules linking these are: {-# RULES "fmap/read" forall f n a. f `fmapGet` read n a = ... "read/read" forall n m f x. read n f `apGet` read m x = ... #-} and finally we have: word8 :: Get Word8 word8 = read 1 peek {-# INLINE word8 #-} So when we write something like: foo :: Get (Word8,Word8,Word8) foo = (,,) <$> Get.word8 <*> Get.word8 <*> Get.word8 we want to expand word8 into it's definition in terms of read and then have the rules fire (which shares the bounds checks). Looking at the simplifier iterations we get to this step: ==================== Simplifier phase 2, iteration 1 out of 4 ==================== PutTest.foo :: Get.Get (GHC.Word.Word8, GHC.Word.Word8, GHC.Word.Word8) [Exported] [] PutTest.foo = Get.apGet @ GHC.Word.Word8 @ (GHC.Word.Word8, GHC.Word.Word8, GHC.Word.Word8) (Get.apGet @ GHC.Word.Word8 @ (GHC.Word.Word8 -> (GHC.Word.Word8, GHC.Word.Word8, GHC.Word.Word8)) (Get.fmapGet @ GHC.Word.Word8 @ (GHC.Word.Word8 -> GHC.Word.Word8 -> (GHC.Word.Word8, GHC.Word.Word8, GHC.Word.Word8)) (Data.Tuple.(,,) @ GHC.Word.Word8 @ GHC.Word.Word8 @ GHC.Word.Word8) Get.word8) Get.word8) Get.word8 Here is where we really must inline word8 or we're going to miss our opportunity once apGet and fmapGet get inlined. Sadly it doesn't inline it here (in phase 2), or in the next phase (in fact it does nothing in phase 1 at all). We get all the way to phase 0 and then go and inline everything (including word8). The behaviour is the same for 6.6 and 6.7.recentish (one month old). If we hit word8 with a bigger hammer: {-# RULES "inline word8" word8 = read 1 peekWord8 #-} then the whole thing works perfectly and we get really nice STG code at the end. I was under the impression that GHC considered a function more 'interesting' if it was mentioned in the LHS of a rule as is the case here. What is the right thing for me to do in this case? Just use the rule to do the inlining? The full source is here: http://haskell.org/~duncan/binary/ Get.hs and GetTest.hs (In the same dir is an example showing the opposite problem, GHC inlining a function when I asked explicitly for it not to. I reported that problem previously. Though I now realise I never filed a bug in trac for that one. I'll file bugs for both.) On the good news side, I'm getting excellent performance results for the serialisation and judging from the STG code for the deserialisation I expect it'll be great too. Duncan

4 7

non-owner-writable files generated in ghc build process?
by Isaac Dupree 12 May '07

12 May '07

-----BEGIN PGP SIGNED MESSAGE----- Hash: SHA1 When I was doing `rm -r` on a build tree it pointed out that driver/split/ghc-split.prl and driver/mangler/ghc-asm.prl were write-protected. Tacking this down, they're generated from .lprl with unlit... then (in mk/suffix.mk) they are `chmod 444`-ed. Is this a problem? Is the purpose to remind people that those are generated files, so don't change them? (hmm... if someone has a restrictive umask like 027, will this circumvent it? would `chmod -w` make more sense?) I know, I can use `rm -rf` in order to unquestioningly follow UNIX permissions model... Isaac -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.6 (GNU/Linux) Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org iD8DBQFGNJmgHgcxvIWYTTURAs5IAKCw5ND5vKLimSkIaclz5onqnNHVyACeKCPq bBtTcqD+/qoG3gnDcAtLHc0= =PUgp -----END PGP SIGNATURE-----

3 3

GHC 6.6.1 Windows installer, test version
by Neil Mitchell 11 May '07

11 May '07

Hi, I've prepared a GHC 6.6.1 Windows installer. Before I offer this up as an official installer, could people please test it? http://www.haskell.org/ghc/dist/6.6.1/ghc-6.6.1-i386-windows-test1.exe The new features of this installer (relative to the 6.6 one) are: * Prettier .hs icons * Automatically adds GHC and Cabal binaries to the %PATH% * 10Mb smaller (better compression) Thanks to Duncan for answering installer related questions. Neil

5 20

ghc-6.6.1 win32 msi available
by Sigbjorn Finne 11 May '07

11 May '07

In case anyone's interested, http://www.galois.com/~sof/msi/ghc-6-6-1.msi contains a Windows installer for 6.6.1; most (all?) libraries/ are in there; no C++ bits (sorry.) enjoy --sigbjorn [And, if it's your preference, a ghc-6-6-1.zip is also available from that same dir.]

3 3

More speed please!
by Duncan Coutts 11 May '07

11 May '07

All, So here's the Put monad for the binary serialisation stuff: newtype Put a = Put { runPut :: (a -> Buffer -> [B.ByteString]) -> Buffer -> [B.ByteString] } data Buffer = Buffer {-# UNPACK #-} !(ForeignPtr Word8) {-# UNPACK #-} !Int -- offset {-# UNPACK #-} !Int -- used bytes {-# UNPACK #-} !Int -- length left This is all good, and pretty quick. Code like the following gets turned into great low level code: foo :: Word8 -> Put () foo !n = do word8 n word8 (n+1) word8 (n+17) It does a straight line sequence of writes into memory (there are rules that combine the bounds checking of adjacent writes). After that it calls the continuation with a new buffer. While almost everything is unboxed, the parameters to the continuation are not unboxed. So we have to allocate a new Buffer structure and pass that to the continuation: let { sat_s1F8 = NO_CCS PutMonad.Buffer! [ww1_s1Es ww2_s1Et ww3_s1Ew sat_s1F4 sat_s1F6]; } in w_s1DY GHC.Base.() sat_s1F8; w_s1DY being the continuation here. However we know that really the parameters to this continuation could really be unboxed since we construct all these continuations explicitly in this module. We could re-write the monad type by manually explicitly unboxing the Buffer argument: newtype Put a = Put { runPut :: (a -> Addr# -> ForeignPtrContents -> Int# -> Int# -> Int# -> [B.ByteString]) -> Addr# -> ForeignPtrContents -> Int# -> Int# -> Int# -> [B.ByteString] } Then we'd get no allocations and no heap checks in the fast path. Note that we could still get a continuation in from the 'outside' with the original type and convert it to one with the above type, though obviously that involves unpacking the arguments. This unpacking is basically what the wrapper of a worker/wrapper pair does of course. Obviously this is ugly. We'd much rather write the original and with just a couple annotations get the above representation. This is what I would like to write: newtype Put a = Put { runPut :: (a -> {-# UNPACK #-} !Buffer -> [B.ByteString]) -> {-# UNPACK #-} !Buffer -> [B.ByteString] } So I'm declaring a type and a data constructor that contains a function that is strict in one of it's arguments. I do not wish to distinguish the strictness in the type however, that is it should be perfectly ok to do this: foo :: Foo -> Buffer -> [B.ByteString] Put foo newBuffer :: Put Foo Suppose that in this case we do not know locally that foo is strict and can take it's args unboxed then upon applying the Put constructor we just have to apply a wrapper function that boxes up the args and supplies them to the wrapped function. Obviously that'd be a pessimisation, having to re-box args, however we can expect programmers to only use that UNPACK pragma when they know that it is going to be a win overall. So the ! on the arg is a semantic change and the pragma is a representation change but not a semantic change. The ! means the obvious thing, that the function is strict in that arg. So either the caller or calle must ensure the arg is evaluated to WHNF. Hmm, is the UNPACK actually needed then? Normally when ghc determines that a func is strict in an arg it make the worker unbox that arg if possible and that always seems to be a win. Mine you, in that case we know what the function is going to do with each arg, where as here we do not so perhaps a separate UNPACK makes sense. This issues crops up quite a bit with Monads I think. For example GHC defines it's IO monad to return an unboxed tuple: newtype IO a = IO (State# RealWorld -> (# State# RealWorld, a #)) This is fine for low level internal code, but for everyday monads it'd be nice to be able to write nice code and still get great performance. This applies to monads particularly since they very often fully encapsulate the function used as the internal representation, that is all the sites where the representation function is constructed and taken apart are in a single module. So we can 'see' that all uses are strict in some arg. Or if they're not we might want them to be. So instead of doing an analysis to figure out if we're always using it strictly (which is something that jhc/grin might be able to do?) we can just declare the data representation to be strict like we do with ordinary algebraic data types, that way it propagates strictness to the usage sites which is much more convenient than going around strictifying all the usage sites in an attempt to make an analysis notice that it's safe to do a representation change. Ok, I'm done. :-) Duncan

5 10

GHC as a library - getting output from GHCI
by Mads Lindstrøm 11 May '07

11 May '07

Hi I am trying to use GHC as a library (see http://haskell.org/haskellwiki/GHC/As_a_library ). I want to get all the output from an interactive session and put in a GUI. This http://haskell.org/sitewiki/images/5/51/Interactive.hs seemed to be a nice starting point. However, the result of: GHC.runStmt session stmt does not include the output of evaluating the statement (stmt above) - just the names of bound names. That is if stmt eqauls "3 + 5" then GHC.runStmt do not return a string equaling "8", but just the "it"-name (which is bound to 8). The output is printed to standard output :( And I do not see and easy way to get hold of it. The only way I see, is having the GUI in one process and "GHC as a library" in another process. Do anybody know of an easy way to get hold of the output from "GHC as a library" - the output currently printed to standard output? Greetings, Mads Lindstrøm

5 14