Fundamentals

"The best way to predict the future is to invent it... The second best way is to fund it. The third best way is to map it."

– Neal Stephenson, Cryptonomicon

Every Java developer has, at some point, stared at a screen wondering why updating a single field in an immutable record requires reconstructing half the object graph. The standard approach (manually copying and rebuilding each layer) works, technically speaking, in the same way that crossing the Atlantic in a rowing boat works. Possible, certainly. Pleasant, no.

Optics offer a rather more civilised alternative. Here is the destination, before any theory: a reusable path from a User down to the name of the street they live on, and two one-line updates through it. Every line compiles against the real library on every build:

var streetName = UserLenses.address()
    .andThen(AddressLenses.street())
    .andThen(StreetLenses.name());

User moved = streetName.set("Baker Street", user);
User shouted = streetName.modify(String::toUpperCase, user);
// moved.address().street().name()   -> "Baker Street"
// shouted.address().street().name() -> "FLEET STREET"
// the whole graph is rebuilt for you; user itself is untouched

At their heart, optics are simply composable, reusable paths through data structures. A Lens focuses on a single field. A Prism handles cases that might not exist. An Iso converts between equivalent representations. None of this is particularly revolutionary in concept (functional programmers have been using these tools for decades), but the practical benefit is considerable: once you've defined a path, you can use it to get, set, or modify values without writing the same tedious reconstruction code repeatedly.

Which optic do you need?

flowchart TD
    Q{"What are you<br/>focusing on?"}
    Q -->|"a field that is<br/>always there"| L(["Lens"])
    Q -->|"one variant of a sealed type,<br/>which might not match"| P(["Prism"])
    Q -->|"a value that may be absent:<br/>an Optional field"| A(["Affine"])
    Q -->|"the same information<br/>in two different shapes"| I(["Iso"])
    Q -->|"every element of a collection<br/>inside a structure"| T(["Traversal<br/>(in Collections)"])

    classDef decision fill:#e5c890,stroke:#df8e1d,color:#232634
    classDef tier fill:#a6d189,stroke:#40a02b,color:#232634
    class Q decision
    class L,P,A,I,T tier

This section introduces the fundamental optics: Lens for product types (records with fields), Prism for sum types (sealed interfaces with variants), Affine for zero-or-one focus, and Iso for reversible conversions. By the end, you'll understand not only how each works, but when to reach for one over another.

The composition rules table at the section's end is worth bookmarking. You'll refer to it more often than you might expect. The Optics landing page carries the overall optics hierarchy if you need to see where these four fit in relation to Traversals, Folds, Getters, and Setters.

Chapter Contents

1. What Are Optics? - Introduction to composable, reusable paths through data
2. Lenses - Focusing on required fields within records
3. Prisms - Safely handling sum types and optional variants
   • Prism Toolkit - Ready-made prisms and matching combinators
   • Validated Prisms - The parse-don't-validate boundary optic
4. Affines - Working with optional fields (zero-or-one focus)
5. Isomorphisms - Lossless conversions between equivalent types
6. Composition Rules - A reference for what type results from combining optics
7. Coupled Fields - Atomic updates for fields with shared invariants

Next: What Are Optics?