什么`... - > ta - > ...`在Haskell中的类型签名中意味着什么？

Question

In the sign signature of the functions all and any , I see this:

Prelude> :t all 
all :: Foldable t => (a -> Bool) -> t a -> Bool
Prelude> :t any
any :: Foldable t => (a -> Bool) -> t a -> Bool

However, what does ... -> ta ->... mean ?

Isn't both t and a a type variable ? if so, what does the juxtapositions of two type variable mean in Haskell ?

Answer 1

Isn't both t and aa type variable? if so, what does the juxtapositions of two type variable mean in Haskell?

Like a data constructor can take parameters (for example Just ), a type constructor can take parameters as well, these parameters are then types. For example the Maybe type constructor takes a type parameter (for example Int ), and then is a type Maybe Int .

One can for example use a list [] to store elements, but there is still a type parameter to be resolved: the type of objects the list will store. [] Int or [Int] is then a list of Int s.

Now Foldable types are types that can be folded. For example a list [] is a Foldable (note that we use [] , not [a] or [Int] ) as well as a Maybe , or for example a Tree . Most "collections" of elements are Foldable s, although types that are not collections can be Foldable s and vice versa.

The all :: Foldable t => (a -> Bool) -> ta -> Bool and any :: Foldable t => (a -> Bool) -> ta -> Bool are functions that can operate on Foldable s. The advantage is thus that we can write all and any to operate on a list of a s (so [a] ), but a Maybe a can be used as well: you can see Maybe as a type that is a collection that either contains no elements ( Nothing ), or exactly one element ( Just x with x the element). We can for example write:

Prelude> all id Nothing
True
Prelude> all id (Just True)
True
Prelude> all id (Just False)
False
Prelude> all id []
True
Prelude> all id [True]
True
Prelude> all id [False]
False
Prelude> all id [False, True]
False
Prelude> all id [True, True]
True

The all thus can work on lists, Maybe s, but a lot of other types as well.