/FP-Course-ITMO

Slides and other materials for functional programming lectures ITMO university

Primary LanguageHaskell

Haskell ITMO course at CTD

Here you can find plan and presentations on the Haskell course authored by Dmitry Kovanikov and Arseniy Seroka.

This course is always under development and always improving constantly because there's no limit for the best Haskell course.

Course plan

All slides: https://slides.com/fp-ctd

Templates for homework: https://github.com/ChShersh/fp-homework-templates

Lecture 0: Why FP and Haskell ↑

Introductory presentation: here

Lecture 1. Stack. How to build/run/test ↑

  • GHC, GHCi
  • Haskell project structure
  • Stack. Features
  • How stack works. Snapshots
  • .cabal and .yaml files
  • Basic comands

Presentation: https://slides.com/fp-ctd/stack-build#/

Lecture 2: Basic Syntax ↑

  • Introduction to Haskell
    • Basic GHCi examples
    • Function & operators definition
    • Lists and functions on lists
  • Haskell syntax
    • let (variable declaration)
    • where clause
    • if expression
    • Guards
    • case expression
    • Higher order functions
    • Lambdas (anonymous functions)
  • Polymoprhism
    • Parametric
    • Ad-hoc
  • LANGUAGE pragmas
  • Currying (aka partial application)
  • Pattern matching
  • List comprehension
  • Function application: ($)
  • Function composition: (.)
  • Lazy evaluation (erathosphene sieve, fibonacci numbers, repmin)

Presentation: http://slides.com/fp-ctd/lecture-2#/

Lecture 3: Datas, Classes, Instances ↑

Presentation: http://slides.com/fp-ctd/lecture-3#/

Lecture 4: Basic typeclasses: Monoid. Functor. Applicative ↑

Presentation: http://slides.com/fp-ctd/lecture-4#/

Lecture 5: Monads ↑

  • Typed holes
  • What is Monad?
  • Monad type class
  • Monad laws
  • State monad
  • Reader monad
  • Maybe as example, philosophy about null-safety
  • Either monad instance
  • Monad laws

Presentation: http://slides.com/fp-ctd/lecture-5-2019#/

Lecture 5.5: Parser combinators and Property-based-testing ↑

  • Idea of parsing and parser combinators
  • Parser type
    • Basic parsers
    • Instances: Functor, Applicative, Monad, Alternative
    • Usage examples
  • Testing

Presentation: http://slides.com/fp-ctd/lecture-55#/

Lecture 6: RealWorld ↑

Presentation: http://slides.com/fp-ctd/lecture-6#/

Lecture 9: Monad Transformers ↑

Presentation: http://slides.com/fp-ctd/lecture-9#/

Lecture 10: Speeding up haskell ↑

Presentation: http://slides.com/fp-ctd/lecture-10#/

Lecture 11: Template Haskell and Lens ↑

  • Lens
    • Implementing naive data lenses
    • Introducing real Lens'
    • lens, view, set, over definition and explanation
    • 3-step lens guide
    • microlens-family
    • Nice example with real lens (view, traversed, filtered, zoom)
    • Prism
    • Affine traversals
  • -XCPP
  • Template Haskell
    • Boilerplating tuple code
    • Haskell AST
    • Splices
  • -XQuasiQuotes
  • Generate instances with TH

Presentation: http://slides.com/fp-ctd/lecture-11#/

Lecture 12: Parallel and Concurrent Haskell ↑

  • Advantages of immutability and purity
  • Haskell parallelism with rpar and rseq
  • Spark pool, GC and sparks
  • Threadscope
  • Strategies
  • Par monad examples
  • Difference between Parallelism and Concurrency
  • forkIO and MVar
  • Transactions: STM, TVar
  • Async

Presentation: http://slides.com/fp-ctd/lecture-12#/

Lecture 13: Comonads ↑

  • Comonad type class & motivation
  • Zippers
    • List zipper
    • Game of Life
  • Indexed array comonad for image processing
  • Comonadic 2D-parser
  • Type algebra
    • Types as functions (sum, product, type variables)
    • Type isomorphisms
    • Zippers as deriviation: List zipper, Tree zipper
  • Comonads as OOP patterns
  • codo-notation (aka method)
  • Comonad transformers

Presentation: http://slides.com/fp-ctd/lecture-13#/

Lecture 14: Enterprise Haskell ↑

Presentation: http://slides.com/fp-ctd/lecture-14#/

Lecture 15: Advanced type features ↑

Presentation: http://slides.com/fp-ctd/lecture-15#/

Lecture 16: Idris ↑

  • Idris tutorial
  • Idris course
  • Paradigms
    • Totality
    • Strict evalution
    • Theorem proving
    • DSL
    • Extensible effects
  • Syntax difference with Haskell
    • : for type and :: for cons
    • Function overloading
    • Named typeclasses
    • !-idiom
    • [| |]-idiom
    • Records
  • Dependent types
    • Vect data type
    • drop for Vect
    • isEmpty : Vect n a -> Bool
    • isSingleton : Bool -> Type
    • Open and closed doors
    • Total version of head function
    • _|_-eliminator
    • Dependent pair and filter for vectors
    • Type safe printf implementation
  • Simple examples of Eff
    • Tagging tree with labels (and counting leaves)

Uncovered topics ↑

Unfortunately there're some topics which are great but there is no time for them in this course :(