<br><br><div class="gmail_quote">On Sun, Mar 29, 2009 at 6:47 PM, Daniel Fischer <span dir="ltr">&lt;<a href="mailto:daniel.is.fischer@web.de">daniel.is.fischer@web.de</a>&gt;</span> wrote:<br><blockquote class="gmail_quote" style="border-left: 1px solid rgb(204, 204, 204); margin: 0pt 0pt 0pt 0.8ex; padding-left: 1ex;">
Am Montag 30 März 2009 00:53:15 schrieb Zachary Turner:<br>
<div class="im">&gt; On Sat, Mar 28, 2009 at 4:53 PM, John Dorsey &lt;<a href="mailto:haskell@colquitt.org">haskell@colquitt.org</a>&gt; wrote:<br>
&gt; &gt; &gt; &gt; How would an experienced guy write this without parentheses?<br>
&gt; &gt; &gt;<br>
&gt; &gt; &gt; I&#39;m fairly certain it&#39;s impossible to write it without using<br>
&gt; &gt; &gt; parentheses.  I would probably just write<br>
&gt; &gt; &gt;<br>
&gt; &gt; &gt;   x - fromInteger (floor x)<br>
&gt; &gt;<br>
&gt; &gt; Never impossible!<br>
&gt; &gt;<br>
&gt; &gt; flip subtract x . fromInteger $ floor x<br>
&gt; &gt; case floor x of y -&gt; x - fromInteger y<br>
&gt; &gt; let y = floor x in x - fromInteger y<br>
&gt;<br>
&gt; I&#39;m a bit of a beginner myself, but I came up with this:<br>
&gt;<br>
&gt; let (|&gt;) x f = f x<br>
&gt; let mapping f x = (x, f x)<br>
&gt; let mapping2 f (x,y) = (x, f y)<br>
&gt; let frac x = x |&gt; mapping id |&gt; mapping2 floor |&gt; mapping2 fromInteger |&gt;<br>
&gt; uncurry (-)<br>
<br>
</div>But John didn&#39;t use<br>
<br>
(-) x . fromInteger . floor $ x<br>
<br>
because it has parentheses, like your version :)<br>
That is easily fixed, though, and since almost everything you ever need has<br>
already been coded by somebody else, let&#39;s use a library instead of (|&gt;),<br>
mapping and mapping2:<br>
<br>
import Control.Arrow<br>
<div class="im"><br>
frac :: RealFrac a =&gt; a -&gt; a<br>
</div>frac = fromInteger . floor &amp;&amp;&amp; id &gt;&gt;&gt; uncurry subtract<br>
<br>
pointfree and without parentheses.<br>
<br>
f &amp;&amp;&amp; g = \x -&gt; (f x, g x)<br>
(for functions, it&#39;s more generally applicable to arrows), so your<br>
&#39;mapping f&#39; is &#39;id &amp;&amp;&amp; f&#39;, your &#39;mapping2 f&#39; would be &#39;second f&#39;, also defined in<br>
Control.Arrow.<br>
You see that these functions are so generally useful that they already are in a<br>
library :)<br>
<br>
(&gt;&gt;&gt;) is forward composition (for functions, it&#39;s defined in Control.Category for<br>
more general settings), useful and readable. You can&#39;t use it to inject the value<br>
into the pipeline, though.<br>
But often that is not necessary and pointfree style is equally readable<br>
(sometimes even more readable).<br>
<div><div></div><div class="h5"><br>
&gt;<br>
&gt; A little extreme, but I still like that it illustrates the |&gt; operator,<br>
&gt; which is actually really useful, I borrowed the concept from F#.  I<br>
&gt; redefined it because I actually have no idea if F# has a similar operator.<br>
&gt; Does it? It&#39;s obviously still easier to read the original parenthesized<br>
&gt; version, but sometimes the |&gt; operator really makes things very readable,<br>
&gt; because it emphasizes the fact that you start with a single value, and send<br>
&gt; that value through a series of transformations one after the other, and you<br>
&gt; can read each transformation in the order that it happens, rather than with<br>
&gt; function composition where you have to scan to the end first to see which<br>
&gt; operation gets applied first.<br>
</div></div></blockquote></div><br>The &amp;&amp;&amp; operator is pretty sweet, thanks for pointing it out.  That&#39;s pretty much what I was trying to come up with the mapping and mapping2, but it&#39;s more general and hence more useful.  <br>
<br>The &quot;pipelining&quot; operator I defined should definitely be used with care.  For example, it requires the pipelined argument to be the last argument, which is not always the case.  And I&#39;ve also found that with it I tend to think about the problem less, and write less efficient code as a result.  For example given a list of integers, an easy and very readable way to remove all multiples of 2 from a list, and then double the remaining items could be like this:<br>
<br>let doit x = x |&gt; filter (\y -&gt; y `mod` 2 == 0) |&gt; map (* 2)<br><br>as opposed to the more efficient<br><br>doit [] = []<br>doit (x:xs) | (x `mod` 2 == 0) = doit xs<br>doit (x:xs) = (2 * x) : doit xs<br><br>since the list is walked twice.  (I&#39;m betting someone will respond with a cool one-liner here involving function composition or something else that I can&#39;t think of yet :)<br>