Yes, it is a type signature. It's "function name :: optional type constraints => function of type a -> function of type b -> type c"
take' :: Num i => i -> [a] -> [a] = take' is a function whose first argument is of type i, where the i type must be an instance of the Num typeclass. The function also takes a list of values of type a (any specific type), and returns a list of values of the same type.
take' :: (Num i, Ord i) => i -> [a] -> [a] = take' is a function whose first argument is of type i, where the i type must be an instance of both the Num and Ord typeclasses. The function also takes a list of values of type a (any one type), and returns a list of values of the same type.
So the tuple behind the => doesn't mean that one of the arguments is a tuple, or that the constraints apply to the arguments positionally, but rather that the specified type, e.g. i, must satisfy some constraints--in this case implement Ord and Eq so that you can check if it's below 0 (Ord) and use it as a number (Num.) take' :: i -> [a] -> [a] would have been valid too, but you wouldn't know if you can compare against i, or use it as a number.
If you wanted to sort the [a], then indeed, you would need to make it take' :: (Num i, Ord i, Ord a), since sort from Data.List has a type signature of sort :: Ord a => [a] -> [a]