It's supposed to be

   why(why(why(why(why(theMatter))));

not

   why(theMatter);
   why(theMatter);
   why(theMatter);
   why(theMatter);
   why(theMatter);

Careful, enough why()'s and you invariably get nil. This is a pointer your employer probably doesn't want you to follow.

I usually get "Because BIG BANG".

But good point - you want the why function to write the intermediate answers somewhere as a side effect.

I'd be interested to know why(Because BIG BANG)

When I'm interviewing for a job at VW and they ask this question, I can deflect with my curry skills.

compiler error at line 1. unmatched parenthesis.

... oh don't worry it's a loosely bracketed language.

That's one of the best points of Haskell:

why . why . why . why . why $ theMatter

Actually that is point-free

In a stack language:

  theMatter why why why why why

I think its more like:

    Answer Why(Answer question) {
        if(validDivisibleQuestion(question){
            return Why(question);
        }
    }

I guess this is how our mind handles stuff too, and because of the stack issues is why working things on papers works better than doing it in mind.

Well, that's possible. But sometimes also the whys are mutually recursive.

"Why is X unelectable? Because realistically no one will vote for him. And why will no one vote for him? Because he is unelectable"

I think the worst case scenario is an answer that forms a question, which lead to the answer framing the very question.

Infinite recursion. Basically.

You could keep the second form but use a ditto operator instead;

   why(theMatter);
   why(%);
   why(%);
   why(%);
   why(%);

A bug that I will blame on unclear requirements.

Why?

That sounds very meta.

Because they make money and it takes a while to get caught.

Why does it take a while to get caught?

That's only one "why".

because the emmissions test conditions are predictable