C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals Chapter 6 of 13 | Going Deep

exoteric
I : Next<I>

OK, this is a quick write-up that would seem to fit the bill

public static class Extensions
{
    public static IEnumerable<Tuple<A, B>> Zip<A, B>(this IEnumerable<A> ps, IEnumerable<B> qs)
    {
        if (ps == null)
            throw new ArgumentNullException("ps");
        if (qs == null)
            throw new ArgumentNullException("qs");
        return ps.DoZip(qs);
    }
    private static IEnumerable<Tuple<A, B>> DoZip<A, B>(this IEnumerable<A> ps, IEnumerable<B> qs)
    {
        using (var pe = ps.GetEnumerator())
        {
            using (var qe = qs.GetEnumerator())
            {
                while (pe.MoveNext() && qe.MoveNext())
                    yield return new Tuple<A, B>(pe.Current, qe.Current);
            }
        }
    }
}

Using nested using statements for resource disposal, as prescibed by C# for easy exception safe resource disposal.
Using a separate method to ensure exceptions are thrown upon calling the method.

This doesn't use the more generic version using a function but the pattern is the same (the lower-order Zip can of course be written in terms of the higher-order Zip using Tuple.Create).

As for writing Zip in terms of other LINQ operators: haven't looked into it but you wrote about that, I remember, although not what your precise solution was.

Jonte

I think it's amusing that you refer to Hughes paper on FP as such a good paper, because I'm taking a class of his right now, and he strongly recommends this video series Smiley And, yes, it's a great paper. Good read. Thanks for the awesome video lectures, they complement his course very well!

paks8150

Here is my take on the homework:

1.- Define:

and :

and' :: [Bool] -> Bool
and' [] = True
and' (False:_)  = False
and' (_:xs)     = and xs

concat:

concat' :: [[a]] -> [a]
concat' [] = []
concat' (xs:xss) = xs ++ concat' xss

replicate:

replicate' :: Int -> a -> [a]
replicate' 0 x = []
replicate' (n+1) x = x:replicate' n x

Select the Nth statement of a list:

(!!@) :: [a] -> Int -> a
(!!@) (x:_) 0 = x
(!!@) (_:xs) (n+1) = xs !!@ n

elem:

elem' :: (Eq a) => a -> [a] -> Bool
elem' _ [] = False
elem' x (y:ys) | x == y = True
               | otherwise = elem' x ys

2. Define merge :: [Int] -> [Int] -> [Int]

merge:: (Ord a) => [a] -> [a] -> [a]
merge [] [] = []
merge xs [] = xs
merge [] ys = ys
merge (x:xs) (y:ys) | x < y = x:merge xs (y:ys)
                    | x == y = x:y:merge xs ys
                    | otherwise = y:merge (x:xs) ys

3. Define merge sort:

msort :: (Ord a) => [a] -> [a]
msort [] = []
msort [x] = [x]
msort xs = merge (msort ys) (msort zs)
           where [(ys,zs)] = halve xs

halve :: [a] -> [([a],[a])]
halve [] = []
halve xs = [(take n xs, drop n xs)]
           where n = (length xs `div` 2)

I'm having a blast with this series. Smiley

exoteric
I : Next<I>

In reply to dot_tom

#Nov 5th @ 8:49 AM

It's probably not a complete coincidence that Charles speaks of the high priests of the Lambda calculus.

- folded hands, closed eyes, tilted head, pointing to the sky

May the monad be with you!

Big Smile

Charles
Welcome Change

In reply to exoteric

#Nov 12th @ 2:27 PM

Indeed! You are right, brothers. That still shot captures a moment of extreme reverence, a moment in time where Dr. Meijer, a reverend of the Lambda, evangelist of the functional composition of the monadic universe, exudes his deep thanks and praises for the higher-order function in the sky.

C

avichi

Somewhere closer to the end of the talk, Mr. Meijer says that segregation of common parts

of a function from the distinct parts is only possible with lazy evaluation (with the two clouds

drawn on the board). Didn't he really mean functional composition instead, which is more

general than lazy evaluation? If the distinct parts have no side-effects and the common part has

no influence on the distinct parts besides parametrization (as is the case with pure functions),

then you can also call the common part as a function with distinct parts as pure functional or

value parameters to that common function.

Of course you might save some computations with lazy evaluation, but I am quite sure I have