gary ng garyng2000 at yahoo.com
Sat Sep 10 23:54:08 EDT 2005

```Ah, lambda, function as first order object and curry.
A million thanks, that clears my mind. It is very hard
for me to shake away the things that I have learnt for
over 20 years. I still think from time to time that
the "accumulator" in foldr/foldl as a constant being
folded and forget that it can be anything. In this
case, because 'n' is not binded during the fold, it(g
(x*n)) becomes a function needing one more parameter
and keeps getting folded. The '1' at the end becomes
this final parameter that makes all these stacked
function in function all being evaluated back to
value.

as I can understand simple tutorials(I used them in my
python programs) about them but only this kind deep
recursive I can see the advantage of curry.

before I tried to see the various factorial
implementation, but I am sure I need to go back to
them again and again as haskell(and the idea behind it
in programming) is not something I can understand in
one go.

IMO, every CS course should teach haskell, as one can
easily pick up C/Pascal etc. without any help but

--- Thomas Spriggs <thomasspriggs at hotmail.com> wrote:

> Well, here goes. The way the lambda function/foldr
> thing evaluates, the
> resulting foldl like function needs a new identity
> parameter hence the
> additional "1". To demonstrate something like how
> this is evaluated for a
> low number eg 3: (Please would someone correct me if
> I have made a mistake
> in this)
> fac 3 = (foldr (\x g n -> g (x*n)) id [1..3]) 1
> fac 3 = (foldr (\x g n -> g (x*n)) id [1,2,3]) 1
> fac 3 = (foldr (\x g n -> g (x*n)) (\n -> id (3*n))
> [1,2])) 1
> fac 3 = (foldr (\x g n -> g (x*n)) (\n -> (\n -> id
> (3*n)) (2*n)) [1]) 1
> fac 3 = (foldr (\x g n -> g (x*n)) (\n -> (\n -> (\n
> -> id (3*n)) (2*n))
> (1*n)) []) 1
> fac 3 = (\n -> (\n -> (\n -> id (3*n)) (2*n)) (1*n))
> 1
> fac 3 = (\n -> (\n -> id (3*n)) (2*n)) (1*1)
> fac 3 = (\n -> (\n -> id (3*n)) (2*n)) 1
> fac 3 = (\n -> id (3*n)) (2*1)
> fac 3 = (\n -> id (3*n)) 2
> fac 3 = id (3*2)
> fac 3 = id 6
> fac 3 = 6
> I would suggest that you use something other than
> the "evolution of a
> of factorial get
> complicated very quickly and its largely use less as
> you should probably
> just use:
> fac n = product [1..n]
> anyway. A better introduction would be something
> like
> http://www.cse.unsw.edu.au/~cs1011/05s2/ and use
>
> and
> http://www.haskell.org/tutorial/ if you want to
> learn something in specific
> or are strugling. All links from
> course.
> >
> >thanks for help in advance.
> You're welcome.
> >
> >regards,
> >
> >gary
> >
> >
> >
> >
>
>______________________________________________________
> relief effort.
> >http://store.yahoo.com/redcross-donate3/
> >_______________________________________________
>
>
>
> Thomas
>
>
_________________________________________________________________
> Be the first to hear what's new at MSN - sign up to
>
>

__________________________________________________
Do You Yahoo!?
Tired of spam?  Yahoo! Mail has the best spam protection around
http://mail.yahoo.com
```