====== L12. Lazy evaluation ======

<code haskell>
{-

Lazy evaluation strategy:
  - evaluate function first (not parameter first)
  - evaluate each expression AT MOST ONCE!


Applications:
-}


ones = 1:ones

-- evaluating ones loops.

get 0 (x:xs) = []
get k (x:xs) = x : get (k-1) xs

{-

get 2 ones
get 2 (1:ones)
1:(get 1 ones)
1:(get 1 (1:ones))
1:(1:(get 0 ones))
1:(1:[])

[1,1]
-}

member :: Eq a => a -> [a] -> Bool

member x = foldr ((||).(==x)) False

or False x = x
or True _ = True

{-
member 1 [2,1,3,4,5,6,7]
foldr op False [2,1,3,4,5,6,7]

(2==1) || (foldr op False [1,3,4,5,6,7])
False || (foldr op False [1,3,4,5,6,7])

foldr op False [1,3,4,5,6,7]

(1 == 1) || (foldr op False [3,4,5,6,7])

True

Conclusion: lazy foldr is not that bad!


-}

member' :: Eq a => a -> [a] -> Bool
member' x = foldl (flip ((||).(==x))) False

 

nat x = x : (nat (x+1))
nats = nat 0

{-
take 0 _ = []
take n (x:xs) = x:(take (n-1) xs)
-}

type FSuccesor = Integer -> Integer
gen :: FSuccesor -> Integer -> [Integer]

gen f x = x:(gen f (f x))
-- [x, f x, f f x, f f f x, ....]

exx = zipWith (,) (gen (+1) 0) (gen (*2) 1)


{-
   Lista numerelor prime (Sita lui Eratostene)
   2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25

   2 is the first prime
   we need to filter out numbers divisible by 2 from the rest of the stream:

   filter (\k-> k `mod` 2 /= 0) rest

   3,_,5,_,7,_,9,_,11,_,13,_,15,_,17,_,19,_,21,_,23,_,25

   3 is the first prime
   we need to filter out numbers divisible by 3:

   5,_,7,_,_,_,11,_,13,_,_,_,17,_,19,_,_,_,23,_,25

-}

sieve :: [Integer] -> [Integer]
sieve (x:xs) = x:(sieve $ filter (\k-> k `mod` x /= 0) xs)

primes = sieve $ tail $ tail nats

</code>