Donald Bruce Stewart wrote:
>sdowney:
>>>>i'm not naive enough to think they are the composition function, and
>>i've gathered it has something to do with free terms, but beyond that
>>i'm not sure. unless it also has something to do with fix points?
>>>>>>The wiki knows all! :)
>>http://haskell.org/haskellwiki/Pointfree>> 1 But pointfree has more points!
>> A common misconception is that the 'points' of pointfree style are the (.)
> operator (function composition, as an ASCII symbol), which uses the same
> identifier as the decimal point. This is wrong. The term originated in
> topology, a branch of mathematics which works with spaces composed of points,
> and functions between those spaces. So a 'points-free' definition of a function
> is one which does not explicitly mention the points (values) of the space on
> which the function acts. In Haskell, our 'space' is some type, and 'points' are
> values.
>>Hm. I've been lurking for a while, and this might be a bit of
nit-picking as my first post, especially given I'm still a bit of a n00b
in Haskell. I've been programming a long time, though - coming up on
three decades now and virtually all of it really programming, no management.
Anyway, as I understood it, the "points" were the terminal objects of
the category in which you're working - in this case, pointed continuous
partial orders (CPO), and the points are effectively values in the
domain. The usage of "point" for terminal objects comes from the
category of topological spaces, as you say,. and algebraic topology is
where category theory found it's first big home - but that's not really
what we're talking about here, is it?
Category theory got the term from topology, which got it from geometry.
So you could say "point" is "position without dimension" - but that's
just not the "point" we're talking about anymore.
So, the usage of "point" here refers a terminal object in the CPO
category, which means a value of some datatype - in this particular
case, a value in the domain of the function being defined. So when you
give a definition that uses patterns for the parameters, the variables
in the patterns get bound to the values in the domain of the function.
If you write the function in a higher-order style, where you don't bind
the values, your definition doesn't refer to the "point" at which it's
being evaluated, hence "point-free".
--
-----
What part of "ph'nglui bglw'nafh Cthulhu R'lyeh wagn'nagl fhtagn" don't you understand?
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://www.haskell.org/pipermail/haskell-cafe/attachments/20061215/591ba0cd/attachment.htm