Standardized Ladder of Functional Programming.md

[Know about it][Understanding][Clear understanding]

NOVICE

CONCEPTS

• xxx Immutable Data
• xxx Second-Order Functions
• xxx Constructing & Destructuring
• xxx Function Composition
• xxx First-Class Functions & Lambdas

SKILLS

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

ADVANCED BEGINNER

CONCEPTS

• xxx Algebraic Data Types
• xxx Pattern Matching
• xxx Parametric Polymorphism
• xxx General Recursion
• xxx Type Classes, Instances & Laws
• xxx Lower-Order Abstractions (Equal, Semigroup, Monoid, etc)
• xxx Referential Transparency & Totality
• xxx Higher-Order Functions
• xxx Partial-Application, Currying, & Point-Free Style

SKILLS

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

COMPETENT

CONCEPTS

• xxx Generalized Algebraic Data Types
• xxx Higher-Kinded Types
• xx- Rank-N Types
• xxx Folds & Unfolds
• xxx Higher-Order Abstractions (Category, Functor, Monad)
• xxx Basic Optics
• xx- Efficient Persistent Data Structures
• xx- Existential Types
• xx- Embedded DSLs using Combinators

SKILLS

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

PROFICIENT

CONCEPTS

• x-- Codata
• x-- (Co)Recursion Schemes
• x-- Advanced Optics
• xx- Dual Abstractions (Comonad)
• xx- Monad Transformers
• x-- Free Monads & Extensible Effects
• --- Functional Architecture
• xxx Advanced Functors (Exponential, Profunctors, Contravariant)
• x-- Embedded DSLs using GADTs, Finally Tagless
• --- Advanced Monads (Continuation, Logic)
• xx- Type Families, Functional Dependencies

SKILLS

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

EXPERT

CONCEPTS

• x-- High-Performance
• xx- Kind Polymorphism
• x-- Generic Programming
• xx- Type-Level Programming
• xx- Dependent-Types, Singleton Types
• xx- Category Theory
• --- Graph Reduction
• --- Higher-Order Abstract Syntax
• --- Compiler Design for Functional Languages
• --- Profunctor Optics

SKILLS

• --- Design a generic, lawful library with broad appeal
• --- Prove properties manually using equational reasoning
• --- Design & 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
• x-- Use dependent-typing to prove more properties at compile-time
• x-- Understand deep relationships between different concepts
• --- Profile, debug, & optimize purely functional code with minimal sacrifices