Haskell中函数类型的区别

Question

I've been playing around with basic functions in Haskell, and am a little confused with the difference between the following type declarations for the function f

f :: Integer -> Integer

versus

f :: Integral n => n -> n

So far, I've treated both of these as identical, but I'm sure this isn't true. What is the difference?

Edit: As a response to the first answer, I wanna propose a similar example which more is along the lines of the question I hold.

Consider the following declarations

f :: Num n => n -> n

or

f :: Num -> Num

What functionality does each offer?

Answer 1

Let's rename:

f :: Integer -> Integer
g :: (Integral n) => n -> n

I like to follow a fairly common practice of adding parentheses to the constraint section of the signature. It helps it stand out as different.

f :: Integer -> Integer is simple, it takes an integer and returns another integer.

As for g :: (Integral n) => n -> n : Integral is not a type itself, rather it's more like a predicate. Some types are Integral , others aren't. For example, Int is an Integral type, Double is not.

Here n is a type variable , and it can refer to any type. (Integral n) is a constraint on the type variable, which restricts what types it can refer to. So you could read it like this:

g takes a value of any type n and returns a value of that same type , provided that it is an Integral type.

If we examine the Integral typeclass:

ghci> :info Integral
class (Real a, Enum a) => Integral a where
  quot :: a -> a -> a
  rem :: a -> a -> a
  div :: a -> a -> a
  mod :: a -> a -> a
  quotRem :: a -> a -> (a, a)
  divMod :: a -> a -> (a, a)
  toInteger :: a -> Integer
 {-# MINIMAL quotRem, toInteger #-}
    -- Defined in ‘GHC.Real’
instance Integral Word -- Defined in ‘GHC.Real’
instance Integral Integer -- Defined in ‘GHC.Real’
instance Integral Int -- Defined in ‘GHC.Real’

We can see 3 builtin types which are Integral . Which means that g simultaneously has three different types, depending on how it is used.

g :: Word -> Word
g :: Integer -> Integer
g :: Int -> Int

(And if you define another Integral type in the future, g will automatically work with that as well)

The Word -> Word variant is a good example, since Word s cannot be negative. g , when given a positive machine-sized number, returns another positive machine-sized number, whereas f could return any integer, including negative ones or gigantic ones.

Integral is a rather specific class. It's easier to see with Num , which has fewer methods and thus can represent more types:

h :: (Num a) => a -> a

This is also a generalization of f , that is, you could use h where something with f 's type is expected. But h can also take a complex number, and it would then return a complex number.

The key with signatures like g 's and h 's is that they work on multiple types, as long as the return type is the same as the input type.

Answer 2

According to this link the standard instances of the Integral type class are Integer and Int . Integer is a primitive type, and it acts like an unbounded mathematical integer. So given:

f :: Integral n => n -> n

n could be Int or Integer or any "custom" type that you define that is an instance of Integral . The use of type classes allows for type polymorphism.

f :: Num -> Num WILL NOT COMPILE because Num is not a type. Num has kind * -> Constraint and is thus a type constructor whereas f requires an ordinary type or monotype which has kind * , such as Int or Integer (also known as type system primitives). See the haskell wiki for a brief reference/jumping off point about kinds . Haskell has a rich type system with higher-order types, if used correctly it can be an extremely powerful tool ie type polymorphism.

Answer 3

f :: Integer -> Integer

f is a function from arbitrary sized integers to arbitrary sized integers.

f' :: Integral n => n -> n

f' is a polymorphic function from type n to type n . Any type n that is member of the class Integral is allowed. Examples for types in Integral are Integer and Int (the integer type with fixed precision).

f'' :: Num n => n -> n

f'' is also a polymorphic function, but this time for class Num . Num is a more generic number type that has more members than Integral , but all types in Integral are also in contained in Num . For f'' n can also be Double .

Answer 4

TL;DR

f :: Integer -> Integer works for one type: Integer .

f :: Integral n => n -> n works for Integer , Int , Word , Int32 , Int64 , Word8 , and any arbitrary user-defined types that implement the Integral type class.

That's the short version. If you only care about one type, it's easier to type-check and more efficient to execute if you specify that one type. If you want multiple types, then the second way is probably the way to do.