点函数实际上如何“函数”? [英] How are point-free functions actually "functions"?
问题描述
f = map
和 f => ID 。地图
在这种情况下有所不同?如 f = map
只是一个绑定到一个恰好是 f
的函数的简单的返回 map
(类似于 f = 2
返回 2
)然后接受参数。但 f = id。 map
被称为函数,因为它是免费的。 <康纳尔的博客文章归结为非功能不是功能,例如 False
不是函数。这很明显;如果你考虑所有可能的值并删除那些具有函数类型的值,那么剩下的就是...不是函数。
这完全与
考虑以下函数定义:
map1,map2,map3,map4 ::(a - > b) - > [a] - > [b]
map1 =地图
map2 = id。地图
map3 f =地图f
map4 _ [] = []
map4 f(x:xs)= fx:map4 f xs
这些都是相同函数的所有定义(并且有无限多种方法来定义相当于 map
函数)。 map1
显然是一个无点定义; map4
显然不是。它们都明显具有函数类型(同一个!),那么我们怎么能说无点定义不是函数呢?只有当我们将函数的定义改为Haskell程序员通常的意思(即函数是 x - > y
类型的东西)时,对于一些 x
和 y
;在这种情况下,我们使用 a - > b
为
x
和 [a] - > [b]
for <$ c $
)。
f
,但没有提及第二个参数。
是无点性是定义的质量,而是功能是值的属性。无点函数的概念实际上并不合理,因为给定的函数可以通过多种方式定义(其中一些是无点的,另一些则不是)。每当你看到有人在谈论一个免费的功能时,他们的意思就是一个无点的定义。
你似乎担心 map1 = map
不是一个函数,因为它只是对现有值 map
的绑定,就像 x = 2
。你在这里混淆概念。请记住,函数在Haskell中是一流的; 作为功能的东西是作为价值的东西的<强>子集,而不是一类不同的东西!因此,当 map
是现有值是一个函数时,则是 map1 = map
只是将新名称绑定到现有值。 也定义函数 map1
;这两者不是相互排斥的。
您通过查看代码来回答这是免费的问题。函数的定义。您通过查看类型来回答这是一个函数的问题。
Conal here argues that nullary-constructed types are not functions. However, point-free functions are described as such for example on Wikipedia, when they take no explicit arguments in their definitions, and it seemingly is rather a property of currying. How exactly are they functions?
Specifically: how are f = map
and f = id . map
different in this context? As in, f = map
is simply just a binding to a value that happens to be a function where f
simply "returns" map
(similar to how f = 2
"returns" 2
) which then takes the arguments. But f = id . map
is referred to as a function because it's point-free.
Conal's blog post boils down to saying "non-functions are not functions", e.g. False
is not a function. This is pretty obvious; if you consider all possible values and remove the ones which have a function type, then those that remain are... not functions.
That has absolutely nothing to do with the notion of point-free definitions.
Consider the following function definitions:
map1, map2, map3, map4 :: (a -> b) -> [a] -> [b]
map1 = map
map2 = id . map
map3 f = map f
map4 _ [] = []
map4 f (x:xs) = f x : map4 f xs
These are all definitions of the same function (and there are infinitely many more ways to define something equivalent to the map
function). map1
is obviously a point-free definition; map4
is obviously not. They also both obviously have a function type (the same one!), so how can we say that point-free definitions are not functions? Only if we change our definition of "function" to something else than what is usually meant by Haskell programmers (which is that a function is something of type x -> y
, for some x
and y
; in this case we're using a -> b
as x
and [a] -> [b]
for y
).
And the definition of map3
is "partially point-free" (point-reduced?); the definition names its first argument f
, but doesn't mention the second argument.
The point in all this is that "point-free-ness" is a quality of definitions, while "being a function" is a property of values. The notion of point-free function doesn't actually make sense, since a given function can be defined many ways (some of them point-free, others not). Whenever you see someone talking about a point-free function, they mean a point-free definition.
You seem to be concerned that map1 = map
isn't a function because it's just a binding to the existing value map
, just like x = 2
. You're confusing notions here. Remember that functions are first-class in Haskell; "things that are functions" is a subset of "things that are values", not a different class of thing! So when map
is an existing value which is a function, then yes map1 = map
is just binding a new name to an existing value. It's also defining the function map1
; the two are not mutually exclusive.
You answer the question "is this point-free" by looking at code; the definition of a function. You answer the question "is this a function" by looking at types.
这篇关于点函数实际上如何“函数”?的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持IT屋!