Qual è questo modello di piegatura e iterazione?

Question

Immagina di dover passare una sequenza e di conoscere anche i valori intermedi in diversi punti lungo l'intervallo. Questo è quello che ho usato per questo:

[a,b,c] = map fst . tail $ chain [g i, g j, g k] (zero, sequence) 

g :: Integer -> (a,b) -> (a,b) 

chain (f:fs) x = x : chain fs (f x) 
chain [] x = [x] 

La funzione g consuma una certa parte di una sequenza di ingresso (di lunghezza i, j, ecc), iniziando con un valore di partenza e producendo risultati della stessa digitare, da inserire nella prossima invocazione. Consumare più volte la sequenza per lunghezze diverse a partire dall'inizio e lo stesso valore iniziale sarebbe inefficiente, ovviamente sia in termini di tempo che di spazio.

Quindi da una parte pieghiamo su questa sequenza di numeri interi - punti intermedi sulla sequenza; d'altra parte iteriamo questa funzione, g. Che cos'è? Mi sto perdendo qualcosa di base qui? Questo può essere espresso in qualche modo con il repertorio regolare di pieghe, ecc.?

EDIT:   risolto:   quanto sopra è semplicemente

[a,b,c] = map fst . tail $ scanl (flip g) (zero, sequence) [i, j, k] 

interessante come un'iterazione modificabile effettivamente è ripiegare l'elenco dei modificatori.

Answer 1

Prova scanl: http://www.haskell.org/hoogle/?hoogle=scanl

scanl è simile a foldl, ma restituisce un elenco di successive ridotti valori da sinistra:

scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...] 

Nota che

last (scanl f z xs) == foldl f z xs 

Answer 2

Per approfondire Il commento di Marcin, che, fondamentalmente, vogliono:

intermediates = scanl step zero sequence 
map (\n -> intermediates !! n) [i, j, k] 

step non è g, ma solo la parte di g che consuma un singolo elemento della lista sequence.

Inoltre, accetta Marcin come risposta corretta.