为什么没有必要在此函数中提供参数？

Question

I'm fairly new to Haskell and this week I found this particular function in a couple of lecture slides. I'm trying to understand why the following function doesn't need to include a parameter:

-- Return all final segments of the argument, longest first 
-- (horrible runtime complexity, used here for illustration purposes only)
tails :: [a] -> [[a]]
tails = reverse . map reverse . inits . reverse

If I would call it like tails "thisisastring" then this would be a valid argument. Isn't it necessary to provide a parameter, for example tails xs = ... . All the other functions I seen before were in that fashion.

Answer 1

This is called point-free style (where "point" is a mathematical term that basically means "argument" here).

Even tails xs = ... is just syntactic sugar for tails = \\xs -> ... , so all you need to do to convince yourself that tails is a function is to recognize that

1. reverse , map reverse , and inits are all functions:

   • map is a higher-order function; it takes one function as an argument and returns another function.

   • map reverse is a function because map is applied to the function reverse .

2. The composition of two functions is another function (assume that the types match up so that we can focus on the result of each composition, instead of verify that each composition type-checks.)

Thus

• reverse . map reverse reverse . map reverse is a function,
• so reverse . map reverse . inits reverse . map reverse . inits reverse . map reverse . inits is a function,
• and reverse . map reverse . inits . reverse reverse . map reverse . inits . reverse reverse . map reverse . inits . reverse is a function.

Since tails is assigned the value of reverse . map reverse . inits . reverse reverse . map reverse . inits . reverse reverse . map reverse . inits . reverse , tails itself is also a function.

Answer 2

The parameter is implicit. Or to put it differently, reverse . map reverse . inits . reverse reverse . map reverse . inits . reverse reverse . map reverse . inits . reverse evaluates to a function of type [a] -> [[a]] .

Consider a simpler example:

double_impl x = x * 2
double = double_impl

The type of double here is the same type as double_impl , ie it takes one parameter of typeclass Num :

main = do 
  print $ double_impl 5
  print $ double 5

-- Out: 10
-- Out: 10

Answer 3

We can see that tails is a function, by checking it's type.

To compute its type, we begin by writing down the types of all the intermediate functions in the composition. Note that we use new type variables for each ocurrence of a function.

reverse :: [a] -> [a]
inits :: [b] -> [[b]]
map :: (c -> d) -> [c] -> [d]

Now we have map reverse has type [[e]] -> [[e]] since we get c=d=[e] for some type e from comparing the expressions

reverse :: c -> d  -- for some c and d
reverse :: [e] -> [e] -- for some e

Hence the last two intermediates have types

map reverse :: [[e]] -> [[e]]
reverse :: [f] -> [f]

Now we start trying to match up types. Let me emphasize first that obviously THESE ARE NOT REAL TYPES! (sorry for the all caps, but I don't want anyone to miss that.)

inits . reverse :: [a] -*- [a] = [b] -*> [[b]]
-- I'm using a -*- b -*> c to denote the type a -> c obtained by
-- composing a function of type a -> b with one of type b -> c.
-- The *s are to break the double dashes up,
-- so they aren't parsed as a comment.
-- Anyway, looking at this type, we see
-- we must have [a] = [b], so a = b
-- we can rewrite the type of inits . reverse as
inits . reverse :: [a] -> [[a]]

Then for the next composition:

map reverse . inits . reverse :: [a] -*- [[a]] = [[e]] -*> [[e]]
-- again, we have [[a]] = [[e]], so e = a, and we have
map reverse . inits . reverse :: [a] -> [[a]]

Finally, we have

reverse . map reverse . inits . reverse :: [a] -*- [[a]] = [f] -*> [f]
-- This time we have [[a]] = [f], so we must have f = [a], so the type
-- of the final composition is
tails = reverse . map reverse . inits . reverse :: [a] -> [[a]]

Since tails has the type [a] -> [[a]] , it must be a function that accepts a list of a s as it's argument and returns a list of lists of a s.