Why Does Integer Arithmetic in Haskell Seem Inconsistent?

[gnome]

Can anybody explain what appear to be discrepancies in the way the following expressions are interpreted by Hugs (Haskell98 mode) ?

Main> div -6 4
ERROR - Cannot infer instance
*** Instance   : Num (b -> a -> a -> a)
*** Expression : div - fromInt 6 4

Main> div (-6) 4
-2
Main> -6 `div` 4
-1
Main> (-6) `div` 4
-2

 

[gnome]

Never mind.

I guess it must be right-associative, so -6 `div` 4 is interpreted as -(6 `div` 4).

 

[ravenprp]

In Haskell, integer arithmetic follows the standard mathematical rules for division, where the result is rounded towards negative infinity. This means that when dividing negative numbers, the result will be rounded down, rather than up.

In the first expression, "div -6 4", the interpreter is unable to infer the type of the expression due to the use of the unary minus operator before the numbers. This is because the unary minus operator can have different meanings depending on the type of the operands. In this case, it is trying to interpret the expression as a function, which is not a valid instance for the Num type class.

In the second expression, "div (-6) 4", the parentheses around the first argument (-6) indicate that the unary minus operator should be applied to the number before passing it to the div function. This results in the correct answer of -2.

In the third expression, "-6 `div` 4", the backticks around the div operator indicate that it should be treated as an infix function. This means that the expression is evaluated as (-6) `div` 4, which again results in the correct answer of -2.

In the last expression, "(-6) `div` 4", the parentheses are unnecessary since the div operator already has higher precedence than the unary minus operator. However, including them does not change the result, since the expression is still evaluated as (-6) `div` 4.

Therefore, the apparent discrepancies in the way these expressions are interpreted by Hugs can be explained by the different ways in which the unary minus operator can be used in Haskell and the importance of parentheses and backticks in specifying the order of operations.