在Haskell中使用foldr实现尾部

Question

So earlier today I asked about implementing inits via foldr . I have a similar question for tails now. First things first: I have A solution. However it's not the solution I need, but the solution I deserve. Or something like that:

Code:

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

This provides correct results, however it does not fulfill the pattern our prof set for us. The pattern looks like this:

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

So obviously my function needs tweaking, however I do not get my head around it, since I always fall back to my solution.

Any tips on how to solve this better?

Thanks in advance.

Solved:

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

Answer 1

Some hints:

• You know that tails [] == [[]] , so your initial value has to be [[]] , so you'll have

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

• length (tails xs !! n) > length (tails xs !! (n+1)) , or in plain english: the length of each tail gets shorter as you go down the list.

• What do you think about foldr (\\x (y:ys) -> undefined : undefined) [[]] ?

If you get stuck after a while again (or have already thought of these), leave a comment and I'll give you another nudge.

Answer 2

Sidenote, its interesting to me that the Haskell community on this site generally don't like to give flat answers, so I guess I will follow the trend (also the OP did not ask for a flat out answer)

Here are some hints:

• foldr folds from right to left

• Look at the output of tails "abc" , it's ["abc", "bc", "c", ""] . How do you construct the list going from right to left? (or in other words, prepending things to the list)

• What is the difference between the elements of the result, looking from right to left? Is there a pattern?

Answer 3

I don't know why, but I seem to be seeing unfolds everywhere of late, including in this question:

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

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