Implementare le code utilizzando foldr in Haskell

Question

Così oggi ho chiesto circa implementing inits via foldr. Ho una domanda simile per le code ora. Per prima cosa: ho una soluzione. Tuttavia non è la soluzione di cui ho bisogno, ma la soluzione che merito. O qualcosa del genere:

Codice:

tails :: [a] -> [[a]] 
tails = foldr (\ x y -> reverse([] : reverse(map (x:) y))) [[]] 

Questo fornisce risultati corretti, ma non soddisfa il modello del nostro prof impostato per noi. Il modello si presenta così:

tails :: [a] -> [[a]] 
tails = foldr (\ x y -> undefined : undefined) undefined 

Così, ovviamente, la mia funzione ha bisogno di modifiche, ma non ho ricevuto la mia testa intorno ad esso, dal momento che ho sempre ricadere la mia soluzione.

Qualche consiglio su come risolvere questo problema?

Grazie in anticipo.

risolto:

tails :: [a] -> [[a]] 
tails = foldr (\ x y -> (x : (head y)) : y) [[]] 

Answer 1

Alcuni indizi:

• Voi sapete che tails [] == [[]], in modo che il valore iniziale deve essere [[]], quindi dovrete

  tails = foldr (\x y -> undefined : undefined) [[]]

• length (tails xs !! n) > length (tails xs !! (n+1)) o in inglese semplice: la lunghezza di ciascuna coda si accorcia man mano che si scende nell'elenco.

• Cosa ne pensi di foldr (\x (y:ys) -> undefined : undefined) [[]]?

Se rimani bloccato dopo un po 'di nuovo (o hanno già pensato di questi), lasciare un commento e io ti do un'altra gomitata.

Answer 2

Sidenote, interessa a me che la comunità Haskell su questo sito in genere non mi piace dare risposte piatte, quindi credo che seguirò la tendenza (anche il PO non ha chiesto una risposta a tutto gas)

Ecco alcuni suggerimenti:

• foldr pieghe da destra a sinistra

• sguardo all'uscita del tails "abc", è ["abc", "bc", "c", ""]. Come costruisci la lista andando da destra a sinistra? (o in altre parole, anteporre le cose all'elenco)

• Qual è la differenza tra gli elementi del risultato, guardando da destra a sinistra? C'è uno schema?

Answer 3

Non so perché, ma mi sembra di vedere dipana ovunque negli ultimi tempi, anche in questa domanda:

import Data.List (unfoldr) 
import Data.Maybe (listToMaybe) 

tails :: [a] -> [[a]] 
tails = unfoldr (\ xs -> listToMaybe xs >> Just (xs, tail xs))