- Glasgow-haskell-users

Stable names and type constraints
by Lee Pike 23 Nov '11

23 Nov '11

Hi Everybody, This is a question about System.Mem.StableName <http://www.haskell.org/ghc/docs/latest/html/libraries/base-4.4.1.0/System-M…>---let me know if this isn't the right forum, but my understanding is that stable names are GHC-specific. Consider the module below. For a function with type constraints, stable names fails to "realize" that we are pointing to the same object. As a couple of my colleagues pointed out to me, the cause is the dictionary being passed around causing new closures to be created. This can be rectified using a local variable binding (e.g., using a where clause), but it'd be nice if there were a solution to allow for observable sharing, even for functions with type constraints. Are there known solutions other than monomorphism or local variable bindings? Thanks, Lee ------------------------------------------------------------------------------- module Test where import System.Mem.StableName (StableName, makeStableName) --------------------------------------------------------------------------------- type Map a = [StableName (Expr a)] analyze :: Expr a -> IO (Map a) analyze = analyzeExpr [] analyzeExpr :: (Map a) -> Expr a -> IO (Map a) analyzeExpr env e@(Op e0) = do sn <- makeStableName e if elem sn env then return env else analyzeExpr (sn : env) e0 --------------------------------------------------------------------------------- -- Language, with one constructor class Typed a where instance Typed Int data Expr a = Op (Expr a) expr0 :: Expr a expr0 = Op expr0 expr1 :: Typed a => Expr a expr1 = Op expr1 expr2 :: Typed a => Expr a expr2 = x where x = Op x --------------------------------------------------------------------------------- -- Tests -- Returns 1 test0 :: IO () test0 = test (expr0 :: Expr Int) -- Doesn't terminate! test1 :: IO () test1 = test (expr1 :: Expr Int) -- Returns 1 test2 :: IO () test2 = test (expr2 :: Expr Int) test :: Expr a -> IO () test e = analyze e >>= putStrLn . show . length

2 1

Re: Using extcore
by Tim Chevalier 23 Nov '11

23 Nov '11

It wouldn't surprise me at all if the extcore library only worked with GHC versions less than 7. I don't have sufficiently good Internet access to download 7.0.3 right now, but once I do, I'll see what's going on. Just didn't want you to think your question had disappeared into the aether :-) Cheers, Tim -- Tim Chevalier * http://catamorphism.org/ * Often in error, never in doubt “I cannot hide my anger to spare you guilt, nor hurt feelings, nor answering anger; for to do so insults and trivializes all our efforts. Guilt is not a response to anger; it is a response to one’s own actions or lack of action.” -- Audre Lorde

1 0

behaviour change in getDirectoryContents in GHC 7.2?
by Ganesh Sittampalam 18 Nov '11

18 Nov '11

Hi, I'm just investigating what we can do about a problem with darcs' handling of non-ASCII filenames on GHC 7.2. The issue is apparently that as of GHC 7.2, getDirectoryContents now tries to decode filenames in the current locale, rather than converting a stream of bytes into characters: http://bugs.darcs.net/issue2095 I found an old thread on the subject: http://www.haskell.org/pipermail/haskell-cafe/2009-June/062795.html and some GHC tickets (e.g. http://hackage.haskell.org/trac/ghc/ticket/3300) Can anyone point me at the rationale and details of the change and/or suggest workarounds? Cheers, Ganesh

13 55

IO in the middle
by Serge D. Mechveliani 17 Nov '11

17 Nov '11

People, is it possible to arrange a connected output and input (with something like a socket) "in a middle" of the Haskell function? Consider the example of sorting an integer list: sortInt :: [Int] -> [Int] sortInt js = let callString = "sortForeign( " ++ (show js) ++ ")" ? = outputToSocket callStr socket? -- strict order? resStr = inputFromSocket socket? :: String -- (res, _) = reads str' :: ([Int], String) in res It forms the call string for a foreign function, passes it to a Socket, the foreign system parses callString, evaluates it, and returns the string resStr for the result (inputFromSocket needs to happen later than outputToSocket). Then, reads converts it back to [Int]. Forgetting of the pure-functionality philosophy, which items in the Haskell library or in the GHC library may help? Is the C interface needed? What if there is a file instead of socket? (for this Foreign is able to apply readFile, to parse and evaluate the call). I had an experience with readFile in Haskell, but this was only the top function. Here the situation looks more complex. Thank you in advance for your explanation. ------ Sergei. mechvel(a)botik.ru

2 1

heads up: GHC gets a new constraint solver (again)
by Dimitrios Vytiniotis 16 Nov '11

16 Nov '11

Friends, After a very busy period of hard work with Simon, we've re-engineered GHCs constraint solver and I just pushed a big patch on master along with modifications in the testsuite. The new constraint solver is based on the existing in its core ideas but is shorter, much cuter, and for many programs much faster (for others performance is roughly the same) If you had a program that was taking very long to compile in the past, we'd be very interested to see how this reengineered constraint solver performs on it. Same if you spot problems or notable regressions. Thanks, enjoy! Dimitrios > -----Original Message----- > From: cvs-ghc-bounces(a)haskell.org [mailto:cvs-ghc-bounces@haskell.org] > On Behalf Of dimitris(a)microsoft.com > Sent: 16 November 2011 17:42 > To: cvs-ghc(a)haskell.org > Subject: [commit: ghc] master: GHC gets a new constraint solver. More > efficient and smaller in size. (0007c0e) > > Repository : ssh://darcs.haskell.org//srv/darcs/ghc > > On branch : master > > http://hackage.haskell.org/trac/ghc/changeset/0007c0ec9c0de68e3a348b8c4 > 112ac48fd861b1e > > >--------------------------------------------------------------- > > commit 0007c0ec9c0de68e3a348b8c4112ac48fd861b1e > Author: Dimitrios Vytiniotis <dimitris(a)microsoft.com> > Date: Wed Nov 16 16:12:48 2011 +0000 > > GHC gets a new constraint solver. More efficient and smaller in size. > > compiler/basicTypes/DataCon.lhs | 9 +- > compiler/basicTypes/MkId.lhs | 10 +- > compiler/codeGen/CgCase.lhs | 18 +- > compiler/coreSyn/CoreLint.lhs | 78 +- > compiler/coreSyn/CoreSubst.lhs | 15 +- > compiler/coreSyn/CoreUtils.lhs | 27 +- > compiler/deSugar/Desugar.lhs | 7 +- > compiler/deSugar/DsBinds.lhs | 29 +- > compiler/deSugar/DsCCall.lhs | 4 +- > compiler/deSugar/DsUtils.lhs | 2 +- > compiler/hsSyn/HsBinds.lhs | 17 +- > compiler/prelude/TysPrim.lhs | 12 +- > compiler/simplCore/CoreMonad.lhs | 9 +- > compiler/simplCore/OccurAnal.lhs | 4 +- > compiler/simplCore/SimplUtils.lhs | 2 +- > compiler/simplCore/Simplify.lhs | 25 +- > compiler/typecheck/Inst.lhs | 71 +- > compiler/typecheck/TcCanonical.lhs | 1361 ++++++++++++++-------- > compiler/typecheck/TcErrors.lhs | 48 +- > compiler/typecheck/TcHsSyn.lhs | 12 +- > compiler/typecheck/TcInteract.lhs | 1664 +++++++++----------------- > compiler/typecheck/TcMType.lhs | 40 +- > compiler/typecheck/TcRnDriver.lhs | 15 +- > compiler/typecheck/TcRnMonad.lhs | 9 + > compiler/typecheck/TcRnTypes.lhs | 194 +++- > compiler/typecheck/TcSMonad.lhs | 1211 ++++++++++++++------ > compiler/typecheck/TcSimplify.lhs | 522 +++++---- > compiler/typecheck/TcSplice.lhs | 2 +- > compiler/typecheck/TcType.lhs | 41 +- > compiler/types/Coercion.lhs | 99 +- > compiler/types/FunDeps.lhs | 10 +- > compiler/types/Type.lhs | 12 +- > compiler/types/TypeRep.lhs | 21 +- > compiler/vectorise/Vectorise/Type/PRepr.hs | 4 +- > compiler/vectorise/Vectorise/Utils/PADict.hs | 2 +- > 35 files changed, 3205 insertions(+), 2401 deletions(-) > > > Diff suppressed because of size. To see it, use: > > git show 0007c0ec9c0de68e3a348b8c4112ac48fd861b1e > > _______________________________________________ > Cvs-ghc mailing list > Cvs-ghc(a)haskell.org > http://www.haskell.org/mailman/listinfo/cvs-ghc

2 1

Way to expose BLACKHOLES through an API?
by Ryan Newton 16 Nov '11

16 Nov '11

Hi GHC users, When implementing certain concurrent systems-level software in Haskell it is good to be aware of all potentially blocking operations. Presently, blocking on an MVar is explicit (it only happens when you do a takeMVar), but blocking on a BLACKHOLE is implicit and can potentially happen anywhere. If there are known thunks where we, the programmers, know that contention might occur, would it be possible to create a variant of "Control.Monad.Evaluate" that allows us to construct non-blocking software: evaluate :: a -> IO a evaluateNonblocking :: a -> IO (Maybe a) It would simply return Nothing if the value is BLACKHOLE'd. Of course it may be helpful to also distinguish the evaluated and unevaluated states. Further, the above simple version allows data-races (it may become blackhole'd right after we evaluate). An extreme version would actively blackhole it to "lock" the thunk... but maybe that's overkill and there are some other good ideas out there. A mechanism like the proposed should, for example, allow us to consume just as much of a lazy Bytestring as has already been computed by a producer, WITHOUT blocking and waiting on that producer thread, or migrating the producer computation over to our own thread (blowing its cache). Thanks, -Ryan

4 4

encoding and paths, again
by Ganesh Sittampalam 16 Nov '11

16 Nov '11

Hi, I'm not entirely clear on what the overall situation will be once Simon M's patch to add .ByteString versions to unix is added in GHC 7.4.1. In particular the original problem darcs ran into was with getDirectoryContents in the directory package. That in turn uses the unix package on Posix systems and another code path based on Win32 on Windows (http://hackage.haskell.org/packages/archive/directory/1.1.0.1/doc/html/src/…) So a couple of questions: (1) Does Win32 need similar additions? I can't spot any substantial changes to it for Max's PEP383, but I'm not sure if any lower-level library changes might have affected it. (2) What's the recommended way of doing the equivalent of getDirectoryContents for RawFilePath? Do we also need to add "raw" versins to the directory package? Cheers, Ganesh

2 3

Why not allow empty record updates?
by Herbert Valerio Riedel 16 Nov '11

16 Nov '11

Hello GHC HQ, I have been toying with phantom types in combination with "polymorphic" record-updates (which is a great feature imho), but stumbled over a limitation: GHC doesn't allow empty record updates (see toy example below), and I couldn't find a GHC language extension to relax this constraint. In the toy-example below it was easy to workaround by performing a dummy record update, but for more advanced uses workarounds becomes a bit more annoying. Is there a particular reason why empty record updates are disallowed by the Haskell Report? Would it be sensible, to allow empty record updates as a GHC language extension? hvr. ------------------------------------------------------- -- empty types for tagging data Clean data Dirty data Foo a = Foo { fa :: Int, fb :: String } data Bar a = Bar { ba :: Int, bb :: Foo a } markDirtyFoo :: Foo Clean -> Foo Dirty markDirtyFoo foo = foo { } -- rejected with "Empty record update" error markDirtyFoo foo = foo { fa = fa foo } -- workaround: dummy update markDirtyBar :: Bar Clean -> Bar Dirty markDirtyBar bar = bar { bb = markDirtyFoo (bb bar) } -- works

8 12

instance union proposal
by Serge D. Mechveliani 15 Nov '11

15 Nov '11

Dear Haskell implementors, I suggest the following small extension to the instance declaration in the language. So far -- for Haskell + glasgow-ext. I think that they are easy to implement. This is the "instance union" proposal. It is needed to write shorter several `old' instance declarations. This will make programs easier to read. It suggests the so-called inherited decl and, more general, union decl. Inherited instance decl proposal -------------------------------- Union several instance declarations with the same condition part and such that among the conclusion classes there exists some which inherits all others. Example 1. My program uses the class tower Field a Picture 1. | ERing | CRing a | Ring a / \ AddGroup a MulSemigroup a | | AddSemigroup a | \ / Set a -- "|" means that the upper inherits from the lower. Now, by the application meaning, I need to write instance (Show a, CRing a) => CRing (Pol a) where <implement operations of Set> <implement operations of AddGroup> ... <implement operations of CRing> >From the class decls it is clear to the compiler that CRing inherits all that is lower on the picture. Therefore, the conditional `instance (Show a, CRing a) =>' and 'where' is written only once. In the existing language, I need to write this conditional 6 times. Union instance decl proposal ---------------------------- It is a generalization for inhereted decl. instances (cond_1, ..., cond_n) -- of the type parameters a_1 ... a_m => <typeTuple> (<params>) has {<conclInstList>} where <implement operations for each member of <conclInstList>. It differs from the old instance declaration in that 1) it unions several old declarations having the same conditional part, 2) each member of <conclInstList> can be conditional, 3) in <conclInstList> it can be skipped any instance which is inherited by some other member in this list. <params> is a subset of {a_1 ... a_m}, <typeTuple> (<params>) is a tuple of type expressions, as in old declaration, for example, `(a, b)', `Vector a', `[(a,b), Vector a]'. It is the argument for the conclusion instance declarations. <conclInstList> is a list of inst-members separated by comma. Each member of <conclInstList> is either an old conclusion instance declaration or a conditional declaration. Example. In the situtation of Picture 1, I need to declare instance (Show a, CRing a) => (Pol a) has { CRing, if (has a Field) then ERing } where <define operations for Set (Pol a)> <define operations for AddSemigroup (Pol a)> ... <define operations for CRing (Polynomial a)> <define operations for ERing (Pol a)> -- this part has the -- additional condition (Field a) Its meaning is that the complier extends this into several `old' instance declarations: instance (Show a, CRing a) => Set (Pol a) where <define operations for Set (Pol a)> ... instance (Show a, CRing a) => CRing (Pol a) where <define operations for Set (Pol a)> instance (Show a, Field a) => ERing (Pol a) where <define operations for ERing (Pol a)> (in the last decl `Field a' has been moved to LHS). In this example <typeTuple> === (Pol a). For bi-parametric instances, the concusion part may be, for example => [a, Pol a] has {Foo1, Foo2} ... This means the two instance assertions Foo1 a (Pol a), Foo a (Pol a), and `[a, Pol a]' is the agrument tuple for the instance conclusions. This is a draft proposal. If the idea is accepted, some generalizations and corrections are expected. Regards, ----------------- Serge Mechveliani mechvel(a)botik.ru

2 1

source/build separation
by Rustom Mody 15 Nov '11

15 Nov '11

I am building ghc from source. The building page http://hackage.haskell.org/trac/ghc/wiki/Building/Using#Sourcetreesandbuild… mentions lndir for separating source trees from build trees. Given how much detail is generally given for individual commands eg http://hackage.haskell.org/trac/ghc/wiki/Building/GettingTheSources maybe it would be nice to have a (typical?) lndir command also given? Also there is a mention about using a local git clone here http://hackage.haskell.org/trac/ghc/wiki/Building/GettingTheSources Arent these two alternative ways with similar intent - viz. keeping source pristine and separating build 'messiness'? Or do people use both git (local) clone + lndir? If so why? Rusi [ghc noob here: Please tell me if this is the wrong list to ask this kind of question :-) ]

3 2