[Haskell-beginners] doing state right

[Floptical Logic]

I am using a PPM library to generate a square image where each white
pixel represents a prime number.  The PPM library takes a function
(Int -> Int -> Colour) to create the image.  This interface isn't
ideal but it is what I have to work with.  I am convinced that using a
sieve is faster than testing every pixel in the image for primality,
but the (Int -> Int -> Colour) interface makes this awkward.  The code
below attempts to treat the list of prime numbers as a stack via
global mutable state, popping the head whenever the pixel is prime.
Obviously this is not idiomatic Haskell.  What is the correct approach
of dealing with state here?  Thanks for reading.

import ONeillPrimes
import PPM6
import Colour

import Data.IORef
import System.IO.Unsafe

limit = 2000
slimit = limit*limit

primeList = takeWhile (<=slimit) primes

p :: IORef [Int]
p = unsafePerformIO (newIORef primeList)

pcol n = unsafePerformIO $ do
    xs <- readIORef p
    if null xs then return black else
        if n == head xs
            then do
                writeIORef p (tail xs)
                return white
            else
                return black

main = quick_ppm "foo.ppm" (\i j -> pcol ((i-1)*limit+j)) limit limit

-- quick_ppm :: FilePath -> (Int -> Int -> Colour.Colour) -> Int -> Int -> IO ()