¿Qué es una buena manera de generar una lista infinita de todos los enteros en Haskell

Question

escribí la siguiente función en Haskell, ya que enumera cada número entero:

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

Me pregunto si hay mejores maneras de hacerlo , parece un poco demasiado complicado.

Además, me pregunto si hay implementaciones estándar para enumerar todos los elementos en el enrejado entero de la dimensión $ k $.

Answer 1

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

(o, alternativamente, como en la solución de @ DanielWagner en el comentario anterior que funciona mejor, creo)

Answer 2

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

No hay implementaciones estándar para mostrar todos los puntos en ℤ ^k . Ni siquiera para k == 1, realmente. Pero con cualquier enumeración de ℤ y un producto cartesiano de dos listas que generan cualquier par en un índice finito, incluso si las listas son infinitas (algunas implementaciones posibles here), puede hacer las suyas propias.

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 3

import Control.Applicative 

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

Por supuesto, puede tomar el camino de la no-religioso, así:

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

Pero entonces no va a entender el verdadero significado de mu.

Answer 4

Hemos tenido muchas soluciones cortas. Aquí hay un sistemático, con tuplas de enteros también.

-- 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 5

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

Un método mucho más simple que algunos que fueron publicadas aquí (aunque no es el orden usual).

Answer 6

map (*) [1..] <*> [1,-1] que puede ser reescrito

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

o incluso

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