A five-level learning roadmap for Functional Programmers

• Immutable data
• Second-order functions
• Constructing and destructuring
• Function composition
• First-class functions and lambdas

• Use second-order functions (map, filter, fold) on immutable data structures
• Destructure values to access their components
• Use data types to represent optionality
• Read basic type signatures
• Pass lambdas to second-order functions

• Algebraic data types
• Pattern matching
• Parametric polymorphism
• General recursion
• Type classes, instances, and laws
• Lower-order abstractions (equal, semigroup, monoid, and so on)
• Referential transparency and totality
• Higher-order functions
• Partial application, currying, and point-free style

• Solve problems without nulls, exceptions, or type casts
• Process and transform recursive data structures using recursion
• Able to use functional programming in the small
• Write basic monadic code for a concrete monad
• Create type class instances for custom data types
• Model a business domain with abstract data types (ADTs)
• Write functions that take and return functions
• Reliably identify and isolate pure code from an impure code
• Avoid introducing unnecessary lambdas and named parameters

• Generalized algebraic data type
• Higher-kinded types
• Rank-N types
• Folds and unfolds
• Higher-order abstractions (category, functor, monad)
• Basic optics
• Implement efficient persistent data structures
• Existential types
• Embedded DSLs using combinators

• Able to implement large functional programming applications
• Test code using generators and properties
• Write imperative code in a purely functional way through monads
• Use popular purely functional libraries to solve business problems
• Separate decision from effects
• Write a simple custom lawful monad
• Write production medium-sized projects
• Use lenses and prisms to manipulate data
• Simplify types by hiding irrelevant data with existential

• Codata
• (Co)recursion schemes
• Advanced optics
• Dual abstractions (comonad)
• Monad transformers
• Free monads and extensible effects
• Functional architecture
• Advanced functors (exponential, profunctors, contravariant)
• Embedded domain-specific languages (DSLs) using generalized algebraic datatypes (GADTs)
• Advanced monads (continuation, logic)
• Type families, functional dependencies (FDs)

• Design a minimally powerful monad transformer stack
• Write concurrent and streaming programs
• Use purely functional mocking in tests.
• Use type classes to modularly model different effects
• Recognize type patterns and abstract over them
• Use functional libraries in novel ways
• Use optics to manipulate state
• Write custom lawful monad transformers
• Use free monads/extensible effects to separate concerns
• Encode invariants at the type level.
• Effectively use FDs/type families to create safer code

CONCEPTS

• High performance
• Kind polymorphism
• Generic programming
• Type-level programming
• Dependent-types, singleton types
• Category theory
• Graph reduction
• Higher-order abstract syntax
• Compiler design for functional languages
• Profunctor optics

• Design a generic, lawful library with broad appeal
• Prove properties manually using equational reasoning
• Design and implement a new functional programming language
• Create novel abstractions with laws
• Write distributed systems with certain guarantees
• Use proof systems to formally prove properties of code
• Create libraries that do not permit invalid states.
• Use dependent typing to prove more properties at compile time
• Understand deep relationships between different concepts
• Profile, debug, and optimize purely functional code with minimal sacrifices