# How (not) to convert CDouble to Double

Published on

What’s wrong with the following code?

```
module Acos (acos) where
import Prelude hiding (acos)
import Foreign.C.Types (CDouble(..))
import ccall "math.h acos" c_acos :: CDouble -> CDouble
foreign
acos :: Double -> Double
acos = realToFrac . c_acos . realToFrac
```

If you use QuickCheck to test the equivalence of
`Acos.acos`

and `Prelude.acos`

, you’ll quickly
find a counterexample:

```
> Prelude.acos 1.1
NaN
> Acos.acos 1.1
Infinity
```

You might think this is a difference in the semantics of Haskell acos vs. C acos, but the acos(3) manpage disproves that:

If x is outside the range [-1, 1], a domain error occurs, and a NaN is returned.

Moreover, you’ll notice the discrepancy only when compiling the
Haskell program with `-O0`

. If you compile with
`-O1`

or higher, both versions will result in
`NaN`

. So what’s going on here?

What turns the `NaN`

turned into the `Infinity`

is `realToFrac`

. It is defined as follows:

```
realToFrac :: (Real a, Fractional b) => a -> b
realToFrac = fromRational . toRational
```

Unlike `Double`

, `Rational`

, which is defined
as a ratio of two Integers, has no way to represent special values such
as `NaN`

. Instead, `toRational (acos 1.1)`

results
in a fraction with some ridiculously large numerator, which turns into
`Infinity`

when converted back to `Double`

.

When you compile with `-O1`

or higher, the following
rewrite rules fire and avoid the round trip through
`Rational`

:

```
"realToFrac/a->CDouble" realToFrac = \x -> CDouble (realToFrac x)
"realToFrac/CDouble->a" realToFrac = \(CDouble x) -> realToFrac x
"realToFrac/Double->Double" realToFrac = id :: Double -> Double
```

Unfortunately, the Haskell
2010 Report doesn’t give you any reliable way to convert between
`Double`

and `CDouble`

. According to the Report,
`CDouble`

is an abstract newtype, about which all you know is
the list of instances, including `Real`

and
`Fractional`

. So if you want to stay portable,
`realToFrac`

seems to be the only solution available.

However, if you only care about GHC and its base library (which
pretty much everyone is using nowadays), then you can take advantage of
the fact that the constructor of the `CDouble`

newtype is exported.
You can use `coerce`

from `Data.Coerce`

or apply
the data constructor `CDouble`

directly.

So here’s a reliable, but not portable, version of the
`Acos`

module above:

```
module Acos (acos) where
import Prelude hiding (acos)
import Foreign.C.Types (CDouble(..))
import Data.Coerce (coerce)
import ccall "math.h acos" c_acos :: CDouble -> CDouble
foreign
acos :: Double -> Double
acos = coerce c_acos
```