Haskell: Converting Integral to Float (or Floating). Mixing floats and ints

Question

I'm still having a hard time wrapping my brain around Haskell and its type system. I posted another question: Haskell Converting Int to Float and that certainly helped, but I'm still stuck. I have what I think is a simpler example posted here:

ymod2 :: Integral b => b -> [b]
ymod2 n = map (\y->(y `mod` 2)) [0..n]    

powersOfx :: (Enum b, Floating b) =>  b -> b -> [b]
powersOfx n x = map (\y->(x**y)) [0..n]

thirdLst :: (Integral a, Enum a, Enum b, Floating b) => a -> b -> [b]    
thirdLst n x = zipWith (*) (ymod2 n) (powersOfx (fromIntegral n) x)

As you can see, I have a function that takes an Integral (ymod2) and a function that takes an Enum,Floating. These are both used (via zipWith) in thirdLst. I pass thirdLst an Integral and a Floating. I do attempt to change the Integral to a Floating for use in powersOfx. When I load this into WinGHCi I get:

• Couldn't match type ‘b’ with ‘a’
  ‘b’ is a rigid type variable bound by
    the type signature for:
      thirdLst :: forall a b.
                  (Integral a, Enum a, Enum b, Floating b) =>
                  a -> b -> [b]
   // and quite a bit more which I can post if desired

I've tried various permutations. I've removed the fromIntegral, I've tried different types, but nothing seems to work. I think my central question might be how to convert types. I thought fromIntegral would do it. I realize that quite possibly, the method powersOfx could be rewritten to use different types in this contrived example. My question would remain though. That is how to make these two methods play nicely together when zipping them.

Thanks, Dave

UPDATE. Based on reading Willem's answer I was able to get my code working by replacing thirdLst with:

thirdLst :: (Integral a, Floating b, Enum b) => a -> b -> [b]    
thirdLst n x = zipWith (*) (map fromIntegral (ymod2 n)) (powersOfx (fromIntegral n) x)

I believe Willem's example is far superior and future readers should study his answer. I'm marking his answer as the correct one. Thanks Willem!

Answer 1

Haskell's (numerical) type system

I'm still having a hard time wrapping my brain around Haskell and its type system.

Well I think that there are some aspects about the numerical types in Haskell:

1. there are no implicit conversions between types (not between numerical types, nor between other types), so you can not implicitly convert an Int to a Float;
2. most operators work on the same type. For example (+) :: Num a => a -> a -> a, so that means if one of the operands is an Int, then the other operand and the result are all Ints; and
3. the numerical operators (like (+), (-), (**)) originate from type classes. For example (**) :: Fractional a => a -> a -> a originates from the Fractional type class.

Deriving the type of the function (and why it is problematic)

Let us now emulate the Haskell compiler. You define a function:

thirdLst n x = zipWith (*) (ymod2 n) (powersOfx (fromIntegral n) x)

So we here see that the function takes two parameters n, and x, so first we assume that thirdLst has type:

thirdLst :: a -> b -> c

but we still need to analyze the types by looking at the expression. We see that the ymod2 :: Integral d => d -> [d] (we here use another name, since those are basically different variables) function is called, so that means that the type of n is a as well as d, so that means that a and d are the same type, and ymod2 n produces a list [a]. We also have to add the Integral a type, and now the type of our function is:

thirdLst :: Integral a => a -> b -> c
ymod2 n :: Integral a => [a]

We also see in the expression that the fromIntegral :: (Integral e, Num f) => e -> f is called with n as parameter, so we conclude that a ~ e (a and e are the same type), and that fromIntegral n has type Num f => f. We again add an Integral type constraint to a, but since it is already constrained that way, the constraints on a remain the same:

thirdLst :: Integral a => a -> b -> c
ymod2 n :: Integral a => [a]
fromIntegral n :: Num f => f

The fromIntegral expression is only a subexpression of (powersOfx (fromIntegral n) x), since powersOfx has type powersOfx :: (Enum g, Floating g) => g -> g -> [g]. We thus know that f ~ g, and b ~ g, we thus know that the result of the expression is [b], and we have to add Enum b and Floating b as constraints:

thirdLst :: (Integral a, Enum b, Floating b) => a -> b -> c
ymod2 n :: Integral a => [a]
fromIntegral n :: Num b => b
powersOfx (fromIntegral n) x :: (Enum b, Floating b) => [b]

This is up to now no problem, the two parameters of thirdLst, n and x have a different type, but now we use zipWith :: (h -> i -> j) -> [h] -> [i] -> [j] and we use as first argument (*) :: Num k => k -> k -> k, so as a result we know that k ~ h ~ i ~ j, and thus that our zipWith (*) has type:

zipWith (*) :: Num k => [k] -> [k] -> [k]

and now the problem arises, we see that the two arguments of zipWith (*) need to have the same type. Since ymod2 n :: Integral a => [a] and powersOfx (fromIntegral n) x :: (Enum b, Floating b) => [b] are the parameters we use for zipWith (*) this means that k ~ a ~ b, so k, a and b are all the same type. So now we conclude:

thirdLst :: (Integral a, Enum a, Floating a, Num a) => a -> a -> [a]

So that means that the two parameters need to have the same type. Now this already results in an important issue: numbers typically are not Integral and Floating at the same time. There are in the most common numerical library no number types that are both Floating and Integral at the same time. So this makes the function quite useless.

Allowing more freedom

So we will need to find more generic functions, and more freedom. Your powersOfx function is too restrictive: since the length of the list an x need to have the same type. We can construct one where the two types are independent:

import Data.List(genericTake)

powersOfx :: (Num a, Integral i) => i -> a -> [a]
powersOfx n x = genericTake (n+1) (iterate (x*) 1)

for ymod2, you basically construct a list with a certain length that looks like [0, 1, 0, 1, ...]. So we can use cycle :: [a] -> [a] for that and again an genericTake (n+1):

ymod2 :: (Num a, Integral i) => i -> [a]
ymod2 n = genericTake (n+1) (cycle [0, 1])

and then our function is:

thirdLst :: (Num c, Integral a) => a -> c -> [c]
thirdLst n x = zipWith (*) (ymod2 n) (powersOfx n x)

Answer 2

ymod2 :: Integral a => a -> [a]
ymod2 n = map (\y->(y `mod` 2)) [0..n]    

powersOfx :: (Enum b, Floating b) =>  b -> b -> [b]
powersOfx n x = map (\y->(x**y)) [0..n]

thirdLst :: (Integral a, Enum b, Floating b) => a -> b -> [b]    
thirdLst n x = zipWith (*) (fromIntegral <$> ymod2 n) (powersOfx (fromIntegral n) x)