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

paks8150

At last Thursday is here. Smiley

Excelent presentation as always. The only thing is that you missed an excelent opportunity to implement "where" using a list comprehension.

where' :: [a] -> (Int -> a -> Bool) -> [a]
where' xs p = [x | (x,i) <- xs', p i x ]
              where xs' = zip xs [0..]

Thanks again.

I'm looking forward to the next lecture.

exoteric
embarassingly sequential

I love IEnumerable<char> and recently used it for code-generation from XML to a simple Pascal-like language that generates the same XML - although I had some issue with it at first - as if Intellisense didn't recognize this fact that String : IEnumerable<char>.

I'm watching the ICFP videos every evening although quite a few of them are so deeply theoretical that you cannot understand them without quite some CS grounding. Nevertheless, there are also quite a few that are more accessible and show you where the future is, where the Haskell compiler development is, unusual uses of monads etc. So every interesting indeed.

Especially the oscar-winning mathematician from Industrial Light & Magic using monads for untangling knots, describing quantum computation, etc. - that was extremely interesting!

RobertZ

Here's the link for the ICFP 2009 videos.

Thanks for the great lecture series Erik. Converting the Haskell examples into their .NET equivalents really helps drive home some of the concepts for me. I also found your comparison between functional programming and the GOF design patterns quite enlightening.

I am waiting to see if Brian Beckman will "pop" in for the Monads lecture?

Charles
Welcome Change

In reply to RobertZ

#Oct 29th, 2009 @ 1:29 PM

Smiley You never know when the Wizard of Monad will appear....

C

exoteric
embarassingly sequential

In reply to Charles

#Oct 29th, 2009 @ 1:42 PM

Say monad thrice and the Beckman genie is bound by genie law to escape from his Klein bottle and do some monad tricks!

This is of course a lecture series but how wonderful it would be if there would be a few interruptions along the way but of course the Beckman genie is also busy

I loved his input on the IO E2E video where he showed in simplest terms what duality really means. The greatest minds find the simplest solutions. - And make them efficient.

Smiley

Godeke

This is the first of the tutorials to really get into the "meat" of Haskell and I enjoyed it quite a bit (especially the fact that I was able to write the solutions with only a few minor missteps in syntax). I may become a Haskell convert: writing type signatures does make the code that follows much easier to construct.

Richard.Hein
... my guitar gently weeps ...

I take it you meant Enumerable.Range, not Observable.Range?

exoteric
embarassingly sequential

In reply to Richard.Hein

#Oct 29th, 2009 @ 4:37 PM

I bet that was on purpose, to show off the new Observable extensions to .Net. Even if that was probably not especially suitable in this case, there's no reason why it wouldn't apply equally well to an IO as an IE, or so it appears. - Speaking of observations! (Prettified observations)I am starting to see why looking at types is so satisfying! A pure structural/type-level examination of semantics is very fascinating. Looking at currying, lists and tuples in this light will be enlightening.

Head.In.TheBox
Head In The Box

In reply to exoteric

#Oct 29th, 2009 @ 4:43 PM

From http://www.haskell.org/onlinereport/list.html

17.4 unfoldr

The unfoldr function is a "dual" to foldr: while foldr reduces a list to a summary value, unfoldr builds a list from a seed value. For example:

  iterate f == unfoldr (\x -> Just (x, f x))

In some cases, unfoldr can undo a foldr operation:

  unfoldr f' (foldr f z xs) == xs

if the following holds:

  f' (f x y) = Just (x,y)
  f' z       = Nothing