Skip to content

anonymous /c9_note.md
Created

Embed URL

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP

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
  • "Theorems for free" : Everyone interested in FP should read that // 46:05
  • 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
  • SPJ homepage parallel haskell & Nested Data Parallelism in Haskell

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

  • Philip Wadler
  • 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

ch11 The Countdown Problem

  • ...

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
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Something went wrong with that request. Please try again.