Q:

Haskell function type clarification

I am trying to understand Haskell type variables for functions. I wrote a function:
applyTwice f x = f(f x)

I tried to understand the type variables for this function, so I did a :t applyTwice. This is how Haskell interprets the types:
applyTwice :: (t -> t) -> t -> t

Then I created another function:
applyOnce f x = f x

This time for :t Haskell returns
applyOnce :: (t1 -> t) -> t1 -> t

My questions are 

How do we read/understand what these functions take and return?  
This is for applyTwice. If they say anything left side of the -> is what the function takes and right hand side is what it returns then should it not be 
applyTwice :: ((t -> t) -> t) -> t? (t -> t) for (f x) and ((t -> t) -> t) for f (f x) and the return type being t.  
This is for applyOnce. Why is the function's type interpreted as applyOnce :: (t1 -> t) -> t1 -> t? because we only take a function and return it's value. Should it not be applyOnce :: (t1 -> t) -> t1?

As a beginner in Haskell I would like any advice in this. 

A:

We have:
applyTwice f x = f(f x)

This would make sense only if the types of x and f x were equivalent (else how would you be able to pass f x to a function that takes x?). Therefore, you could say that applyTwice takes 2 input arguments:

A function that takes a type t and returns the same type t
An input of some type

Now this input could be of any type, say t1. But you also have to be able to apply the function to this input, and so the type of the input must also be t. Put together, we get the signature:
applyTwice :: (t -> t) -> t -> t

Remember that only the last term is the return type, and all others are types of the inputs.
Now consider:
applyOnce f x = f x

Simplistically, all it says about the function f is that it should be able to accept an input x of any type. There is nothing about what type the function should return except that applyOnce should also return that same type. Hence, we end up with the signature you see:
applyOnce :: (t1 -> t) -> t1 -> t

where t1 could be any type and t could be any type (same or different from t1), but requiring that the return type of f matches the return type of applyOnce, represented by t here.
TL;DR: Your function signature for a function with n inputs will always have (n+1) terms, and the last term will be the return type of the function. 
However, you should note that this is not actually how things work under the hood. All functions in Haskell actually take one argument i.e. they are curried. You can read more about this here.

