ANNOUNCE: GHC 6.8.3 Release Candidate
simonpj at microsoft.com
Mon Jun 2 03:50:18 EDT 2008
* I think it is a Bad Idea for an application to assume
that the implementation of (f^n) will not multiply by 1.
Implementations of numeric algorithms probably make all sorts
of ill-documented assumptions about the algebraic properties
of numeric operations
* On the other hand, it's a bit stupid for the implementation
of (f^n) to multiply by 1, and Ian has, I think, already fixed this.
| -----Original Message-----
| From: glasgow-haskell-users-bounces at haskell.org [mailto:glasgow-haskell-users-bounces at haskell.org] On
| Behalf Of Serge D. Mechveliani
| Sent: 01 June 2008 18:34
| To: Ian Lynagh
| Cc: glasgow-haskell-users at haskell.org
| Subject: Re: ANNOUNCE: GHC 6.8.3 Release Candidate
| On Sun, Jun 01, 2008 at 03:34:00PM +0100, Ian Lynagh wrote:
| > On Sun, Jun 01, 2008 at 05:39:49PM +0400, Serge D. Mechveliani wrote:
| > >
| > > This is why res and 1*res are not equivalent in Haskell-98 for
| > > res :: Num a => a.
| > >
| > > Am I missing something?
| > The library functions assume that class instances obey some unwritten
| > laws; it's all a bit vague, but if your instances don't obey them then
| > you might find that things go wrong when using library functions. For
| > example, if your (*) isn't associative then (^) is going to give odd
| > results, and if the type of the second argument to (^) doesn't do
| > arithmetic in the normal way then very strange things could happen.
| > Anyway, I've just tweaked the (^) definition again, so your code should
| > work in 6.8.3.
| Thank you.
| This helps -- in that the public DoCon-2.11 test will run (I hope).
| But I think that you have found a bug in the DoCon test program.
| Thank you.
| More precisely, here are my indeas.
| 1. Generally, for t = Num a => a, the expessions res :: t and
| ((fromInteger 1) :: t) * res
| are not equivalent in Haskell-98,
| and the compiler has not rigth to replace the former with the latter.
| 2. But I guess, our current questions are different:
| (2.1) For t = Num a => a, has a Haskell implementation for (f^n) :: t
| right to base on certain natural properties of the operation
| fromInteger :: Integer -> t ?
| (2.2) Has a reliable mathematical application right to base on that
| for n > 0 the expression (f^n) :: Polynomial Integer
| does not imply computing fromInteger 1 :: Polynomial Integer
| Concerning (2.1): I do not know whether Haskell-98 allows to rely on
| that f^3 is equivalent to (fromInteger 1)*(f^3).
| But concerning (2.2), I think that (independently of the question (2.1))
| a reliable mathematical application must not presume the above properties
| of (^) and fromInteger.
| Concerning f^3 :: UPol Integer in my test for DoCon:
| 1) fromInteger _ :: UPol _ is defined as
| error "... use fromi instead".
| 2) (*) is defined via polMul ...
| 3) The expression f ^ 3 relies on the Haskell-98 library for (^).
| The Haskell library defines (^) via (*) -- all right.
| 4) DoCon has the function `power' to use instead of (^),
| and its library avoids (^).
| But for n > 0, I considered f^n :: UPol _
| as also correct. Because the Haskell library performs this via repeated
| application of (*).
| And I thought that if n > 0, then (fromInteger _ :: UPol _) will not
| Maybe it does not appear in old GHC-s and does appear 6.8.3 ?
| I was using expressions like [(f ^ n) :: UPol Integer | n <- [2 .. 9]]
| in my _test programs_ for DoCon.
| But this relies on a particular property of the Haskell library definition
| for (f^n) :: a
| -- on that if n > 0 then (fromInteger _ :: a) does not appear in this
| Now, I think, either I need to hide the standard (^) and overload it
| or to replace (^) with `power' in my examples too.
| Serge Mechveliani
| mechvel at botik.ru
| Glasgow-haskell-users mailing list
| Glasgow-haskell-users at haskell.org
More information about the Glasgow-haskell-users