second xs = head (tail xs)

Since tail is of type [a] -> [a], xs has to be of type [a] and thus tail xs is of type [a]. Combining this with the type of head (which is [a] -> a), we obtain a for head (tail xs) and thus [a] -> a for second.

swap (x,y) = (y,x)

Since there are no restrictions on x and y, the input of swap is an arbitrary tuple of type (a,b). Swapping the components then yields (b,a) and thus (a,b) -> (b,a) for swap.

pair x y = (x,y)

Since there are no restrictions on x and y, the input of pair are two arbitrary values of types a and b. Constructing a pair out of those values, results in the type (a, b) and thus a -> b -> (a,b) for pair.

double x = x*2

The operation (*) is of type Num a => a -> a -> a, hence x, needs to be of some Num-type, resulting in Num a => a -> a for double.

palindrome xs = Prelude.reverse xs == xs

reverse is of type [a] -> [a] and has no class constraints. On the contrary, (==) is only applicable for types of the Eq class. Putting this together results in Eq a => [a] -> Bool for palindrome.

twice f x = f (f x)

Since f is applied on the result of f x, the input as well as the output of f need to be of the same type as x. There are no further restrictions. Hence the type of twice is (a -> a) -> a -> a.

For reverse we use the auxiliary function snoc ('cons' spelled backwards), which adds an element at the end of a list. Then, using foldr, we obtain

reverse = foldr snoc []

For map we use 'function composition' (.) (where (f . g) x = f (g x), reading 'first apply g and then apply f to the result') together with the 'cons' function (:). Using foldr, we obtain

map f = foldr ((:) . f) []

One possible definition is

concat []     = []
concat (x:xs) = x ++ concat xs

Again, we could use foldr to obtain the shorter definition

concat = foldr (++) []