[gridaphobe]

The type of map is `(a -> b) -> [a] -> [b]`, which means that map takes a function from any type `a` to any type `b` and a list of `a`s, and returns a list of `b`s. Generics, aka parametric polymorphism, are required for this because the definition of map makes no assumptions on what types `a` and `b` will be instantiated to.

[DougWebb]

What does "from any type 'a' to any type 'b'" mean? That sounds like a range of types, but I don't see how that makes sense. Did you just mean that the map converts from 'a' to 'b'?

[FreeFull]

a and b are placeholders (type variables). They can be any type, for example Integer, or a Float. It doesn't matter.

[a] is a list of a, [b] is a list of b. Map takes a function that takes an a and returns a b, and applies it to every element of [a] in order to produce the [b]. An example usage is

  map lessThanThree [1,2,3,4]

In this case, map takes a function where a is an integer, and b is a boolean, then takes a list of integers and produces a list of booleans.

The result is [True,True,False,False]

[jjaredsimpson]

It's also illuminating to note that haskell curries function application. This allows us to think of map as a function of one argument.

map :: (a -> b) -> ([a] -> [b])

so instead of thinking that map takes a function and a list and applies that function to the list, we can think that map takes a function and "lifts" that functions argument and result types to the list type.

This thinking leads us directly to Functors and fmap