I am trying to dynamically load a shared haskell module - and
it almost
works... however as
soon as the grabage collector thread runs it frees/moves
something and the
program falls over.
Presumably this means I need to use a StablePtr - however I
have as yet been
unable to work out
Folks,
There's been some mail recently about GHC and Cygwin, some
of it on the nhc-bugs list (hence ccing this there). I'm a bit confused
so this message is to try to clarify the situation.
The GHC core team is now down to Simon M and me. Sigbjorn
heroically helps out on Win32 stuff, but it
[interesting; postfix at haskell.org claims rightly that there is no ghc-users
list there.
so how did Simon's mail reach me in the first place? well, here we go again]
- Original Message -
From: Claus Reinke [EMAIL PROTECTED]
To: Simon Peyton-Jones [EMAIL PROTECTED]; [EMAIL PROTECTED];
| Can you comment on how much longer the GHC core team will exist?
Indefinitely. Meaning that
(a) There is no time limit: Simon and I have permanent posts
Reuben and Julian left when the grant ran out; we knew that
was coming, but there is no correponding future event known.
(b) But (as has
Simon Peyton Jones wrote:
I am therefore deeply reluctant to provide both GHC-for-mingw32
and GHC-for-cygwin. One build on Win32 is enough! We ended
up with a mingw32 basis because it meant we could make GHC=20
completely self-contained -- no dependence on cygwin1.dll etc.
This was
Why can I not define the following (in ghc):
class Foo p where
instance Foo Double where
foo :: Double - (forall q . Foo q = q)
foo p = p
From my humble (lack of) knowledge, there seems to be nothing wrong here,
but ghc (5.03) complains about unifying q with Double. I *can* write:
class
On Thu, Apr 04, 2002, Hal Daume III wrote:
Why can I not define the following (in ghc):
class Foo p where
instance Foo Double where
foo :: Double - (forall q . Foo q = q)
foo p = p
From my humble (lack of) knowledge, there seems to be nothing wrong here,
but ghc (5.03) complains
I believe that ghc translates the signature above to
foo :: forall q . Foo q = Double - q
(I don't understand why GHC does this... it seems to have more potential
for confusion)
I thought post 5.03 didn't do this? Isn't this the point of Putting type
annotations to use? Or am I missing
Why can I not define the following (in ghc):
class Foo p where
instance Foo Double where
foo :: Double - (forall q . Foo q = q)
foo p = p
From my humble (lack of) knowledge, there seems to be nothing wrong
here, but ghc (5.03)
class Foo p where
instance Foo Double where
foo :: Double - (forall q . Foo q = q)
foo p = p
From my humble (lack of) knowledge, there seems to be nothing wrong
here, but ghc (5.03) complains about unifying q with Double.
Well, of course! The
| Ah yes, silly me. What I had in mind, I suppose, was
| something more along the lines of:
|
| foo :: Double - (exists q . Foo q = q)
Correct. Currently you can only express this by wrapping
the existential in a constructor:
data R = forall q. Foo q = MkR q
foo :: Double -
11 matches
Mail list logo
