Why does mod give a different result in an expression than in a function call?

Question

Say one wants to calculate the function:

f (x,y) = ((x `mod` 3)+(y `mod` 3)) `mod` 2

Then, if one expands f (-1,0) manually, one gets:

((-1 `mod` 3)+(0 `mod` 3)) `mod` 2
1

If one however uses an inline function, the result is:

let f (x,y) = ((x `mod` 3)+(y `mod` 3)) `mod` 2 in f (-1,0)
0

What happens when storing the function that yields not the expected result?

I assume this is because f uses Integral instead of Int?

BTW (and indeed closely related to the problem): you don't need all those parens; `mod` binds automatically more tightly (`infixl 7 mod` vs `infixl 6 +`). You'd be fine with ``((-1)`mod`3 + 0`mod`3) `mod` 2``. — leftaroundabout, Sep 18 '14 at 00:02
@leftaroundabout: True, the brackets were added in order to track down the problem :(. — Willem Van Onsem, Sep 18 '14 at 00:23

score 9 · Accepted Answer · edited May 23 '17 at 12:21

9

Looks like it's a matter of parsing. -1 `mod` 3 gets parsed as -(1 `mod` 3) and not (-1) `mod` 3.

*Main> -(1 `mod` 3)
-1
*Main> (-1) `mod` 3
2

Honestly, the way unary - works in Haskell is a bit of a hack that I personally find confusing. If I really need a negative literal, I usually just add the extra parentheses to be sure.

Another thing to consider is that Haskell has two modulo functions, mod and rem, that treat negative numbers differently. For more details, look to these two other questions.

edited May 23 '17 at 12:21

Community

1
1

answered Sep 17 '14 at 23:39

Tikhon Jelvis

67,485
18
177
214

This is rather strange, given the documentation [here](http://zvon.org/other/haskell/Outputprelude/mod_f.html) seems to suggest experiments are done with negative numerators. – Willem Van Onsem Sep 17 '14 at 23:40
@CommuSoft yeah that page is kind of lame. – luqui Sep 17 '14 at 23:42
In most programming languages, the unary minus binds probably the most to variable, of course now it's too late. But perhaps they better had given the minus more priority. – Willem Van Onsem Sep 17 '14 at 23:53
4

Another point in case for `-XNegativeLiterals`, that extension fixes the issue. – leftaroundabout Sep 17 '14 at 23:59
4

@CommuSoft I argued for prefix - having a different precedence when Haskell was designed, but I was overruled. – augustss Sep 18 '14 at 09:44
@augustss: What was the rationale of the overruler? – Willem Van Onsem Sep 19 '14 at 01:11
@CommuSoft The rationale was that `-x` is a shorthand for `0-x` so having both versions of `-` have the same precedence was natural. I don't agree. – augustss Sep 19 '14 at 08:20

Why does mod give a different result in an expression than in a function call?

1 Answers1

Linked