Haskell，递归数据和模式匹配

Question

is the first time that I work with the recursive data . I can not solve this problem:

data Sseq = S Sseq | E deriving (Show)

testElem = (S, S, E, S)

maxSseq_hlp :: Int -> Int -> [SSeq] -> Int
maxSseq_hlp curmax prevmax [] = max curmax prevmax
maxSseq_hlp curmax prevmax ((S x):xs) = maxSSeq_hlp (curmax+1) prevmax xs
maxSseq_hlp curmax prevmax (E:xs) = maxSSeq_hlp 0 (max curmax prevmax) xs

maxSseq :: [SSeq] -> Int
maxSseq list = maxSseq_hlp 0 0 list

The function maxSseq should return the longest sequence S in a list testElem, using an auxiliary function that remembers the S counted in the previous sequences, but gives me the following error

Couldn't match expected type `[Sseq]'
            with actual type `(Sseq -> Sseq,
                               Sseq -> Sseq,
                               Sseq,
                               Sseq -> Sseq)'
In the first argument of `maxSseq', namely `testElem'
In the expression: maxSseq testElem
In an equation for `it': it = maxSseq testElem

I do not understand where is the problem, can you help me please?

Answer 1

Ok one after the other:

tuple vs lists

Your testElem is not really a list - it is a tuple - so you have to write [..] instead of (..)

constructors

Your Sseq can either be E or S s where s itself has to be a Sseq again - so your testElem will not work this way (that's why you got the error saying you used functions Sseq -> Sseq (those are the S )

I would suggest:

testElem :: [Sseq]
testElem = [S E, S (S (S E)), E, S (S E)]

this should evaluate (IMO) to either 3 or S (S (SE)) depending on your desired behavior of maxSseq (see below)

Use this and try again (I guess this is Homework of some sort)

PS

all the other errors you will see will basically come from misspelling something - mostlikely SSeq VS Sseq ;)

more hints:

• Your function will not work (you consume max. one of the S while counting)
• You can try to fix this by cleverly reinserting the x from (S x)::xs
• But I think what you really want to do is first implement a function len :: Sseq -> Int and then use this cleverly in some way
• based on your description, what you really want is maxSseq :: [Sseq] -> Sseq - so if you stick with your code you have to remember the max. seqence not (only) it's length
• if you are interested you can use my former hint to solve this easily using comparing and maximumBy

I will append my full solution in an hour or so but you should really try it out yourself first.

solutions (don't read if you are still trying)

ok this is how you can patch your solution:

maxSseq_hlp :: Int -> Int -> [Sseq] -> Int
maxSseq_hlp curmax prevmax [] = max curmax prevmax
maxSseq_hlp curmax prevmax ((S x):xs) = maxSseq_hlp (curmax+1) prevmax (x:xs)
maxSseq_hlp curmax prevmax (E:xs) = maxSseq_hlp 0 (max curmax prevmax) xs

and this is what I would advise if you need to find the max. length element :

import Data.List (maximumBy)
import Data.Ord (comparing)

len :: Sseq -> Int
len E = 0
len (S x) = 1 + len x

maxSseq :: [Sseq] -> Sseq
maxSseq = maximumBy (comparing len)