Question

Firstly, apologies for the vague title, but I’m not sure exactly what I’m asking here(!).

After encountering Haskell at university, I’ve recently started using it in anger and so am working through the Project Euler problems as an extended Hello World, really. I’ve encountered a bug in one of my answers that seems to suggest a misunderstanding of a fundamental part of the language, and it’s not something I could work out from the tutorials, nor something I know enough about to start Googling for.

A brief description of the issue itself – the solution relates to primes, so I wanted an infinite list of prime numbers which I implemented (without optimisation yet!) thusly:

isPrime :: Int -> Bool
isPrime n = isPrime' 2 n
            where isPrime' p n | p >= n           = True
                               | n `mod` p == 0  = False
                               | otherwise       = isPrime' (p+1) n

primes :: [Int]
primes = filter isPrime [2..]

Since infinite lists can be a little tedious to evaluate, I’ll of course be using lazy evaluation to ensure that just the bits I want get evaulatued. So, for example, I can ask GHCI for the prime numbers less than 100:

*Main> takeWhile (< 100) primes
[2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97]

Now here’s the part that I don’t understand at all – when the upper limit gets large enough, I get no answers back at all. In particular:

*Main> takeWhile (< 4000000000) primes
[]

This isn’t a problem with takeWhile itself, or the partially-applied function, as takeWhile (< 4000000000) [2..] works as I would expect. It’s not a problem with my use of filter (within the definition of primes), since takeWhile (< 4000000000) (filter even [2..]) also returns the expected result.

Through binary search I found that the greatest upper limit that works is 2^31 - 1, so this would certainly seem to imply some kind of space-based constraint (i.e. largest positive signed integer). However:

1. I was of the impression that Haskell had no language limits on the size of integers, and they were bounded only by the amount of free memory.
2. This number only appears in the less-than predicate, which I know works as expected in at least some cases. Surely when it’s applied to elements of a list, it shouldn’t care where they come from? Looking solely at the first element, I know that the predicate returns true for the input 2 when it comes from filter even [2..]; I know that primes returns 2 as its first element. So how can my list be empty, how is this predicate failing “for some values of 2”?

Any thoughts would be grateful as I don’t have enough experience to know where to start with this one. Thanks for taking the time to take a look.

Answer 1

There are 2 built-in integral types in haskell: Int and Integer. Integer is the default and is unbounded. Int however is bounded. Since you’re explicitly using Int in the type for isPrime 4000000000 is used as an Int and overflows. If you change the type of isPrime to Integer -> Bool or even better Integral a => a -> Bool (read: a function that can take any kind of Integral value and returns a Bool), it will work as expected.

The important thing to take away here (other than the difference between Int and Integer) is that the type of 4000000000 depends on how it is used. If it is used as an argument to a function that takes an Int, it will be an Int (and on 32-bit systems it will overflow). If it is used as an argument to a function that takes an Integer, it will be an Integer (and never overflow). If it is used as an argument to a function that takes any kind of Integral, it will also be an Integer because Integer is the default instance of Integral.