- Glasgow-haskell-users

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

Re: [Haskell-cafe] retrospective on 'seq' -> 'unsafeSeq' ?
by pepe 30 Apr '08

30 Apr '08

On 14/04/2008, at 12:19, Simon Peyton-Jones wrote: > | > type constraints accordingly. (Analogously there could be an > unsafeShow that > | > allows showing offending values in an 'error' without adding a > Show > | > constraint to the type signature.) > | > | Ideally, unsafeShow could also show types as they are underneath, > not > | as a pretty-printing Show might show them. I have often wanted to > | overload Show to print things in a readable way, but to have a > showRaw > | which shows things as they are, for debugging purposes. I have even > | written such code for Yhc: > | http://www.cs.york.ac.uk/fp/yhc/snapshot/docs/Yhc-Core-ShowRaw.html > | > | I think unsafeShow is a fantastic idea - and would be much more > useful > | to me than unsafeSeq - plus is a non-breaking change. I think Hugs > | already has 90% of the code to support this, and GHCi's debugger I > | think has a fair chunk of it, so it could be added given not too > much > | work. > > Yes, as you say, the debugger has most of the machinery. I just > don't know what it'd take to make it a callable function. Pepe? > > Someone might want to make a feature-request ticket for this, with > as much background and/or suggested design as poss. unsafeShow sounds quite useful, especially to avoid adding a Show constraint in function signatures only for debugging (of course a decent refactoring tool for Haskell would help with this too, so I hope the HaRe SoC project proposal gets accepted and done!). :print has the code for doing this, but it needs the type information collected by the compiler. In GHC API speak, it needs the HscEnv from the Session object. If we can expose the Session created for GHCi (how? exporting it from GHC.Main? in a thread-local object? FFI trickery?), then this would need nearly zero work, albeit it would print things only when working in GHCi of course. But you can still compile all your modules to object code and call main from GHCi, so I don't think this is a big restriction considering unsafeShow is only for debugging purposes. Another question is where in the package hierarchy would this function live. Since the code it would use is in the ghc package, it would introduce a dependency on it. And I am fairly sure that there is no package in the standard ghc distribution which depends on the ghc package. Ian, can it be made to live in ghc-prim without creating a dependency on the ghc package? Alternatively, with some effort one can create a type-agnostic version of unsafeShow, which would print things in a more raw format, but probably sufficient anyway. I don't think it would work with unboxed values in general, although it can be made to work with the standard types. Actually, Bernie Pope wrote some code for this [1, see GHC Heap Printing library] some time ago, although with the new primitives and changes made for :print in GHC 6.8, this would be way easier nowadays. No need to use StablePtrs, no need to turn on profiling, and above all, no C needed :) And as a bonus this would work out of GHCi too. If there is a clean way to access the Session object, the first option means less implementation work, less code to maintain in GHC, and better functionality. What does the GHC team think? [1] - http://www.cs.mu.oz.au/~bjpop/code.html

3 3

Error Interpreting Main with API
by C.M.Brown 28 Apr '08

28 Apr '08

Hello, I am trying to use the API to interpret a Main module and get some type information from it. However, everytime I try to load a "Main.hs" module using the API I get the following error message: /usr/local/packages/ghc-6.8.2/lib/ghc-6.8.2/libHSrts.a(Main.o): In function `real_main': Main.c:(.text+0x7): undefined reference to `__stginit_ZCMain' Main.c:(.text+0x36): undefined reference to `ZCMain_main_closure' collect2: ld returned 1 exit status If I create an empty file called "Main" within the directory where "Main.hs" is located the program suceeds, I'm guessing this is because there is no linking involved. Is there an extra flag I need to pass to GHC in order to avoid this error? It works perfectly if I try it on a module that is not called Main. main = defaultErrorHandler defaultDynFlags $ do let packageConf = "/usr/local/packages/ghc-6.8.2/lib/ghc-6.8.2" session <- GHC.newSession {-JustTypecheck-} (Just (filter (/= '\n') packageConf)) dflags0 <- getSessionDynFlags session (f1,b) <- parseDynamicFlags dflags0 ["-fglasgow-exts"] setSessionDynFlags session f1{verbosity=6, hscTarget = HscInterpreted} target <- GHC.guessTarget "/home/cmb21//HaRe_Project/testing/subIntroPattern/Main.hs" Nothing hscTarget=HscNothing} GHC.addTarget session target GHC.load session GHC.LoadAllTargets usermod <- findModule session (mkModuleName "Main") Nothing setContext session [usermod] [] return session I hope somebody can share some light! Kind regards, Chris.

3 6

strictness of interpreted haskell implementations
by Geraint Jones 25 Apr '08

25 Apr '08

Are there well-known differences in the implementations of Haskell in ghci and hugs? I've got some moderately intricate code (simulations of pipelined processors) that behave differently - apparently because ghci Haskell is stricter than hugs Haskell, and I cannot find any obviously relevant claims about strictness in the documentation.

4 3

RE: [Haskell] How to define tail function for Even/Odd GADT lists?
by Simon Peyton-Jones 24 Apr '08

24 Apr '08

[Redirecting to ghc-users] You're right that tailList "ought" to work. There are at least two reasons that it doesn't. First, GHC does not have a robust implementation of GADTs + functional dependencies. The interaction is very tricky. So I tried re-expressing it using type families, thus: data Even; data Odd type family Flip a :: * type instance Flip Even = Odd type instance Flip Odd = Even data List a b where Nil :: List a Even Cons :: a -> List a b -> List a (Flip b) tailList :: List a b -> List a (Flip b) tailList (Cons _ xs) = xs (I find the program quite a bit easier to read in this form.) Now I get the error (from the HEAD) Occurs check: cannot construct the infinite type: b = Flip (Flip b) In the pattern: Cons _ xs In the definition of `tailList': tailList (Cons _ xs) = xs There's a bug here -- reporting an occurs check is premature. But there is also a real problem: if you look at the type constraints arising from tailList you'll see that you get c ~ Flip b b ~ Flip c where c is the existential you get from the GADT match. Now, *we* know that b = Flip (Flip b) is always tru, but GHC doesn't. After all, you could add new type instances type instance Flip Int = Bool type instance Flip Bool = Char and then the equation wouldn't hold. The best we can hope for is to get tailList :: (b ~ Flip (Flip b)) => List a b -> List a (Flip b) although this too is rejected at the moment because of the above bug. What we really want is a *closed* type family, like this type family Flip a where Flip Even = Odd Flip Odd = Even (preferably supported by kinds) and even *then* it's not clear whether it's reasonable to expect the compiler to solve the above problem by trying all possibilities. This relates to http://hackage.haskell.org/trac/ghc/ticket/2101 That is probably more than you wanted to know. Since there's a bug here, I'll make a ticket. Simon | -----Original Message----- | From: haskell-bounces(a)haskell.org [mailto:haskell-bounces@haskell.org] On Behalf Of Ahn, Ki Yung | Sent: 23 April 2008 21:33 | To: Haskell(a)haskell.org | Subject: [Haskell] How to define tail function for Even/Odd GADT lists? | | Using GADTs and functional dependencies, we can define GADT lists | that statically distinguishes even length lists from odd length lists. | | > data Even | > data Odd | > | > class Flip b c | b -> c, c -> b where | > | > instance Flip Even Odd where | > instance Flip Odd Even where | > | > data List a b where | > Nil :: List a Even | > Cons :: Flip b c => a -> List a b -> List a c | | For example, | | Nil :: forall a. List a Even | Cons True Nil :: List Bool Odd | Cons False (Cons True Nil) :: List Bool Even | | | We were able to define the function that returns the head. | | > headList :: List a b -> a | > headList (Cons x _) = x | | However, we were not able to write a function that returns the tail. | | > tailList :: Flip b c => List a b -> List a c | > tailList (Cons _ xs) = xs | | Is there a way to define the tailList function within the current | GHC type system implementation (maybe using some other language | extensions), or do we need to improve the type system regarding | GADTs and functional dependencies? | | $ ghci -fglasgow-exts EOlist.hs | GHCi, version 6.8.2: http://www.haskell.org/ghc/ :? for help | Loading package base ... linking ... done. | [1 of 1] Compiling Main ( EOlist.lhs, interpreted ) | | EOlist.lhs:30:25: | Couldn't match expected type `c' against inferred type `b1' | `c' is a rigid type variable bound by | the type signature for `tailList' at EOlist.lhs:29:21 | `b1' is a rigid type variable bound by | the constructor `Cons' at EOlist.lhs:30:12 | Expected type: List a c | Inferred type: List a b1 | In the expression: xs | In the definition of `tailList': tailList (Cons _ xs) = xs | Failed, modules loaded: none. | Prelude> | | Note: You can save this message content as EOList.lhs and load the | script with ghci to observe the type error message above. | _______________________________________________ | Haskell mailing list | Haskell(a)haskell.org | http://www.haskell.org/mailman/listinfo/haskell

1 0

runstmt within API
by C.M.Brown 23 Apr '08

23 Apr '08

Hello, I want to use the ghc evaluator on the fly for some refactorings within HaRe. However, I notice that runstmt ::Session -> String -> IO RunResult. Is there anyway I can grab the result of the evaluated expression as a String (rather than it being outputted to the terminal)? It seems RunResult is defined: data RunResult = RunOk [Name] -- names bound by the expression | RunFailed | RunException GHC.IOBase.Exception If I can't grab its result, is there a way to query the [Name] to get a list of bindings in String format? Preferably something like "it = expression". Kind regards, Chris.

2 2

help with an intriguing problem
by Liang Guang 18 Apr '08

18 Apr '08

Hi! the ghc compiler keeps complaing " can't find module 'Char', perhaps you haven't installed the profiling libraries for package haskell98?". but actually I did install it, and i checked with ghc -v , it is right there: "wired-in package haskell98 mapped to haskell98-1.0.1.0", and Char.hi is right there in the folder haskell98-1.0.1.0.. can't figure out why it happened.. anyone please ? Thanks! Liang --------------------------------- Be a better friend, newshound, and know-it-all with Yahoo! Mobile. Try it now.

3 4

6.8 unable to derive with higher-kinded variable (6.6 could)
by Mike Gunter 18 Apr '08

18 Apr '08

GHC 6.8 seems unable to derive (some?) instances for data types with higher-kinded variables. GHC 6.6 manages these just fine. See below. What's the story? thanks -m :~/haskell$ cat D.hs data T w = T (w Bool) deriving (Show) data ID x = ID x deriving (Show) main = print (T (ID False)) :~/haskell$ ghci -ignore-dot-files -fallow-undecidable-instances D.hs ___ ___ _ / _ \ /\ /\/ __(_) / /_\// /_/ / / | | GHC Interactive, version 6.6.1, for Haskell 98. / /_\\/ __ / /___| | http://www.haskell.org/ghc/ \____/\/ /_/\____/|_| Type :? for help. Loading package base ... linking ... done. [1 of 1] Compiling Main ( D.hs, interpreted ) Ok, modules loaded: Main. *Main> main T (ID False) *Main> :q Leaving GHCi. :~/haskell$ ${GHC_682_BIN}/ghci -ignore-dot-files -fallow-undecidable-instances D.hs GHCi, version 6.8.2: http://www.haskell.org/ghc/ :? for help Loading package base ... linking ... done. [1 of 1] Compiling Main ( D.hs, interpreted ) D.hs:1:0: No instance for (Show (w Bool)) arising from the 'deriving' clause of a data type declaration at D.hs:1:0-48 Possible fix: add an instance declaration for (Show (w Bool)) When deriving the instance for (Show (T w)) Failed, modules loaded: none. Prelude>

2 1

gmp
by Christian Maeder 17 Apr '08

17 Apr '08

I understand that gmp is needed for the certain libraries like the Prelude with Double and Integer. But I do not understand why gmp is so deeply buried in the rts. Are the basic types Int and Pointer not enough to write a compiler like ghc? Cheers Christian

7 10