prodotto cartesiano Lazy Haskell

Question

desidero generare un piuttosto grande ma finito prodotto cartesiano in Haskell, che devo poi iterare su (si pensi funzione di partizione di un modello di campo medio). La cosa più naturale da fare usa sequence, in questo modo:

l = sequence $ replicate n [0,1,2] 

Purtroppo, per grandi n, questo non va bene nella memoria e io a corto di cumulo non appena chiedo length l per esempio. Avrei bisogno di un modo per fare la stessa cosa pigramente. Ho finito per "riscoprire" base-3 aritmetica, in questo modo,

nextConfig []  = [] 
nextConfig (0:xs) = 1:xs 
nextConfig (1:xs) = 2:xs 
nextConfig (2:xs) = 0:(nextConfig xs) 

ll = take (3^n) $ iterate nextConfig $ replicate n 0 

(che funziona), ma ci si sente come reinventare la ruota, e inoltre è troppo specifica. Quale sarebbe il modo migliore per generare il prodotto?

Answer 1

Il modo più memoria-friendly si ottiene legando in ordine inverso rispetto alla sequenza,

foo 0 _ = [[]] 
foo k xs = [h:t | t <- foo (k-1) xs, h <- xs] 

E 'più lento a causa di meno la condivisione, ma dal momento che la memoria è il vostro problema, forse è abbastanza buono per voi.