March 2004 - Glasgow-haskell-users

ghci can't continue in a situation (HXml Toolbox)
by Ferenc Wagner 11 Mar '04

11 Mar '04

Hello, Please have a look at the transcript below. GHC happily compiles the file with the Makefile, while GHCi chokes on it. I would be grateful for any insight into the problem. Feri. tba:~/haskell/xml/ $ cat xml2wiki.hs import System import XmlInput import XmlTree import XmlState getLength :: String -> XState () Int getLength file = do [xmlTree] <- getXmlContents $ newDocument file io $ putStr $ show xmlTree return 14 main :: IO () main = do [xmlFile] <- getArgs l <- run' $ getLength xmlFile putStrLn (show l) ---------------------------------------------------------------------- tba:~/haskell/xml/ $ cat Makefile HXT := $(HOME)/haskell/xml/HXmlToolbox-3.01 INCLUDES := $(HXT)/hdom:$(HXT)/hparser:$(HXT)/http:$(HXT)/popen:$(HXT)/parsec:$(HOME)/haskell/HTTP PACKAGES := -package util -package net xml2wiki: xml2wiki.hs ghc -o $@ --make -i$(INCLUDES) $(PACKAGES) $< ---------------------------------------------------------------------- tba:~/haskell/xml/ $ cat .ghci :set -package net -package util :set -i/home/wferi/haskell/xml/HXmlToolbox-3.01/hdom:/home/wferi/haskell/xml/HXmlToolbox-3.01/hparser:/home/wferi/haskell/xml/HXmlToolbox-3.01/http:/home/wferi/haskell/xml/HXmlToolbox-3.01/popen:/home/wferi/haskell/xml/HXmlToolbox-3.01/parsec:/home/wferi/haskell/HTTP ---------------------------------------------------------------------- tba:~/haskell/xml/ $ ghci xml2wiki ___ ___ _ / _ \ /\ /\/ __(_) / /_\// /_/ / / | | GHC Interactive, version 6.2, for Haskell 98. / /_\\/ __ / /___| | http://www.haskell.org/ghc/ \____/\/ /_/\____/|_| Type :? for help. Loading package base ... linking ... done. Loading package lang ... linking ... done. Loading package concurrent ... linking ... done. Loading package QuickCheck ... linking ... done. Loading package readline ... linking ... done. Loading package unix ... linking ... done. Loading package posix ... linking ... done. Loading package util ... linking ... done. Loading package network ... linking ... done. Loading package net ... linking ... done. Skipping Zord64_HARD ( /home/wferi/haskell/HTTP/Zord64_HARD.lhs, /home/wferi/haskell/HTTP/Zord64_HARD.o ) Skipping ParsecPos ( /home/wferi/haskell/xml/HXmlToolbox-3.01/parsec/ParsecPos.hs, /home/wferi/haskell/xml/HXmlToolbox-3.01/parsec/ParsecPos.o ) Skipping ParsecError ( /home/wferi/haskell/xml/HXmlToolbox-3.01/parsec/ParsecError.hs, /home/wferi/haskell/xml/HXmlToolbox-3.01/parsec/ParsecError.o ) Skipping ParsecPrim ( /home/wferi/haskell/xml/HXmlToolbox-3.01/parsec/ParsecPrim.hs, /home/wferi/haskell/xml/HXmlToolbox-3.01/parsec/ParsecPrim.o ) Skipping ParsecChar ( /home/wferi/haskell/xml/HXmlToolbox-3.01/parsec/ParsecChar.hs, /home/wferi/haskell/xml/HXmlToolbox-3.01/parsec/ParsecChar.o ) Skipping ParsecCombinator ( /home/wferi/haskell/xml/HXmlToolbox-3.01/parsec/ParsecCombinator.hs, /home/wferi/haskell/xml/HXmlToolbox-3.01/parsec/ParsecCombinator.o ) Skipping Base64 ( /home/wferi/haskell/xml/HXmlToolbox-3.01/http/Base64.hs, /home/wferi/haskell/xml/HXmlToolbox-3.01/http/Base64.o ) Skipping MD5 ( /home/wferi/haskell/HTTP/MD5.lhs, /home/wferi/haskell/HTTP/MD5.o ) Skipping AssocList ( /home/wferi/haskell/xml/HXmlToolbox-3.01/hdom/AssocList.hs, /home/wferi/haskell/xml/HXmlToolbox-3.01/hdom/AssocList.o ) Skipping NTree ( /home/wferi/haskell/xml/HXmlToolbox-3.01/hdom/NTree.hs, /home/wferi/haskell/xml/HXmlToolbox-3.01/hdom/NTree.o ) Skipping Util ( /home/wferi/haskell/xml/HXmlToolbox-3.01/hdom/Util.hs, /home/wferi/haskell/xml/HXmlToolbox-3.01/hdom/Util.o ) Skipping Unicode ( /home/wferi/haskell/xml/HXmlToolbox-3.01/hparser/Unicode.hs, /home/wferi/haskell/xml/HXmlToolbox-3.01/hparser/Unicode.o ) Skipping Parsec ( /home/wferi/haskell/xml/HXmlToolbox-3.01/parsec/Parsec.hs, /home/wferi/haskell/xml/HXmlToolbox-3.01/parsec/Parsec.o ) Skipping XmlCharParser ( /home/wferi/haskell/xml/HXmlToolbox-3.01/hparser/XmlCharParser.hs, /home/wferi/haskell/xml/HXmlToolbox-3.01/hparser/XmlCharParser.o ) Skipping POpen ( /home/wferi/haskell/xml/HXmlToolbox-3.01/popen/POpen.hs, /home/wferi/haskell/xml/HXmlToolbox-3.01/popen/POpen.o ) Skipping HTTP ( /home/wferi/haskell/xml/HXmlToolbox-3.01/http/HTTP.hs, /home/wferi/haskell/xml/HXmlToolbox-3.01/http/HTTP.o ) Skipping Browser ( /home/wferi/haskell/xml/HXmlToolbox-3.01/http/Browser.hs, /home/wferi/haskell/xml/HXmlToolbox-3.01/http/Browser.o ) Skipping XmlTreeTypes ( /home/wferi/haskell/xml/HXmlToolbox-3.01/hdom/XmlTreeTypes.hs, /home/wferi/haskell/xml/HXmlToolbox-3.01/hdom/XmlTreeTypes.o ) Skipping XmlKeywords ( /home/wferi/haskell/xml/HXmlToolbox-3.01/hdom/XmlKeywords.hs, /home/wferi/haskell/xml/HXmlToolbox-3.01/hdom/XmlKeywords.o ) Skipping XmlTreeFunctions ( /home/wferi/haskell/xml/HXmlToolbox-3.01/hdom/XmlTreeFunctions.hs, /home/wferi/haskell/xml/HXmlToolbox-3.01/hdom/XmlTreeFunctions.o ) Skipping XmlTreeFilter ( /home/wferi/haskell/xml/HXmlToolbox-3.01/hdom/XmlTreeFilter.hs, /home/wferi/haskell/xml/HXmlToolbox-3.01/hdom/XmlTreeFilter.o ) Skipping MonadStateIO ( /home/wferi/haskell/xml/HXmlToolbox-3.01/hdom/MonadStateIO.hs, /home/wferi/haskell/xml/HXmlToolbox-3.01/hdom/MonadStateIO.o ) Skipping XmlTree ( /home/wferi/haskell/xml/HXmlToolbox-3.01/hdom/XmlTree.hs, /home/wferi/haskell/xml/HXmlToolbox-3.01/hdom/XmlTree.o ) Skipping XmlState ( /home/wferi/haskell/xml/HXmlToolbox-3.01/hdom/XmlState.hs, /home/wferi/haskell/xml/HXmlToolbox-3.01/hdom/XmlState.o ) Skipping FormatXmlTree ( /home/wferi/haskell/xml/HXmlToolbox-3.01/hdom/FormatXmlTree.hs, /home/wferi/haskell/xml/HXmlToolbox-3.01/hdom/FormatXmlTree.o ) Skipping XmlOutput ( /home/wferi/haskell/xml/HXmlToolbox-3.01/hparser/XmlOutput.hs, /home/wferi/haskell/xml/HXmlToolbox-3.01/hparser/XmlOutput.o ) Skipping XmlParser ( /home/wferi/haskell/xml/HXmlToolbox-3.01/hparser/XmlParser.hs, /home/wferi/haskell/xml/HXmlToolbox-3.01/hparser/XmlParser.o ) Skipping XmlInput ( /home/wferi/haskell/xml/HXmlToolbox-3.01/hparser/XmlInput.hs, /home/wferi/haskell/xml/HXmlToolbox-3.01/hparser/XmlInput.o ) Compiling Main ( xml2wiki.hs, interpreted ) Ok, modules loaded: Main, XmlInput, XmlParser, XmlOutput, FormatXmlTree, XmlState, XmlTree, MonadStateIO, XmlTreeFilter, XmlTreeFunctions, XmlKeywords, XmlTreeTypes, Browser, HTTP, POpen, XmlCharParser, Parsec, Unicode, Util, NTree, AssocList, MD5, Base64, ParsecCombinator, ParsecChar, ParsecPrim, ParsecError, ParsecPos, Zord64_HARD. *Main> run' $ getLength "texi2/lilypond.xml" Loading package haskell98 ... linking ... done. GHCi runtime linker: fatal error: I found a duplicate definition for symbol __stginit_POpen whilst processing object file /home/wferi/haskell/xml/HXmlToolbox-3.01/popen/POpen.o This could be caused by: * Loading two different object files which export the same symbol * Specifying the same object file twice on the GHCi command line * An incorrect `package.conf' entry, causing some object to be loaded twice. GHCi cannot safely continue in this situation. Exiting now. Sorry.

2 2

RE: Overlapping instances and multi-parameter classes
by Simon Peyton-Jones 11 Mar '04

11 Mar '04

I had a look. It turns out to be an utterly bogus and incorrect test for overlap in 6.2. As it happens, I've already re-written that part of the compiler in the HEAD, to do lazy overlap resolution. In GHC 6.2 the instances instance C a Bool instance C Bool a are rejected because they overlap (unless you have -fallow-overlapping-instances). In GHC HEAD the instances are not rejected. Reason: if we are seeking an instance declaration matching (C Bool Int) then plainly only one of the instances match. So GHC HEAD reports overlap only if a lookup finds two matching instances, rather than when the instance declarations themselves are declared. Kind of like lazy reporting of overlap of unqualified names in the module system. Anyway, it happens that I'd inadvertently thereby fixed the bug you found. Since it's rather a dark corner, I don't propose to fix it for 6.2. Thanks for reporting it though. Simon | -----Original Message----- | From: glasgow-haskell-users-bounces(a)haskell.org [mailto:glasgow-haskell-users- | bounces(a)haskell.org] On Behalf Of Mike Gunter | Sent: 06 March 2004 06:13 | To: glasgow-haskell-users(a)haskell.org | Subject: Overlapping instances and multi-parameter classes | | | | Given the following: | | > | > import Data.Maybe ( fromMaybe ) | > | > data None | > none = error "none evaluated" :: None | | these class and instance declarations: | | > class ToMaybe2 b a where toMaybe2 :: a -> Maybe b | > instance ToMaybe2 a None where toMaybe2 = const Nothing | > instance ToMaybe2 a a where toMaybe2 = Just | | compile fine (given -fallow-undecidable-instances and | -fallow-overlapping-instances). And the following code: | | > mbPutStrLn :: ToMaybe2 String a => a -> IO () | > mbPutStrLn = putStrLn . fromMaybe "None." . toMaybe2 | > main = mbPutStrLn none >> mbPutStrLn "Hello, world!" | | works as I'd expect. However, if the parameters to the class | are reversed: | | > {- uncomment to see error message | > class ToMaybe1 a b where toMaybe1 :: a -> Maybe b | > instance ToMaybe1 None a where toMaybe1 = const Nothing | > instance ToMaybe1 a a where toMaybe1 = Just | > -} | | I get the following error message (from GHC{,i} 6.2): | | Overlapping instance declarations: | OverlapOrder.lhs:27: ToMaybe1 None a | OverlapOrder.lhs:28: ToMaybe1 a a | | Why is this? | | thanks, | mike | _______________________________________________ | Glasgow-haskell-users mailing list | Glasgow-haskell-users(a)haskell.org | http://www.haskell.org/mailman/listinfo/glasgow-haskell-users

1 0

Re: Polymorphic lists...
by MR K P SCHUPKE 10 Mar '04

10 Mar '04

This is the latest varient. Let me know whether you guys find this interesting, as I am coding what I need for a practical application, it may be tedious for you... I am still of the opinion that some kind of polygenious list (or maybe heteromorphic?) would be good in the standard libraries, whether it my code, someone elses or some combination. My initial feeling would be to standardise our function , class and type naming so the different kinds of list/set can be put into the same codebase, possibly aimed at being Data.PolyLists, also what is required to get these in the library - just the code, neat code, a report, or some kind of proposal ? infixr 1 `MCons` data MNil = MNil deriving Show data MCons l a r = a `MCons` r deriving Show class MRelation r instance MRelation MNil instance MRelation r => MRelation (MCons l a r) This is a labelled list. It uses a phantom type to label each node, but it theoretically needs no storage for the label... Standard list functions operate as before, and ignore the phantom type. class MRelation r => MList r where mHead :: MCons l a r -> a mTail :: MCons l a r -> r mIsEmpty :: r -> Bool instance MList MNil where mHead (x `MCons` _) = x mTail (_ `MCons` _) = MNil mIsEmpty MNil = True instance MList r => MList (MCons l a r) where mHead (x `MCons` _) = x mTail (_ `MCons` xs) = xs mIsEmpty (_ `MCons` _) = False I have the usual suspects fold/map/zip/unzip, and natural number lookup coded. This is the nice touch though, an indexed lookup on the phatom type, which finds the Nth occurance of a given type in the list: class (MRelation r,Nat n) => MLookup l n r a | l n r -> a where mLookup :: r -> l -> n -> a instance MRelation r => MLookup l Zero (MCons l a r) a where mLookup (x `MCons` _) _ Zero = x instance MLookup l n r b => MLookup l (Suc n) (MCons l a r) b where mLookup (_ `MCons` xs) l (Suc n) = mLookup xs l n instance MLookup l n r b => MLookup l n (MCons m a r) b where mLookup (_ `MCons` xs) l n = mLookup xs l n heres an example: data Name = Name data Size = Size data Weight = Weight test = MCons Name String (MCons Size Int (MCons Weight Float MNil)) test = "Box" `MCons` 3 `MCons` 1.1 putStrLn $ show $ mLookup test Name zero putStrLn $ show $ mLookup test Size zero putStrLn $ show $ mLookup test Weight zero putStrLn $ show $ mLookup (test `mProduct` test) Name one putStrLn $ show $ mLookup (test `mProduct` test) Weight zero These last two show how to access the labels from the right and left sides of the product when some/all domains have the same name. Regards, Keean.

1 0

Re: Polymorphic lists...
by MR K P SCHUPKE 10 Mar '04

10 Mar '04

Hi Oleg, I like the polymorphic list indexed by Ints... there do seem to be a couple of differences between this and the list indexed by natural numbers. The list indexed by integers cannot determine the type of the return value through induction on the class... in other words it cannot determine the return type of the lookup function until runtime: you can see this in the class instance for 'tke' > instance (TH a (a,b), TH W b) => TH W (a,b) where > tke (W 0) th@(h,t) f = f h th > tke (W n) (h,t) f = tke (W$ n-1) t f On the other hand indexing by natural numbers allows the compiler to know the return type (and avoid the use of existentials) because it is determined at compile time... you can see this because the recursion termination is done by the type signatures in the instance not the pattern guards of the function. instance Relation r => RIndex Zero (a `RCons` r) a where rIndex Zero (x `RCons` _) = x instance RIndex Idx r b => RIndex Idx (a `RCons` r) b where rIndex (Suc n) (_ `RCons` xs) = rIndex n xs It looks like most of this stuff has been done before... but I don't think there is any of it in the ghc libraries. I needed this code for a real application, and could not find anything suitable so I rolled my own. What do people think - is there a case for getting this stuff in the libs, should we write a functional pearl? does anyone have any comments about the code I posted, or how it could be improved? To finish, here are some new definitions for map,zip and unzip class Relation r => RMap t r where rMap :: t -> r -> r instance RMap t RNil where rMap _ RNil = RNil instance (RMapFn t a,RMap t r) => RMap t (a `RCons` r) where rMap t (x `RCons` xs) = rMapFn t x `RCons` rMap t xs class RMapFn t a where rMapFn :: t -> a -> a data RMapId = RMapId instance RMapFn RMapId a where rMapFn RMapId a = a class (Relation r1,Relation r2,Relation r3) => RZip r1 r2 r3 | r1 r2 -> r3 where rZip :: r1 -> r2 -> r3 instance RZip RNil RNil RNil where rZip _ _ = RNil instance RZip r1 r2 r3 => RZip (a `RCons` r1) (b `RCons` r2) ((a,b) `RCons` r3) where rZip (x `RCons` xs) (y `RCons` ys) = (x,y) `RCons` rZip xs ys class (Relation r1,Relation r2,Relation r3) => RUnZip r1 r2 r3 | r1 -> r2 r3 where rUnZip :: r1 -> (r2,r3) instance RUnZip RNil RNil RNil where rUnZip _ = (RNil,RNil) instance RUnZip r1 r2 r3 => RUnZip ((a,b) `RCons` r1) (a `RCons` r2) (b `RCons` r3) where rUnZip ((x,y) `RCons` xys) = (x `RCons` xs,y `RCons` ys) where (xs,ys) = rUnZip xys and finally a lookup that indexes by the left type of a pair and returns the right type & value stored in a polymorphic list: class Relation r => RLookup r l v | r l -> v where rLookup :: r -> l -> v instance Relation r => RLookup ((l,v) `RCons` r) l v where rLookup ((_,v) `RCons` _) _ = v instance RLookup r l v => RLookup ((l',v') `RCons` r) l v where rLookup (_ `RCons` r) l = rLookup r l Regards, Keean Schupke.

2 1

RE: confused by core
by Simon Marlow 10 Mar '04

10 Mar '04

> If I have this Foo.hs: > > ------------------------------- > module Foo (foo) where > > import Word (Word8) > import Control.Monad.ST (ST) > import Data.Array.ST (STUArray, writeArray) > > foo :: STUArray s Int Word8 -> [Word8] -> Int -> ST s () > foo arr ps i = writeArray arr i w > where i' = 4 * i > w = ps !! i' > ------------------------------- > > and I compile with (GHC 6.2 and a reasonably recent CVS) > > ghc -O -funbox-strict-fields -Wall -c Foo.hs -ddump-simpl > > then part of the output is: > > let { > n :: GHC.Prim.Int# > Str: DmdType > n = GHC.Prim.*# 4 ww3 > } in > case GHC.Prim.<# n 0 of wild1 { > > Is this really a lazy let, or is there some magic going on > that means it is actually done strictly as it's an Int#? Yes, this let will be done strictly. Indeed, any let which is sure to be demanded (according to the Demand value of the Id) will turn into a case in STG, and similarly for an expression in the argument position of a strict function call. I believe the motivation was that this makes things much easier for the simplifier, but Simon PJ will be able to elaborate I'm sure. > Like how ISTR Int#s always > appear to have strictness L (these inconsitencies make things > much more difficult as a user IMO, incidentally). ISTR? Cheers, Simon

2 1

RE: confused by core
by Simon Peyton-Jones 10 Mar '04

10 Mar '04

| > let { | > n :: GHC.Prim.Int# | > Str: DmdType | > n = GHC.Prim.*# 4 ww3 | > } in | > case GHC.Prim.<# n 0 of wild1 { | > | > Is this really a lazy let, or is there some magic going on | > that means it is actually done strictly as it's an Int#? | | Yes, this let will be done strictly. Indeed, any let which is sure to | be demanded (according to the Demand value of the Id) will turn into a | case in STG, and similarly for an expression in the argument position of | a strict function call. | | I believe the motivation was that this makes things much easier for the | simplifier, but Simon PJ will be able to elaborate I'm sure. Yes, that's right. A strict let, where the RHS is just a primop that can't fault, is left as a let rather than being expressed as a case, because it can be 'floated' easily to somewhere else, or inlined. A 'case' says "do this here and now" and is much less mobile. But when the type is unboxed, the let is indeed done eagerly. It's a slight hack really. We could have Rec NonRec Unboxed as three forms of binding, but currently the latter are combined into NonRec and distinguished by type. Simon

1 0

Re: Polymorphic lists...
by MR K P SCHUPKE 09 Mar '04

09 Mar '04

Didn't know If I should post it straight away... its quite long and I dont do attachments (well not If I can help it. I am aware Dynamic can model heterogenious lists (thanks for correct terminology) - but I need static typing. Thats the clever thing about this code - the list is heterogenious but statically typed. So... for your perusal - and If its not up to being included in the libraries I would value any comments/code review for my own edification. The module is called "Relation" as I am modelling Relational Algebra... but if anyone can think of a better name... First some examples: putStrLn $ show (rIndex two rel1) -- show the third item in rel1 putStrLn $ show (rHead r) putStrLn $ show (rTail r) putStrLn $ show (rLast r) putStrLn $ show (rInit r) putStrLn $ show (r `rEnqueue` "TEST3") -- insert the string into the last (not head) position putStrLn $ show ((3 :: Int) `RCons` r) -- insert the Int into the head of the list r = toTuple (( 1.1 :: Double) `RCons` (fromTuple ("hello",1,"World"))) And the code: {-# OPTIONS -fglasgow-exts #-} {-# OPTIONS -fallow-undecidable-instances #-} {-# OPTIONS -fallow-overlapping-instances #-} module Lib.DBC.Relation where ------------------------------------------------------------------------------ -- (c) 2004 Keean Schupke, All Rights Reserved. ------------------------------------------------------------------------------ data Zero = Zero deriving Show data Suc n = Suc n deriving Show class Nat n instance Nat Zero instance Nat n => Nat (Suc n) zero :: Zero zero = Zero one :: Suc Zero one = Suc zero two :: Suc (Suc Zero) two = Suc one three :: Suc (Suc (Suc Zero)) three = Suc two four :: Suc (Suc (Suc (Suc Zero))) four = Suc three five :: Suc (Suc (Suc (Suc (Suc Zero)))) five = Suc four ------------------------------------------------------------------------------ infixr 1 `RCons` data RNil = RNil deriving Show data RCons a r = a `RCons` r deriving Show ------------------------------------------------------------------------------ class Relation r where rHead :: a `RCons` r -> a rTail :: a `RCons` r -> r rIsEmpty :: r -> Bool instance Relation RNil where rHead (x `RCons` _) = x rTail (_ `RCons` _) = RNil rIsEmpty RNil = True instance Relation r => Relation (a `RCons` r) where rHead (x `RCons` _) = x rTail (_ `RCons` xs) = xs rIsEmpty (_ `RCons` _) = False class RLast r a | r -> a where rLast :: r -> a instance RLast (a `RCons` RNil) a where rLast (x `RCons` RNil) = x instance RLast r b => RLast (a `RCons` r) b where rLast (_ `RCons` xs) = rLast xs class RInit r1 r2 | r1 -> r2 where rInit :: r1 -> r2 instance RInit (a `RCons` RNil) RNil where rInit (_ `RCons` RNil) = RNil instance RInit (b `RCons` r1) r2 => RInit (a `RCons` b `RCons` r1) (a `RCons` r2) where rInit (x `RCons` xs) = x `RCons` rInit xs class REnqueue r1 r2 a | r1 a -> r2 where rEnqueue :: r1 -> a -> r2 instance REnqueue RNil (a `RCons` RNil) a where rEnqueue RNil y = y `RCons` RNil instance REnqueue r1 r2 b => REnqueue (a `RCons` r1) (a `RCons` r2) b where rEnqueue (x `RCons` xs) y = x `RCons` rEnqueue xs y class (Nat n,Relation r) => RIndex n r a | n r -> a where rIndex :: n -> r -> a instance Relation r => RIndex Zero (a `RCons` r) a where rIndex Zero (x `RCons` _) = x instance RIndex n r b => RIndex (Suc n) (a `RCons` r) b where rIndex (Suc n) (_ `RCons` xs) = rIndex n xs infixl 2 `rProduct` class (Relation r1,Relation r2,Relation r3) => RProduct r1 r2 r3 | r1 r2 -> r3 where rProduct :: r1 -> r2 -> r3 instance RProduct RNil RNil RNil where rProduct RNil RNil = RNil instance Relation r => RProduct RNil r r where rProduct RNil r = r instance RProduct r1 r2 r3 => RProduct (a `RCons` r1) r2 (a `RCons` r3) where rProduct (x `RCons` xs) y = x `RCons` (xs `rProduct` y) ------------------------------------------------------------------------------ class Relation r => RTuple t r | t -> r , r -> t where fromTuple :: t -> r toTuple :: r -> t instance RTuple (a,b) (a `RCons` b `RCons` RNil) where fromTuple (a,b) = a `RCons` b `RCons` RNil toTuple (a `RCons` b `RCons` RNil) = (a,b) instance RTuple (a,b,c) (a `RCons` b `RCons` c `RCons` RNil) where fromTuple (a,b,c) = a `RCons` b `RCons` c `RCons` RNil toTuple (a `RCons` b `RCons` c `RCons` RNil) = (a,b,c) instance RTuple (a,b,c,d) (a `RCons` b `RCons` c `RCons` d `RCons` RNil) where fromTuple (a,b,c,d) = a `RCons` b `RCons` c `RCons` d `RCons` RNil toTuple (a `RCons` b `RCons` c `RCons` d `RCons` RNil) = (a,b,c,d) instance RTuple (a,b,c,d,e) (a `RCons` b `RCons` c `RCons` d `RCons` e `RCons` RNil) where fromTuple (a,b,c,d,e) = a `RCons` b `RCons` c `RCons` d `RCons` e `RCons` RNil toTuple (a `RCons` b `RCons` c `RCons` d `RCons` e `RCons` RNil) = (a,b,c,d,e) instance RTuple (a,b,c,d,e,f) (a `RCons` b `RCons` c `RCons` d `RCons` e `RCons` f `RCons` RNil) where fromTuple (a,b,c,d,e,f) = a `RCons` b `RCons` c `RCons` d `RCons` e `RCons` f `RCons` RNil toTuple (a `RCons` b `RCons` c `RCons` d `RCons` e `RCons` f `RCons` RNil) = (a,b,c,d,e,f) ------------------------------------------------------------------------------

3 2

RE: -static
by Simon Marlow 09 Mar '04

09 Mar '04

> On Mon, Mar 08, 2004 at 11:07:07AM -0000, Simon Marlow wrote: > > > > > It causes this when compiling darcs on these arches: > > > > > > /usr/lib/ghc-6.2/libHSunix.a(User.o)(.text+0x2a2c): In > > > function `s6T9_ret': > > > : warning: Using 'getgrgid_r' in statically linked > > > applications requires at runtime the shared libraries from > > > the glibc version used for linking > > > > > > which I assume would lead to too strict dependencies on > glibc being > > > necessary. > > > > What platform? Does everything work if you remove the -static? > > alpha, powerpc and hppa so far. I expect the same will happen for mips > and mipsel. > > If, on powerpc, I run the final link command without -static > (that's the > only place it should make a difference, right?) then it links without > warnings and looks to be working fine. I haven't looked at the others > yet. Wolfgang: can -static be removed on powerpc as far as you know? Cheers, Simon

4 4

Re: Polymorphic lists...
by MR K P SCHUPKE 09 Mar '04

09 Mar '04

I have written a first attempt at a fold function for the heterogenious list: class RFold i r where rFold :: (forall a . a -> i -> i) -> i -> r -> i instance RFold i RNil where rFold f i RNil = i instance RFold i r => RFold i (a `RCons` r) where rFold f i (x `RCons` xs) = f x (rFold f i xs) This works providing the folded 'op' has the type: forall a . a -> i -> i which means it does not work for functions like show :: forall a . Show a => a -> i -> i as the types are different. I have not figured out a way to make it accept a constraint like Show for example. Here is an example: length = rFold (\_ -> (+1)) 0 relation The use of such a function seems limited, if constraints like Show cannot be used, as most useful applications of fold would require some kind of class membership for example: string = rFold shows "" relation This fails to compile because shows has type: shows :: forall a . Show a => a -> i -> i but fold expects op :: forall a . a -> i -> i Regards, Keean Schupke.

2 2

confused by core
by Ian Lynagh 09 Mar '04

09 Mar '04

Hi, If I have this Foo.hs: ------------------------------- module Foo (foo) where import Word (Word8) import Control.Monad.ST (ST) import Data.Array.ST (STUArray, writeArray) foo :: STUArray s Int Word8 -> [Word8] -> Int -> ST s () foo arr ps i = writeArray arr i w where i' = 4 * i w = ps !! i' ------------------------------- and I compile with (GHC 6.2 and a reasonably recent CVS) ghc -O -funbox-strict-fields -Wall -c Foo.hs -ddump-simpl then part of the output is: let { n :: GHC.Prim.Int# Str: DmdType n = GHC.Prim.*# 4 ww3 } in case GHC.Prim.<# n 0 of wild1 { Is this really a lazy let, or is there some magic going on that means it is actually done strictly as it's an Int#? Like how ISTR Int#s always appear to have strictness L (these inconsitencies make things much more difficult as a user IMO, incidentally). Thanks Ian

1 0