How do I modify the values of a tuple and then return them as a tuple of a tuple?

I'm relatively new to programming and Haskell in general. I'm working my way through a book on the language and one of the exercises asks for the following:

Fill in the definition of the following function, using fst and snd:

f :: (a, b) -> (c, d) -> ((b, d), (a, c))
f = undefined

I'm confused what this function signature means for how the actual function should be defined, and for the order of operations in that definition. In plain language, is this saying "take a tuple, and another tuple, and then output the final mixed tuple"? Or is it saying "take a tuple, modify that tuple, and then mix that modified one with the original"?

My issue is, how do I compose the function definition so that fst and snd can make the new tuple? I know I shouldn't use a lot of brackets, but in my head I want to approach the problem by just making a single line function with brackets to simply demarcate the order of operations, like:

f x y = (,) ((,) snd x snd y) ((,) fst x fst y)

But the compiler returns an error. Am I wildly overcomplicating this? x and y are bound to (a,b) and (c,d) respectively, so shouldn't I be able to access them and return a new tuple of a tuple with the order of operations I've made with my brackets?

> Am I wildly overcomplicating this?

Probably yes, the most straightforward way is probably to simply do pattern matching, like:

f :: (a, b) -> (c, d) -> ((b, d), (a, c))
f (a, b) (c, d) = ((b, d), (a, c))

while it is not a "clever trick" or something, it is readable, and easy to inspect, debug and fix.

As for the implementation, you can fix this with:

f x y = (,) ((,) (snd x) (snd y)) ((,) (fst x) (fst y))

or make this more convenient with:

f x y = ((snd x, snd y), (fst x, fst y))

but using fst and snd is typically useful if defining patterns would mean you introduce a lambda expression for example. If you can define a pattern, by using a tuple pattern you make this more readable.

For your function, there is by the way only one sensical implementation (other than using undefined somewhere as (sub)expression), Djinn is a tool that can (exhaustively) enumerate implementations for simply types, and this is the only one that Djinn can find.