什麼是產生在Haskell

Question

所有整數的無限列表一個很好的方式，我寫在Haskell下面的功能，因爲它會列舉每一個整數：

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

我不知道是否有更好的方法來做到這一點，它看起來有些複雜。

另外，我不知道是否有標準的實現列出維度$ k $的整數格中的所有元素。

Answer 1

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

（或者，如@ DanielWagner在評論液低於工作得更好，我認爲）

Answer 2

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

有沒有什麼標準實現列出所有點ℤ^ķ 。甚至不是對於k == 1，真的。但是任何列舉的ℤ和兩個列表的笛卡爾乘積，即使列表是無限的（有些可能的實現here），也可以在有限索引處輸出任何對，您可以自行編譯。

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]) 

當然你也可以採取非僧的路徑，以及：

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

但你不會明白的mu真諦。

Answer 4

我們已經有很多短的解決方案。這裏是一個具有整數元組的系統。

-- 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..] ] 

一個更簡單的比其中一些被張貼在這裏（雖然它不是通常的順序）的方法。

Answer 6

map (*) [1..] <*> [1,-1]可以將它改寫

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

甚至

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