Prelude> System.Time.getClockTime >>= print
Fri Sep 2 01:13:23 () 2011
@Nawaz: The key thing to note here is that you cannot execute an action from within a function. You can only combine actions and functions together to make new actions. The only way of executing an action is to compose it into your main action. This allows pure functional code to be separated from imperative code, and this separation is enforced by the type system. Treating actions as first class objects also allow you to pass them around and build your own "control structures".
@sepp2k So, myList :: [a -> b] is a function? ;)
@trinithis Well, maybe I should have made it clearer that actions are also functions (just like all values in e.g. Haskell are functions, at least if you call constants nullary functions), but not all functions are actions. But I don't think the term action is misleading or imprecise. An action is a type of value which you can distinguish by its type, just like you can distinguish Ints by their type. I didn't drill too much into the type argument, partly because it's covered in other replies, partly because I wanted to focus on my point.
Another way to explain it is this: no function can get the current time (since it keeps changing), but an action can get the current time. Let's say that getClockTime is a constant (or a nullary function, if you like) which represents the action of getting the current time. This action is the same every time no matter when it is used so it is a real constant.
I don't know if this was any clearer than the other explanations, but it sometimes helps me to think of it this way.
It's not convincing to me. You conveniently called getClockTime an action instead of a function. Well, if you call so, then call every function action, then even imperative programming would become functional programmming. Or maybe, you would like to call it actional programmming.
Likewise, let's say print is a function which takes some time representation and prints it to the console. Since function calls cannot have side effects in pure functional language, we instead imagine that it is a function which takes a timestamp and returns the action of printing it to the console. Again, this is a real function, because if you give it the same timestamp, it will return the same action of printing it every time.
Not everything in Haskell is a function - that's utter nonsense. A function is something whose type contains a -> - that's how the standard defines the term and that's really the only sensible definition in the context of Haskell. So something whose type is IO Whatever is not a function.
Now, how can you print the current time to the console? Well, you have to combine the two actions. So how can we do that? We cannot just pass getClockTime to print, since print expects a timestamp, not an action. But we can imagine that there is an operator, >>=, which combines two actions, one which gets a timestamp, and one which takes one as argument and prints it. Applying this to the actions previously mentioned, the result is... tadaaa... a new action which gets the current time and prints it. And this is incidently exactly how it is done in Haskell.
So, conceptually, you can view it in this way: A pure functional program does not perform any IO, it defines an action, which the runtime system then executes. The action is the same every time, but the result of executing it depends on the circumstances of when it is executed.