What is a good way to generate a infinite list of all integers in Haskell

Question

I wrote the following function in haskell, as it will enumerate every integer:

integers = (0:)$ concat $ zipWith (\x y -> [x,y]) [1..] (map negate [1..])

I wonder if there are better ways to do it, it does seem a bit too complicated.

Also, I wonder are there standard implementations to list all elements in the integer lattice of dimension $k$.

Answer 1

integers = 0 : concat [[x,(-x)] | x <- [1..]]

(or, alternatively, as in @DanielWagner's solution in the comment below that works better I think)

Answer 2

import Control.Applicative

integers = 0 : zipWith (*) ([1..] <* "mu") (cycle [1,-1])

Of course you can take the path of the non-monk as well:

integers = 0 : [y | x <- [1..], y <- [x,-x]]

But then you won't understand the true meaning of mu.

Answer 3

map fun [0 .. ]
  where
    fun n
      | even n = n `quot` 2
      | otherwise = (1 - n) `quot` 2

There aren't any standard implementations to list all points in ℤ^k. Not even for k == 1, really. But with any enumeration of ℤ and a cartesian product of two lists that outputs any pair at a finite index even if the lists are infinite (some possible implementations here), you can roll your own.

integers :: [Integer]
integers = -- whatever is your favourite implementation

-- get all pairs at finite index, even for infinite input lists
-- 
cartesian :: [a] -> [b] -> [(a,b)]
cartesian xs ys = ???

-- enumDim k enumerates the points in ℤ^k, to avoid type problems, the points
-- are represented as lists of coordinates, not tuples
enumDim :: Int -> [[Integer]]
enumDim k
  | k < 0     = error "Can't handle negative dimensions"
  | k == 0    = [[]]
  | otherwise = map (uncurry (:)) $ cartesian integers (enumDim (k-1))
  -- alternative:
  {-
  | k == 1    = map return integers
  | otherwise = map (uncurry (++)) $ cartesian (enumDim h) (enumDim (k-h))
    where
      h = k `quot` 2
  -}

Answer 4

map (*) [1..] <*> [1,-1] which can be rewritten

(*) <$> [1..] <*> [1,-1]` 

or even

liftA2 (*) [1..] [-1,1]

Answer 5

We have had many short solutions. Here is a systematic one, with tuples of integers as well.

-- interleave lists
interleave :: [a] -> [a] -> [a]
interleave [] ys = ys
interleave xs [] = xs
interleave (x:xs) (y:ys) = x : y : interleave xs ys

-- positive integers
positiveIntegers = 1 : [k + 1 | k <- positiveIntegers]

-- negative integers
negativeIntegers = map negate positiveIntegers

-- integers
integers = 0 : interleave positiveIntegers negativeIntegers

-- enumeration of the cartesian product of two lists
prod :: [a] -> [b] -> [(a,b)]
prod [] ys = []
prod xs [] = []
prod (x:xs) (y:ys) = (x,y) : interleave (interleave xys yxs) (prod xs ys)
    where xys = map (\y -> (x,y)) ys
          yxs = map (\x -> (x,y)) xs

-- the k-fold power of a list
power :: Int -> [a] -> [[a]]
power 0 xs = [[]]
power k xs = map (\(y,ys) -> y:ys) (prod xs (power (k-1) xs))

-- all quadruples of integers
integerQuadruples = power 4 integers

-- the millionth quadruple is [62501,0,0,1]
something = integerQuadruples !! 1000000

Answer 6

[0..] ++ [ -x | x <- [1..] ]

A much simpler method than some which were posted here (although it's not the usual order).