<table cellspacing="0" cellpadding="0" border="0" ><tr><td valign="top" style="font: inherit;">Thank you. That's just what I needed. And your second version shows that I needn't use an anonymous function (lambda expression) at all, something that got lost in translation from Lisp to Haskell.<br><br>First, yes, there was a typo. I couldn't find the original message so had to rewrite.<br><br>Second, the reason I switched to a tuple argument in the first place is that I read somewhere, "Real World Haskell" I think, that Haskell anonymous functions could only have a single parameter (\ n -&gt; ...). Maybe I didn't read far enough or Haskell has since been updated.<br><br>Then, one poster didn't like the use of a (tuple) argument because it couldn't be partially applied, but the whole point of anonymous functions is for one off stuff, like these verifiers, where one doesn't want to create a named function that's used just once.<br><br>In any case, the
 function we pass to makeVerifier, whether anonymous or in the WHERE of your clarified version, is a function that only appears in the definition of a particular verifier, so what difference can it possibly make whether or not it can be partially applied? That's what I can't get my head around.<br><br>Thanks again.<br><br>Michael<br><br>--- On <b>Sun, 4/12/09, Ross Mellgren <i>&lt;rmm-haskell@z.odi.ac&gt;</i></b> wrote:<br><blockquote style="border-left: 2px solid rgb(16, 16, 255); margin-left: 5px; padding-left: 5px;"><br>From: Ross Mellgren &lt;rmm-haskell@z.odi.ac&gt;<br>Subject: Re: [Haskell-cafe] Functions that return functions<br>To: "michael rice" &lt;nowgate@yahoo.com&gt;<br>Cc: "Daniel Fischer" &lt;daniel.is.fischer@web.de&gt;, haskell-cafe@haskell.org<br>Date: Sunday, April 12, 2009, 11:59 PM<br><br><div class="plainMail"><br>On Apr 12, 2009, at 11:50 PM, michael rice wrote:<br><br>&gt; I'm not sure what you're trying to tell me, so let's try a
 specific case.<br>&gt; <br>&gt; <br>&gt; Here's the makeVerifier function that expects its function f to have a single arg, a pair (i,d):<br>&gt; <br>&gt; makeVerifier :: ((Int,Int) -&gt; Int) -&gt; Int -&gt; (Int -&gt; Bool)<br>&gt; makeVerifier f m = divides m . foldl (+) 0 . map f . zip [1 .. ] . digits<br>&gt; <br>&gt; And usage:<br>&gt; let checkCc = makeVerifier (\ (i d) -&gt; if odd i then d else if d &lt; 5 then 2*d else 2*d + 1) 10<br>&gt; <br><br>This looks like it has a typo -- did you mean \ (i, d) -&gt; rather than \ (i d) -&gt; ?<br><br>&gt; <br>&gt; <br>&gt; And here's the old makeVerifier function that expects its function f to have two integer arguments, i &amp; d:<br>&gt; <br>&gt; makeVerifier :: (Int -&gt; Int -&gt; Int) -&gt; Int -&gt; (Int -&gt; Bool)<br>&gt; makeVerifier f m = divides m . foldl (+) 0 . zipWith f [1 .. ] . digits<br>&gt; <br>&gt; And usage:<br>&gt; let checkCc = makeVerifier (\ ....&nbsp; &nbsp; &lt;== Complete
 this&nbsp; ) 10<br>&gt; <br><br>let checkCc = makeVerifier (\ i d -&gt; if odd i then d else if d &lt; 5 then 2*d else 2*d + 1) 10<br><br>though I find it a bit nicer to expand it a bit for clarity:<br><br>checkCc :: Int -&gt; Bool<br>checkCc = makeVerifier f 10<br>&nbsp; &nbsp; where<br>&nbsp; &nbsp; &nbsp; &nbsp; f i d | odd i&nbsp; &nbsp;&nbsp;&nbsp;= d<br>&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; | d &lt; 5&nbsp; &nbsp;&nbsp;&nbsp;= 2*d<br>&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; | otherwise = 2*d + 1<br><br>-Ross<br><br><br>&gt; <br>&gt; --- On Sun, 4/12/09, Ross Mellgren &lt;<a ymailto="mailto:rmm-haskell@z.odi.ac" href="/mc/compose?to=rmm-haskell@z.odi.ac">rmm-haskell@z.odi.ac</a>&gt; wrote:<br>&gt; <br>&gt; From: Ross Mellgren &lt;<a ymailto="mailto:rmm-haskell@z.odi.ac" href="/mc/compose?to=rmm-haskell@z.odi.ac">rmm-haskell@z.odi.ac</a>&gt;<br>&gt; Subject: Re: [Haskell-cafe] Functions that return functions<br>&gt; To: "michael
 rice" &lt;<a ymailto="mailto:nowgate@yahoo.com" href="/mc/compose?to=nowgate@yahoo.com">nowgate@yahoo.com</a>&gt;<br>&gt; Cc: "Daniel Fischer" &lt;<a ymailto="mailto:daniel.is.fischer@web.de" href="/mc/compose?to=daniel.is.fischer@web.de">daniel.is.fischer@web.de</a>&gt;, <a ymailto="mailto:haskell-cafe@haskell.org" href="/mc/compose?to=haskell-cafe@haskell.org">haskell-cafe@haskell.org</a><br>&gt; Date: Sunday, April 12, 2009, 9:23 PM<br>&gt; <br>&gt; Under the covers of syntax they only have one parameter, but you can write curried lambdas or functions easily:<br>&gt; <br>&gt; \ a b -&gt; a + b<br>&gt; <br>&gt; which is equivalent to<br>&gt; <br>&gt; \ a -&gt; \ b -&gt; a + b<br>&gt; <br>&gt; and also equivalent to the "normal" function syntax<br>&gt; <br>&gt; f a b = a + b<br>&gt; <br>&gt; or<br>&gt; <br>&gt; f a = \ b -&gt; a + b<br>&gt; <br>&gt; -Ross<br>&gt; <br>&gt; On Apr 12, 2009, at 9:09 PM, michael rice wrote:<br>&gt; <br>&gt;&gt; My question
 was meant in the context of the makeVerifier function, which is passed a lambda expression. It's my understanding that Haskell lambda expressions can have only a single parameter, which is why I changed the function parameter to a pair, (i,d).<br>&gt;&gt; <br>&gt;&gt; How would it be done otherwise?<br>&gt;&gt; <br>&gt;&gt; Michael<br>&gt;&gt; <br>&gt;&gt; <br>&gt;&gt; --- On Sun, 4/12/09, Daniel Fischer &lt;<a ymailto="mailto:daniel.is.fischer@web.de" href="/mc/compose?to=daniel.is.fischer@web.de">daniel.is.fischer@web.de</a>&gt; wrote:<br>&gt;&gt; <br>&gt;&gt; From: Daniel Fischer &lt;<a ymailto="mailto:daniel.is.fischer@web.de" href="/mc/compose?to=daniel.is.fischer@web.de">daniel.is.fischer@web.de</a>&gt;<br>&gt;&gt; Subject: Re: [Haskell-cafe] Functions that return functions<br>&gt;&gt; To: "michael rice" &lt;<a ymailto="mailto:nowgate@yahoo.com" href="/mc/compose?to=nowgate@yahoo.com">nowgate@yahoo.com</a>&gt;<br>&gt;&gt; Cc: <a
 ymailto="mailto:haskell-cafe@haskell.org" href="/mc/compose?to=haskell-cafe@haskell.org">haskell-cafe@haskell.org</a><br>&gt;&gt; Date: Sunday, April 12, 2009, 7:20 PM<br>&gt;&gt; <br>&gt;&gt; Am Montag 13 April 2009 01:09:22 schrieb michael rice:<br>&gt;&gt; &gt; Example please.<br>&gt;&gt; &gt;<br>&gt;&gt; &gt; Michael<br>&gt;&gt; &gt;<br>&gt;&gt; <br>&gt;&gt; Curried:<br>&gt;&gt; <br>&gt;&gt; f :: a -&gt; b -&gt; c<br>&gt;&gt; <br>&gt;&gt; amenable to partial application.<br>&gt;&gt; <br>&gt;&gt; Uncurried:<br>&gt;&gt; <br>&gt;&gt; g :: (a,b) -&gt; c<br>&gt;&gt; <br>&gt;&gt; not easy to apply partially.<br>&gt;&gt; <br>&gt;&gt; The Prelude contains<br>&gt;&gt; <br>&gt;&gt; curry :: ((a,b) -&gt; c) -&gt; (a -&gt; b -&gt; c)<br>&gt;&gt; <br>&gt;&gt; uncurry :: (a -&gt; b -&gt; c) -&gt; ((a,b) -&gt; c)<br>&gt;&gt; <br>&gt;&gt; to convert if needed.<br>&gt;&gt; <br>&gt;&gt; _______________________________________________<br>&gt;&gt; Haskell-Cafe mailing
 list<br>&gt;&gt; <a ymailto="mailto:Haskell-Cafe@haskell.org" href="/mc/compose?to=Haskell-Cafe@haskell.org">Haskell-Cafe@haskell.org</a><br>&gt;&gt; <a href="http://www.haskell.org/mailman/listinfo/haskell-cafe" target="_blank">http://www.haskell.org/mailman/listinfo/haskell-cafe</a><br>&gt; <br>&gt; <br><br></div></blockquote></td></tr></table><br>