Based upon the standardised ladder of functional programming


Immutable DataUse second-order functions (map, filter, fold) on immutable data structures
Second-Order FunctionsDestructure values to access their components
Constructing & DestructuringUse data types to represents optionality
Function CompositionRead basic type signatures
First-Class Functions & LambdasPass lambdas to second-order functions

advanced beginner

Algebraic Data TypesSolve problems without nulls, exceptions or type casts
Pattern MatchingProcess & transform recursive data structures using recursion
Parametric PolymorphismAble to use functional programming “in the small”
General RecursionWrite basic monadic code for a concrete monad
Type Classes, Instances & LawsCreate type class instances for customer data types
Lower-Order Abstractions (Equal, Semigroup, Monoid)Model a business domain with ADTs
Referential Transparency & TotalityWrite functions that take and return functions
Higher-Order FunctionsReliably identify and isolate pure code from impure code
Partial-Application, Currying & Point-free StyleAvoid introducing unnecessary lambdas and named parameters


Generalised Abgebraic Data TypesAble to use functional programming “in the large”
Higher-Kinded TypesTest code using generators and properties
Rank-N TypesWrite imperative code in a purely functional way through monads
Folds & UnfoldsUse popular purely functional libraries to solve business problems
Higher-Order Abstractions (Category, Functor, Monad)Separate decision from effects
Basic OpticsWrite a simple customer lawful monad
Efficient Persistent Data StructuresWrite production medium-sized projects
Existential TypesUse lenses and prisms to manipulate data
Embedded DSLs using CombinatorsSimply types by hiding irrelevant data with existentials


CodataDesign a minimally-powerful monad transformer stack
(Co) Recursion SchemesWrite concurrent and streaming programs
Advanced OpticsUse purely functional mocking in tests
Dual Abstractions (Comonad)User type classes to modularly model different effects
Monad TransformersRecognise type patterns and abstract over them
Free Monads & Extensible EffectsUse functional libraries in novel ways
Functional ArchitectureUse optics to manipulate state
Advanced Functors (Exponential, Profunctors, Contravariant)Write custom lawful monad transformers
Embedded DSLs using GADTs, Finally TaglessUse free monads / extensible effects to separate concerns
Advanced Monads (Continuation, Logic)Encode invariants at the type level
Type Families, Functional DependenciesEffectively use FDs / type families to create safer code


High-PerformanceDesign a generic, lawful library with broad appeal
Kind PolymorphismProve properties manually using equational reasoning
Generic ProgrammingDesign and implement a new functional programming language
Type-Level ProgrammingCreate novel abstractions with laws
Dependent-Types, Singleton TypesWrite distributed systems with certain guarantees
Category TheoryUse proof systems to formally prove properties of code
Graph ReductionCreate libraries that do not permit invalid states
Higher-Order Abstract SyntaxUse dependent-typing to prove more properties at compile-time
Compiler Design for Functional LanguagesUnderstand deep relationships between different concepts
Profunctor OpticsProfile, debug and optimise purely functional code with minimal sacrifices