  ███████╗██████╗     ██╗███╗   ██╗███████╗██╗ ██████╗ ██╗  ██╗████████╗███████╗
  ██╔════╝██╔══██╗    ██║████╗  ██║██╔════╝██║██╔════╝ ██║  ██║╚══██╔══╝██╔════╝
  █████╗  ██████╔╝    ██║██╔██╗ ██║███████╗██║██║  ███╗███████║   ██║   ███████╗
  ██╔══╝  ██╔═══╝     ██║██║╚██╗██║╚════██║██║██║   ██║██╔══██║   ██║   ╚════██║
  ██║     ██║         ██║██║ ╚████║███████║██║╚██████╔╝██║  ██║   ██║   ███████║
  ╚═╝     ╚═╝         ╚═╝╚═╝  ╚═══╝╚══════╝╚═╝ ╚═════╝ ╚═╝  ╚═╝   ╚═╝   ╚══════╝

root@fp-insights:~$ █

> FP Insights█

An interactive deep-dive into Functional Programming in Scala — recommended by Boris (Anthropic CEO).
This is NOT a Scala book. These concepts apply in Python, JavaScript, Go, Rust — any language.

10 concepts · Plain English · Interactive demos · Quizzes · Jargon glossary

CHOOSE A CONCEPT

CONCEPT 01 · FOUNDATIONS

Referential Transparency

The one rule that makes code easy to test, debug, and reason about.

corepure functionstesting

CONCEPT 02 · FOUNDATIONS

Pure Core / Thin Shell

The architecture that makes complex software testable with zero mocks.

architecturetestingdesign

CONCEPT 11 · FOUNDATIONS

Immutable Data & Structural Sharing

Why immutable data structures are fast, safe, and enable time-travel debugging.

immutabilitydata structuressharing

CONCEPT 03 · FOUNDATIONS

Errors as Values

How Option/Result/Either make error handling composable and visible.

optionresulterror handling

CONCEPT 04 · FOUNDATIONS

Laziness & Pipeline Fusion

How lazy evaluation fuses pipelines and enables infinite sequences.

streamsgeneratorsperformance

CONCEPT 05 · FOUNDATIONS

State as a Return Value

The pattern behind Redux, React's useReducer, and testable state machines.

statereduximmutability

CONCEPT 12 · DESIGN

API-First Design

The FP method for designing libraries: start from ideal usage, derive types and laws.

designapilibrary design

CONCEPT 13 · DESIGN

Laws as Design Tools

Every abstraction has laws. Testing them as properties catches bugs that code review misses.

lawsproperty testingcorrectness

CONCEPT 06 · DESIGN

Property-Based Testing

Specify invariants; the framework generates hundreds of random test cases.

testinghypothesisquickcheck

CONCEPT 07 · ABSTRACTIONS

Monoids & Associativity

Why associativity unlocks free parallelism in MapReduce, Spark, and more.

monoidparallelismaggregation

CONCEPT 14 · ABSTRACTIONS

Functor — Map Everything

The simplest context-aware abstraction. Arrays, Promises, Options are all functors.

functormapcontext

CONCEPT 08 · ABSTRACTIONS

The Monad Pattern

The pattern behind Promises, async/await, optional chaining, and Result types.

monadflatmapchaining

CONCEPT 09 · ABSTRACTIONS

Applicative vs Monad

When to use Applicative (parallel/collect-all) vs Monad (sequential/fail-fast).

applicativevalidationparallel

CONCEPT 10 · EFFECTS & IO

Description vs Execution

The FP strategy for IO, streaming, and all side effects. SQL and React already do this.

ioeffectsstreaming

CONCEPT 15 · EFFECTS & IO

Trampolining & Stack Safety

How to make any recursive algorithm stack-safe by returning thunks instead of calling.

recursionstack safetyperformance

CONCEPT 16 · EFFECTS & IO

Stream Processing

Composable state machines that transform data streams with constant memory and resource safety.

streamingiocomposability

JARGON DECODER

Pure Function

A function that always returns the same output for the same input, and does nothing else — no DB calls, no logging, no mutations. Like a calculator.

e.g. add(2, 3) → always 5. Never 6. Never throws. Never logs.

Side Effect

Anything a function does besides computing and returning a value — writing to a database, logging, mutating a variable, sending a network request.

e.g. console.log("hi") is a side effect. So is db.save(user).

Referential Transparency

An expression is referentially transparent if you can replace it with its result everywhere in your code and nothing changes. Like algebra: you can always replace 2+2 with 4.

e.g. If f(x) is referentially transparent, then f(f(x)) = f(result).

Immutability

Never changing data after it's created. Instead of modifying an object, create a new one with the changes. React state works this way.

e.g. const newUser = {...user, name: "Bob"} instead of user.name = "Bob"

Option / Maybe

A type that represents a value that might not exist. Either Some(value) or None. Replaces null checks.

e.g. findUser(id) returns Option<User> — either Some(user) or None, never null.

Either / Result

A type that represents success or failure. Either Right(value) (success) or Left(error) (failure with reason).

e.g. parseJson(str) returns Either<Error, Data> — Right(data) or Left("invalid JSON").

Functor

Anything you can map over — apply a function to values inside a container without changing the container's shape.

e.g. [1,2,3].map(x => x*2) → [2,4,6]. The array shape is preserved. Arrays are functors.

Monad

A pattern for chaining operations where each step might produce a "special" result (failure, multiple values, async). flatMap lets each step choose what comes next.

e.g. Promises are monads. .then() is flatMap. Rejection short-circuits the chain.

flatMap / andThen / bind

The operation that chains monadic steps. It takes a value inside a context, applies a function that returns a new context, and flattens the result.

e.g. getUser(id).flatMap(user => getOrders(user.id)) — orders depends on the user.

Applicative

Like a monad, but for independent operations. map2 combines two effects that don't depend on each other. This lets you collect ALL errors, or run things in parallel.

e.g. Promise.all([fetchUser, fetchSettings]) is applicative — both run independently.

Monoid

Any type with an associative "combine" operation and an identity (neutral) element. Because grouping doesn't matter, you can split and parallelise freely.

e.g. Integers with addition (identity: 0). Strings with concat (identity: ""). Lists with append.

Higher-Order Function (HOF)

A function that takes other functions as arguments or returns functions. map, filter, and reduce are HOFs.

e.g. array.filter(x => x > 5) — filter takes a function as argument.

IO Monad

A way to describe computations that interact with the world (files, network, console) as pure values. Like writing a recipe rather than cooking. You run the recipe only at the very end.

e.g. readFile("x.txt") returns IO<string> — a description of reading. Call run() to actually read.

ADT (Algebraic Data Type)

A type defined by its possible "shapes". Like an enum but each option can carry data.

e.g. type Shape = Circle(radius) | Rectangle(w, h) | Triangle(a, b, c)

Lazy Evaluation

Don't compute a value until it's actually needed. The opposite of eager/strict evaluation.

e.g. Python generators are lazy — they produce values one at a time, only when asked.

Tail Recursion

A recursive function where the recursive call is the very last operation. The compiler can convert this to a loop — no stack overflow.

e.g. function sum(n, acc=0): if n===0 return acc; return sum(n-1, acc+n)

Type Class

An interface/contract that multiple unrelated types can implement independently. Like Java interfaces but not requiring inheritance.

e.g. Comparable in Java is like a type class — any type can implement it without extending a base class.