How to use the map function in haskell?

Let's take a look at exactly what the error message is saying.

map (take 3) [1, 2, 3, 4, 5]

map's type signature is

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

So it takes a function from a to b and returns a function from [a] to [b]. In your case, the function is take 3, which takes a list and returns a list. So a and b are both [t]. Therefore, the second argument to map should be [[t]], a list of lists. Now, Haskell looks at the second argument and sees that it's a list of numbers. So it says "How can I make a number into a list?" Haskell doesn't know of any good way to do that, so it complains that it doesn't know any type Num [t].

Now, as for what you meant to do, I believe it was mentioned in the comments. The tails function¹ takes a list and returns the list of all tails of that list. So

tails [1, 2, 3, 4, 5]
-- ==> [[1, 2, 3, 4, 5], [2, 3, 4, 5], [3, 4, 5], [4, 5], [5], []]

Now you can apply the take function to each argument.

map (take 3) (tails [1, 2, 3, 4, 5])
-- ==> [[1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5], [5], []]

Oops! We've got some extra values we don't want. We only want the values that have three elements in them. So let's filter out the ones we don't want. filter takes a predicate (which is just a fancy way of saying "a function that returns a Boolean) and a list and returns a list containing only the elements that satisfy the predicate. The predicate we want is one that takes a list and returns whether or not that list has three elements.

\x -> ...           -- We want only the lists
\x -> length x ...  -- whose length
\x -> length x == 3 -- is exactly equal to 3

So that's our function. Now we pass that to filter.

filter (\x -> length x == 3) (map (take 3) (tails [1, 2, 3, 4, 5]))
-- ==> [[1, 2, 3], [2, 3, 4], [3, 4, 5]]

[1] Note that you may need to import Data.List to get the tails function.