最新消息:网盘下载利器JDownloader--|--发布资讯--|--站务--|--解压出错.密码问题--

Channel 9 – Advanced Functional Programming Haskell

教程/Tutorials wyy 0评论
Channel 9 - Advanced Functional Programming Haskell

Channel 9 - Advanced Functional Programming Haskell | 3.82GB

Duration: 4h 30m | Video: Windows Media Video 9 1024x768 30.00fps 661kbps | Audio: Windows Media Audio 44100Hz stereo 176kbps

Released: 2010-2011 | Genre: eLearning | Level: Advanced | Language: English

Welcome to another series of C9 Lectures covering functional programming. For this series, Dr. Ralf Lammel has generously taken the time to produce videos for Channel 9 from his office at the University of Koblenz-Landau (Germany), where he is a professor of computer science. The idea here is to take the next step from Erik Meijer's fantastic introductory series on functional programming. Accordingly, Ralf's series will dive into more advanced areas of functional programming, again focusing on the Haskell language (the functional concepts here span beyond any one functional language, however).

Content

The Expression Problem 47 minutes, 51 seconds
To begin, Dr. Lammel teaches us about the Expression Problem. Now put on your thinking caps, make yourself comfortable, and enjoy this installment of functional programming lectures on Channel 9. Huge thanks to Dr. Lammel, both for doing this series for Channel 9 and for filming and producing it all by himself! Finally, thanks to Erik Meijer for suggesting this series and putting me in touch with Ralf.
Type Classes 48 minutes, 56 seconds
In this second lecture in the series, Ralf digs into Type Classes, which are type system constructs that were originally introduced to provide a form of ad hoc polymorphism (i.e., an advanced form of overloading). Type classes amount to an intriguing element of the Haskell language, which is, for example, evident in their ability to solve the Expression Problem (make sure you watch Ralf's first lecture on this subject). Furthermore, type classes directly relate to the interface notion of mainstream OO programming, adding important expressiveness to C#/Java-like interfaces.
Type classes also take functional or declarative programming to a whole new level—one may define relations and functions pointwisely on types. That is, in the same way a regular function pattern matches on value structure, a type-level function sort of matches on type-definitional structure. This is quite a mouthful, I know.
There are various extensibility scenarios in the neighborhood of the Expression Problem that are interesting to consider from a design perspective, including several also addressable with type classes, and others that aren't. Look for the riddles (there are indeed several riddles in this lecture); many of them call for a discussion, rather than a straight solution. But beware—some of them are really difficult.

Evolution of an Interpreter 52 minutes, 38 seconds
More specifically, this lecture develops an interpreter for a simple functional programming language that contains Booleans, natural numbers, lambdas, and recursive lets. The interpreter is actually developed in a stepwise manner, which is why the lecture is called "Evolution of an Interpreter."
In each step, another construct is added and the impact of the extension onto the interpreter is analyzed. In this manner, several interesting programming techniques are exercised. For instance, the Maybe type constructor is pervasively used for dealing with partiality, and Haskell's fixed point combinator is used to model the semantics (i.e., interpretation) of recursive bindings.
This lecture also prepares us for some more advanced subjects. For instance, the next lecture in this series will cover the intriguing subject of monads while using interpretation as the application scenario. Soon, generalized folds (or bananas, according to Erik Meijer) will also be discussed (the folds will traverse abstract syntax trees as opposed to lists).

The Quick Essence of Functional Programming 54 minutes, 48 seconds
Today, Ralf Lammel's lecture goes back to the roots, essentially revisiting Wadler's "The essence of functional programming"—the 1992 paper that discovered monads and popularized their use in functional programming. Ralf Lammel's lecture and accompanying code distribution show Wadler's seminal insight: those original scenarios and observations still make sense today. Indeed, Simon Marlow (a Haskell/GHC high priest @ MSR Cambridge) recently noted: "it's still the best monad tutorial" (see http://twitter.com/simonmar/status/21397398061).
Focusing on a few generically useful monads, Dr. Lammel explains how the work within the interpretation domain. While the lecture also takes a look at the contemporary Haskell library for monads and monad transformers, there are obviously many monads and associated domains that cannot be covered this time. If you want to learn more about monads, then continue with state threads, IO, parsing, and concurrency (STM).
Going Bananas 1 hour, 8 minutes, 33 seconds
Banana is functional programming slang for "fold"—an application of the catamorphic recursion scheme most widely known in the higher-order list processing tradition of Bird-Meertens Formalism and the Squiggol community. Erik Meijer used to be known as the "banana man" because of his early research on the subject; he also co-authored the seminal paper with theoretical (categorical) foundations on the subject. Incidentally, the paper used the notation of so-called "banana brackets" (instead of using the plain string "foldr"), which sort of explains why we sometimes say bananas. There is no shortage of crazy paper titles on the subject, by the way: "Functional Programming with Bananas, Lenses, Envelopes, and Barbed Wire," "Bananas in Space: ...," "Dealing with large bananas," "Boxes go bananas: ...," "See more through lenses than bananas," etc.
More to the point, foldr is the Swiss Army Knife in functional programming. Monoidal reductions of lists or mapping over lists and many other list-processing idioms can be modeled with the regular recursion operator foldr. Even a beginning lecture on functional programming would have to discuss foldr. Not discussing foldr in a Haskell course, however, is like not discussing for loops in a C# course. Indeed, the lectures on Graham Hutton's introductory Haskell course covered the basics of foldr very well. However, a lot more interesting stuff concerning folds or, say, bananas becomes apparent when one becomes fluent in functional programming. For instance, foldr and friends suddenly make sense for container types other than the concrete list type. Foldr and friends even generalize to arbitrary algebraic datatypes in different ways. The combination of folds and monoids also helps us understand key aspects of parallel data processing. These are the more advanced banana subjects that are covered by Ralf Lammel's lecture this time. He has also contributed a stack of bananas papers over the years, and he draws from that interest.

Download uploaded
http://uploaded.net/file/vq8aks3m/Ralf_L.mmel_-_Advanced_Functional_Programming.zip.001
http://uploaded.net/file/428cpoen/Ralf_L.mmel_-_Advanced_Functional_Programming.zip.002
http://uploaded.net/file/3j3xsjtp/Ralf_L.mmel_-_Advanced_Functional_Programming.zip.003
http://uploaded.net/file/4l5yrm0u/Ralf_L.mmel_-_Advanced_Functional_Programming.zip.004
http://uploaded.net/file/ms7iac5i/Ralf_L.mmel_-_Advanced_Functional_Programming.zip.005
http://uploaded.net/file/ucur49lm/Ralf_L.mmel_-_Advanced_Functional_Programming.zip.006
http://uploaded.net/file/0zejmzmx/Ralf_L.mmel_-_Advanced_Functional_Programming.zip.007
http://uploaded.net/file/7asr8odq/Ralf_L.mmel_-_Advanced_Functional_Programming.zip.008
http://uploaded.net/file/ukn1rnkk/Ralf_L.mmel_-_Advanced_Functional_Programming.zip.009

Download 百度云

以下隐藏内容只提供VIP赞助会员

sorry! The following hidden content sponsorship VIP members only.

您必须 登录 才能发表评论!