# ANNOUNCE: GHC 6.8.3 Release Candidate

Serge D. Mechveliani mechvel at botik.ru
Sun Jun 1 13:34:06 EDT 2008

```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
and the compiler has not rigth to replace the former with the latter.
Right?

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
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
appear.
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
computation.

Now, I think, either I need to hide the standard (^) and overload it
or to replace (^) with `power' in my examples too.

Regards,

-----------------
Serge Mechveliani
mechvel at botik.ru

```