[Haskell-cafe] what are the points in pointsfree?

[Scott Brickner]

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