It's a bug in GHC 5.02 and earlier; fixed in 5.03
Simon
| -Original Message-
| From: Hal Daume III [mailto:[EMAIL PROTECTED]]
| Sent: 04 April 2002 00:15
| To: Haskell Mailing List
| Subject: deriving over renamed types
|
|
| Why can't I do this:
|
| import FiniteMap
| type FM =
[Apologies for multiple copies of this announcement]
**
final call for papers and participation ***
**
Hi all,
At 2002-04-03 15:14, Hal Daume III wrote:
type FM = FiniteMap
type FM a b = FiniteMap a b
I wasn't aware there was (supposed to be) a difference
between these two declarations? Is there?
On Wed, 3 Apr 2002, Ashley Yakeley wrote:
type FM a b = FiniteMap a b
...This
| ...which would be very useful, but would probably have unpleasant
| consequences for type inference...
|
| To my mind, this is not a credible objection. The horse has
| already bolted; there's no point in trying to shut the stable
| door. The existing post-Hindley-Milner aspects of
On Wed, Apr 03, 2002 at 11:15:04AM -0800, Hal Daume III wrote:
I'm looking for a (not-necessarily Haskell 98 compliant, as long as it
works in GHC) way to get at the internal representation of Doubles. I can
use decodeDouble# to get at it, but I need something equivalent to
encodeDouble# to
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 Thursday, April 4, 2002, 22:36 CET 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
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
I was visiting http://www.ai.mit.edu/extra/icfp-contest/ and noticed that
there was a functional programming contest in ICFP 98. I'd like to know if
there are any periodic functional progamming contests around the world, such
as the ACM contest for the C language.
-- Andre
Andre W B Furtado writes:
| I was visiting http://www.ai.mit.edu/extra/icfp-contest/ and noticed that
| there was a functional programming contest in ICFP 98. I'd like to know if
| there are any periodic functional progamming contests around the world, such
| as the ACM contest for the C
Yes, and there will be one this year too. Tim Sheard is organising it.
Simon
| -Original Message-
| From: Tom Pledger [mailto:[EMAIL PROTECTED]]
| Sent: 05 April 2002 04:03
| To: [EMAIL PROTECTED]
| Subject: functional programming contest
|
|
| Andre W B Furtado writes:
| | I was
| 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 -
If I do the following ...
$ tar xvfi ../ghc-5.02.1-src-1.tar
$ tar xvfi ../happy-1.11-src.tar
$ cd ghc-5.02.1
$ cp -r ../happy-1.11/happy .
$ echo prefix = /home/dorr/func/haskell/installs mk/build.mk
$ ./configure
$ cd ghc/rts/gmp
$ ./configure
$ cd -
$ cd ghc
$ ./configure # not sure this is
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 -
(Redirected from haskell to haskell-cafe.)
Well, I tried to fix the problems you mention.
Results attached. I have managed to do without de Brujin
notation. The evaluator is (modulo bugs!) normal order.
One can easily do an applicative order evaluator as well.
Evaluating to WHNF is probably
module Main where
main = do content - getContents
let starstat = oneline content
alphabet = ['a'..'z']
count ch = length . filter (==ch)
oneline str ch = [ch] ++ ++ stars (count ch str)
stars x = take x ['*','*'..]
What I would like to know is how the 'fix' function could be used
to find the fixed point of a function like ( \n - 2*n ).
Olaf and Lennart said a little about least fixpoints, but little about
what makes a fixpoint least. Olaf suggested looking up papers on domain
theory or denotational
28 matches
Mail list logo
