Haskell - Why are we using RankNTypes for single type outputs?

Question

I tried this code:

printing = print $ rank2 (+1)
rank2 :: Num n => (n -> n) -> Double
rank2 f = f 1.0

It threw the error:

Couldn't match expected type ‘Double’ with actual type ‘n’
‘n’ is a rigid type variable bound by the type signature

If I changed Double to Int, the error also changes from ‘Double’ to ‘Int’.

This error is only resolved if I use the RankNTypes GHC Language Extension:

{-# LANGUAGE RankNTypes #-}
printing = print $ rank2 (+1)
rank2 :: (forall n. Num n => n -> n) -> Double
rank2 f = f 1.0

I have read the answers at:

Understanding Haskell's RankNTypes

But I do not quite understand why this error would arise when I'm not using a tuple as the output, such as forall n. Num n => (n -> n) -> (Int, Double), where the tuple is (Int, Double). If a tuple is the output, the function f may face a conflict in choosing between the types Int or Double. But in this case, I'm using a single type output..

Is it due to the function f being rigidly polymorphic? If so, wouldn't this mean that being polymorphic is quite meaningless? The function can't adapt itself to a Double or Int..

Answer 1

So you want

rank1 :: Num n => (n -> n) -> Double
rank1 f = f 1.0

If this did typecheck, it would have to be possible to use it, for instance, like this:

bad :: Double
bad = rank1 (\n -> n + (sqrt (-1) :: Complex Double))

But that clearly can't work, because now you're adding an imaginary number to a real one and the result is supposed to be still a real Double.

With

rank2 :: (∀ n. Num n => n -> n) -> Double
rank2 f = f 1.0

you prevent this sort of usage, because the function you pass as the argument must be able to work for arbitrary number types, thus it's not possible for me to add a concrete Complex Double in the mix, only generic Num operations:

allright :: Double
allright = rank2 (\n -> n + abs (-1))

Answer 2

This definition,

rank2 :: Num n => (n -> n) -> Double
rank2 f = f 1.0

Doesn't work because standard rank-1 polymorphism in Haskell says that the caller gets to choose what the type variables mean. It would be valid to call a function with that type with an argument f of type Int -> Int. This doesn't work with that definition because f needs to accept and return a Double.

When you make it higher-rank you resolve that by requiring f to be polymorphic over all n, rather than working on some type n that the caller chooses. Now it's possible to use f at the type Double -> Double in the body and get a result that type-checks.

This higher-rank type isn't completely useless in this case - you prevent the function being passed in from doing anything outside the Num type class. It can add, multiply, use literals, and a couple other things, but it can't divide or use trig functions, for instance.

Sometimes that kind of restriction on the capabilities of an input is really important, and so the higher-rank type provides value. runST :: (forall s. ST s a) -> a is an example of using a higher-rank type to prevent the input value from doing things that would break Haskell's evaluation model and result in buggy programs.

But I'm not sure you actually would care about that sort of thing in this case. It's probably easiest to just go with a rank-1 type that supports what you're doing more directly.

Answer 3

This:

rank1 :: Num n => (n -> n) -> Double

Is short for this:

rank1 :: forall n. Num n => (n -> n) -> Double

You can write an explicit forall at the top level of a type signature using {-# Language ExplicitForAll #-}. It’s also allowed with RankNTypes, of course, but this is a rank-1 type.

This is the type of a polymorphic function with the following parameters:

• A type n, supplied implicitly by type inference or explicitly with {-# Language TypeApplications #-};

• An instance of Num for that type n, also supplied implicitly by the compiler; and

• A function (f) from n to n.

The caller of rank1 specifies the argument values for each of these parameters.

Inside the definition of rank1, it may call f, but f only has a single monomorphic type, being n -> n for the particular type n that the caller of rank1 specified.

For example, rank1 @Int (using TypeApplications syntax) has the type (Int -> Int) -> Double, so in this case we would have f :: Int -> Int. (More specifically, rank1 @Int has type Num Int => (Int -> Int) -> Double, but the constraint Num Int is filled immediately by the fact that there is an instance Num Int.)

Naturally, the Int result of f doesn’t match Double in this case. In general, therefore, rank1 cannot assume anything about the type n, except that it is in the class Num. It promises to work “for all n”. As such, there’s no way to get a Double from an n, because an instance Num t doesn’t offer any conversions from the type t, only to t (with fromInteger :: Integer -> t).

Contrast this with the rank-2 type in your question:

rank2 :: (forall n. Num n => n -> n) -> Double

Here, the forall is nested within a function type … -> Double. So rank2 is not polymorphic, and accepts only one parameter, which is a polymorphic function f.

That function f accepts three parameters: the type n, the instance of Num for n, and a value of type n. It returns a value of type n.

So within the definition of rank2, it may call f, and as the caller of f, rank2 may choose any n that it wants, because the type of f promises that it works “for all n”. Therefore, rank2 can choose n = Double, which is valid because there is an instance Num Double. The specialisation f @Double :: Double -> Double returns a Double, which can, of course, be returned from rank2.

Since f is polymorphic, rank2 could call it multiple times with different arguments for n. That’s why you see examples using a tuple, like (forall n. Num n => n -> n) -> (Int, Double) (note the position of the forall). They’re demonstrating that you can call the functional parameter at multiple different types.