Instantly share code, notes, and snippets.

# anonymous/c9_note.md Created Mar 1, 2014

What would you like to do?

#Erik Meijer FP Foundamentals Notes

## ch1 Introduction & History

• The next 700 programming languages -- Peter Landin // describede DSL 11:25
• One-combinator basis for lambda-terms -- Jeroen Fokker // SKI combinator 21:04
• Static Typing Where Possible, Dynamic Typing When Needed -- Erik Meijer // 24:00

## ch2 First Step

• prove `xs = take n xs ++ drop n xs` // 7:18
• F# `|>` //9:50
• oop & fp function call syntax, dynamic dispatch , pattern matching ,multimethod //10:40
• operator `.` and Gilad Bracha Block ; OOP and IDE// 16:20

## ch3 Types and Classes

• Value Notation = Type Notation // 7:20
• C# function type //14:55,22:29
• Haskell's funcion type syntax is higly optimise //22:29
• "type application associate to thr right and function application associate to the left" //24:59

## ch4 Defining Functions

• otherwise = true // 10:2*
• algebraic data type in oop // 13:13
• hw: boolean class impl `&&` use double dispatching // 21:07
• bottom `⊥` and lazy //26:17
• distributed computing & bottom(non termination) //39:19
• `n + k` patterns // 49:19

## ch5 List Comprehensions

• ICFP 2009 // begining
• List Comprehension is basic of LINQ

## ch6 Recursive Functions

• Why Functional Programming matters // beginning
• hw: prove `product [1...n] == fac n` (fac is define in recursion) // 10:00
• why calculating is better than scheming // 26:02
• hw: define `zip` for `Enumerable` BART DE SMET's blog post// 28:19
• hw: `append` , C# `foreach` , `O(n^2)` -> `O(n)` // 33:22

## ch7 Higher-order Functions

• To Mock a MockingBird // beginning
• Haskell : executable denotational semantics , Denotational Semantics: A Methodology for Language Development David A. Schmidt //04:58
• visitor,The Visitor Pattern as a Reusable‚ Generic‚ Type−Safe Component Jeremy Gibbons //18:55
• hw : prove `length = sum . map (\_ -> 1) == foldr (\_ n-> 1 + n) 0` //25:58
• A tutorial on the universality and expressiveness of fold , Graham Hutton //30:40
• fusion, banana split rule //34:52
• fix point induction // 38:40

## ch8 Functional Parsers

• http://www.cs.ox.ac.uk/richard.bird/ FUNCTIONAL PEARL
• Lazy Wheel Sieves and Spirals of Primes, Colin Runciman //02:16
• The Genuine Sieve of Eratosthenes,Melissa E. O’Neill
• FUNCTIONAL PEARL Calculating the Sieve of Eratosthenes, LAMBERT MEERTENS //
• Lambert Meertens: master of program calculation , Bird–Meertens Formalism // 03:25
• Anamorphism, Hylomorphism, Grant Malcolm http://cgi.csc.liv.ac.uk/~grant/ , recursion scheme // 04:03
• Algebraic Data Types and Program Transformation, Lambert Meertens PhD thesis
• Algorithmics — Towards programming as a mathematical activity, Lambert Meertens
• Functional Programming with Bananas, Lenses, Envelopes and Barbed Wire
• Haskell:`>>=` ,LINQ:`SelectMany`//31:54
• Executable Grammars in Newspeak, Gilad Bracha///50:32

## ch9 Interactive programs

• unsugar do notation // 14:25
• Don Syme ,agent and mailbox // 30:42
• Explain why haskell to be the world best scripting language //33:18

## ch10 Declaring types and classes

• Prelude
• type level & value level,dependent type, Agda, Cayenne, Coq//06:22
• lambda cube //9:33
• Expression Problem // 24:10
• fold for any algebraic type type , Polytypi Programming //36:20

• ...

## ch12 Lazy evaluation

• call by name & call by value, dual,duality -> Rx //09:23
• Church-Rosser, The Lambda Calculus, H.P. Barendregt //11:00
• `filter (=<5) [1..]` => `(1:(2:(3:(4:(5:⊥)))))`// should use takeWhile
• prime sieve //35:06

## ch13 Equational Reasoning

``````P(Zero)              "uuhm"™
P(n)=>p(Succ n)      "you know"™
--------------------
∀(n::Nat)P(n)
``````

// 08:08

``````f (g x) = h (f x)
f ⊥ = ⊥
-------------------
f (fix g) = fix h
``````
• why dose Erik say "unhm" and "you know" of offen? //52:53
• suggestions // 56:00
• Program Calculation Properties of Continuous Algebras // how to prove properties about recursive functions over recursive datatype // 56:57
• Maarten M. Fokkinga // Category Theory