Skip to content

Instantly share code, notes, and snippets.

Show Gist options
  • Save kana-sama/735549b8baaa783d6fc563e65f3299d5 to your computer and use it in GitHub Desktop.
Save kana-sama/735549b8baaa783d6fc563e65f3299d5 to your computer and use it in GitHub Desktop.

[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
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment