[Haskell-beginners] Re: folds again -- myCycle

[7stud]

Will Ness <will_n48 <at> yahoo.com> writes:
> In our case, having 
> The access in (head ys) gets traslated in
> 
> head ys = head (ys ++ [1,2,3]) = head ((ys ++ [1,2,3]) ++ [1,2,3])
> 
> but for the other defintion 
> 
> let zs = [1, 2, 3] ++ zs
> 
> it's
> 
> head zs = head([1, 2, 3] ++ zs) = head( (1:[2,3]) ++ zs) 
> = head( 1:([2,3]++zs) ) = 1
> 
> according to the defintion of (++),
> 
> (x:xs)++ys = x:(xs++ys)
> 
> Were we to use the foldr definition, it'll get rewritten just the same, using 
> the foldr definition (as long as it's not the left-recursive defintion):
> 
> foldr f z (a:as) = a `f` foldr f z as
> 
> let ws = foldr (:) [1,2,3] ws
> 
> head ws = head (foldr (:) [1,2,3] ws) 
> = head (foldr (:) [1,2,3] (foldr (:) [1,2,3] ws))
> 
> because 'ws' is getting matched against (a:as) pattern in foldr definition, so 
> is immediately needed, causing INFINITE looping. BUT
>

I'm confused by your statement that ws is getting matched against the
(a:as) pattern in the foldr definition, and therefore it is immediately 
evaluated.   I didn't think the let expression:

> let ws = foldr (:) [1,2,3] ws

would cause infinite looping.

Wouldn't it be the head pattern that is being matched, and therefore head
triggers the evaluation?  Although, I'm not seeing a pattern match here:

>head (x:xs) = x
>head (foldr (:) [1,2,3] (foldr (:) [1,2,3] ws))


..
...
...
..
..
,,,
...
....