> I worry about why it doesn't have to say abs(n) but then I remember two negatives multiplied together are positive.

The function doesn't terminate if n is negative, so you are right to worry!

Might be cool to just overload in the function body instead of at the top level:

    fac :: Int -> Int 
      (0) => 1
      (n) => n * fac (n-1)

In Haskell:

    fac :: Int -> Int
    fac x = case x of
      0 -> 1
      n -> n * fac (n-1)

or even

    {-# LANGUAGE LambdaCase #-}

    fac :: Int -> Int
    fac = \case
      0 -> 1
      n -> n * fac (n-1)

Just adding parenthesis to the original would make it clearer and closer to the mathematics expresses the structure. Especially given that parenthesis are clearly used sometimes to designate arguments in here.

    fac :: Int -> Int 
      fac(0) => 1
      fac(n) => n * fac(n-1)

What you're describing is the exact same, just different syntax.

Yes, we are talking about syntax.

OP's first four words: "The thing about syntax".

No, the comment replied to has the first four words "Might be cool to". The differences are so minuscule that the argument could be made for it to be 2 differing standards for the same language.

I don't understand your point, much less why you're using the "first four words" thing back at me on my own comment.

The differences may be miniscule. They are syntactic. "Might be cool to" have this other syntax. You're just belaboring the obvious.

That's the whole point. Syntax can be very influential in how people use (or don't) a language

Yes and no. For what I replied to is essentially garden shedding the language. The overall problem is grasping the concepts, weather or not you want es6 style lambdas, or proper haskell function definitions is irrelevant if you don't understand the concepts.