How does the flip function work?

flip' doesn't access x and y. It receives an argument f, and evaluates to the expression g. No x or y in sight.

However, g is itself a function, defined with an auxiliary equation in the where clause of flip'.

You can read g x y = f y x exactly as if it were a top level equation like flip'. So g is a function of two arguments, x and y. It's g that has access to x and y, not flip'. Values for those arguments don't exist until g is applied, which is not until after flip' has returned the function g (if ever).

The thing that's special that about g being defined in the where clause of flip' is that it can have access to the arguments of flip', which is how g can be defined in terms of f.

So when flip' is invoked it receives a function f. For each particular invocation of flip', it constructs a new function g. g would receive two arguments, x and y, when it is called, but that hasn't happened yet. flip' then just returns g as its result.

The Prelude, which is in the base package at hackage.haskell.org, is included with an implicit import in every Haskell file is where the flip function is found. On the right side you can click "source" and see the source code for flip.

flip         :: (a -> b -> c) -> b -> a -> c
flip f x y   =  f y x

The where clause allows for local definitions, x=10 or y="bla". You can also define functions locally with the same syntax you would for the top level. add x y = x + y

In the below equivalent formulation I make the substitution g = f y x

flip         :: (a -> b -> c) -> b -> a -> c
flip f x y   =  g
  where
    g = f y x

Right now g takes no parameters. But what if we defined g as g a b = f b a well then we would have:

flip         :: (a -> b -> c) -> b -> a -> c
flip f x y   =  g x y
  where
    g a b = f b a

No we can do a little algebraic cancelation(if you think of it like algebra from math class you will be pretty safe). Focusing in on:

flip f x y   =  g x y

Cancel the y on each side for:

flip f x   =  g x

Now cancel the x:

flip f   =  g

and now to put it back in the full expression:

flip     :: (a -> b -> c) -> b -> a -> c
flip f   =  g
  where
    g a b = f b a

As a last cosmetic step we can make the substitution a to x and b to y to recover the function down to argument names:

flip     :: (a -> b -> c) -> b -> a -> c
flip f   =  g
  where
    g x y = f y x

As you can see this definition of flip is a little round about and what we start with in the prelude is simple and is the definition I prefer. Hope that helps explain how where works and how to do a little algebraic manipulation of Haskell code.