Pfft, writing a program that collects user input and displays it is just trite. I'm going to skip straight to building an MMO.

You're right. The learning is the point. So rather than flail in the dark, why not learn the optimal solution?

And in order to do that, you have to imagine sisyphus happy

Haskell is beautiful because it resembles math

For more brain flipping try looking into hardware description languages (Verilog) or proof assistants (Coq).

Welp, imma try myself at an explanation. Mostly cause I haven't written Haskell in a while either.

So, that first line:

hanoi :: Integer -> a -> a -> a -> [(a, a)]

...actually only declares the function's type.

In this case, it's a function that takes an Integer and three values of a generic type a and then returns a list of tuples of those same as.
So, those as are just any types representing the towers. Could be strings, integers, custom data types, whatever. The returned tuples represent movements between towers.

Following that are actually two definitions of the function.

The first definition:

hanoi 0 _ _ _ = []

...is the recursion base case. Function definitions are applied, whenever they match, being evaluated top-to-bottom.

This line specifies that it only matches, if that first Integer is 0. It does not care what the remaining parameters are, so matches them with a wildcard _.
Well, and to the right side of the equals sign, you've got the return value for the base case, an empty list.

Then comes the more interesting line, the recursion step:

hanoi n a b c = hanoi (n-1) a c b ++ [(a, b)] ++ hanoi (n-1) c b a

This line matches for any remaining case. Those small letter names are again wildcards, but the matched value is placed into a variable with the provided name.

And then, well, it recursively calls itself, and those ++ are list concations. This line's only real complexity is the usual Tower Of Hanoi algorithm.