Should point-free function expressions be allowed when a function is asked for?

Question

Should an expression evaluating to a function count as a function for the purpose of providing a solution when a function is asked for? An earlier question on meta seems to indicate a consensus that it is fine to provide a function literal when "a function" is asked for.

Many languages treat functions as first-class citizen, and allow operations on functions such as composition or binding variables. What I wonder is if such expressions that evaluate to a function should be acceptable as an answer.

To illustrate the difference, below is an example of an explicit and a point-free function in Haskell, both yielding the same result.

\xs -> map succ xs            -- explicit ("function literal")
map succ                      -- point-free (partial application due to currying)

-- both behave the same
(\xs -> map succ xs) [1,2,3]  -- evaluates to [2,3,4]
(map succ) [1,2,3]            -- evaluates to [2,3,4]

This seems sufficiently different than the linked question to deserve one on its own. So, what do you think?

Answer 1

Any expression that evaluates to a value of function type can be submitted as a function

I can't see a consistent way that works cross-language to ban functions defined in a point-free style, and in many esoteric languages (e.g. Underload), the point-free style is the only one that exists anyway. Even in more normal languages, surrounding a function with \x->( … )x is just boilerplate, and we normally don't count boilerplate if it's inherent in the way the language works. (See also this newer question which covers the ground of whether parentheses or the equivalent are required around this sort of expression; at the time of writing, we're leaning towards no.)

Note that this differs from an expression that evaluates the answer directly (as opposed to evaluating to a function that evaluates the answer); most (but not) all languages draw a distinction, and in this case the expression is just a snippet. For example, in the OP's example, map succ is a valid function (it has function type, and doesn't do anything unless you call it), but map succ xs is a snippet (because it doesn't evaluate to a function, but rather a value of the base type Enum b => [b]). So valid function submissions would include map succ, (map succ), \x->map succ x, let f=map succ, and let f x=map succ x, because all of these return a function, and don't actually read any input, produce any output, or the like.