不知道怎么用。 和Haskell中的$运算符

Question

I am not sure how to implement the . and the $ operators to simplify the following definitions:

compress :: [Char] -> [Char]
compress [] = []
compress as
    | g as 1 == 1 = [head as] ++ compress (drop 1 as)
    | otherwise = [head as] ++ show (g as 1) ++ compress (drop (g as 1) as)

g :: [Char] -> Int -> Int
g [] i = i
g (a:[]) i = i
g (a:as) i
    | a == head as = g as (i + 1)
    | otherwise = i

main = getLine >>= \str -> putStrLn $ compress str

I've read that the . operator is a functional composition so that the output of one function goes to the input of another, and $ is a substitute for a parenthesis.

Therefore, I tried changing it to

compress :: [Char] -> [Char]
compress [] = []
compress as
    | g as 1 == 1 = [head as] ++ compress . drop 1 as
    | otherwise = [head as] ++ show (g as 1) ++ compress . drop (g as 1) as

g :: [Char] -> Int -> Int
g [] i = i
g (a:[]) i = i
g (a:as) i
    | a == head as = g as (i + 1)
    | otherwise = i

main = getLine >>= \str -> putStrLn $ compress str

But I get type errors saying

could not match '[Char]' with a0 -> [Char]

I am a bit confused on how to use those operators.

Answer 1

I do not see a way of using ($) and (.) in this code.

However, you can simplify your code as this:

compress :: [Char] -> [Char]
compress [] = []
compress as@(x:xs)
    | g as 1 == 1 = x : compress xs
    | otherwise = x : show (g as 1) ++ compress (drop (g as 1) as)

g :: [Char] -> Int -> Int
g (a:as) i
    | a == head as = g as (i + 1)
    | otherwise = i
g _ i = i

main = getLine >>= putStrLn . compress

For instance, this:

[head as] ++ compress (drop 1 as)

is the same as this:

head as : compress (drop 1 as)

And by using pattern matching, it becomes even shorter:

x : compress xs

The operators you want to use are commonly use to write a shorter version (with less parentheses) of a function. For instance, your compress function could be written this way:

compress :: [Char] -> [Char]
compress = concatMap (\x -> head x : show (length x)) . group

instead of this:

compress :: [Char] -> [Char]
compress xs = concat $ map (\x -> head x : show (length x)) $ group xs

or even this

compress :: [Char] -> [Char]
compress xs = concatMap (\x -> head x : show (length x)) (group xs)

Here is a simpler example:

capitalizeWords :: String -> String
capitalizeWords string = unwords (map (\(f:rest) -> toUpper f : rest) (words string))

main = putStrLn (capitalizeWords "here you are")

can be rewritten to:

capitalizeWords :: String -> String
capitalizeWords = unwords . map (\(f:rest) -> toUpper f : rest) . words

main = putStrLn $ capitalizeWords "here you are"

Here are the explanations:

The ($) can be used in the main function because this operator can be viewed as wrapping in parentheses what is on the right of it.

For the capitalizeWords function, it can first be simplify to this:

capitalizeWords string = unwords $ map (\(f:rest) -> toUpper f : rest) (words string)

using the previous explanation.

Again, we can use ($) :

capitalizeWords string = unwords $ map (\(f:rest) -> toUpper f : rest) $ words string

And as the string parameter is on the right of both side of the equality, we can use composition to remove this parameter. So we get the final capitalizeWords function shown above.

You can learn more about the ($) and (.) operators here .

There are tools that can help you writing point-free functions like hlint and pointfree .