Optics By Example Functional lenses in Haskell

Table of Contents
Obligatory Preamble
	About this book
	Why should I read this book?
	How to read this book
	Chosen language and optics encodings
	Your practice environment
	Following examples
	About the type signatures
	About the exercises
Optics
	What are optics?
	Strengths
	Weaknesses
	Practical optics at a glance
	Impractical optics at a glance
Lenses
	Introduction to Lenses
		Anatomy
		Exercises – Optic Anatomy
	Lens actions
		Viewing through lenses
		Setting through a lens
		Exercises - Lens Actions
	Lenses and records
		Lenses subsume the ``accessor'' pattern
		Building a lens for a record field
		Exercises - Records Part One
		Getting and setting with a field lens
		Modifying fields with a lens
		Automatically generating field lenses
		Exercises - Records Part Two
	Limitations
		Is it a Lens?
		Is it a Lens? – Answers
	Lens Laws
		Why do optics have laws?
		The Laws
		Case Study: _1
		Case Study: msg
		Case Study: lensProduct
		Exercises - Laws
	Virtual Fields
		What's a virtual field
		Writing a virtual field
		Breakage-free refactoring
		Exercises – Virtual Fields
	Data correction and maintaining invariants
		Including correction logic in lenses
		Exercises – Self-Correcting Lenses
Polymorphic Optics
	Introduction to polymorphic optics
		Simple vs Polymorphic optics
	When do we need polymorphic lenses
		Type-changing focuses
		Changing type variables with polymorphic lenses
		Exercises – Polymorphic Lenses
	Composing Lenses
		How do I update fields in deeply nested records?
		Composing update functions
		Composing Lenses
		How do Lens Types Compose?
		Exercises – Lens Composition
Operators
	Lens Operators
	view a.k.a. ^.
	set a.k.a. .
	Chaining many operations
	Using % a.k.a. over
	Learning Hieroglyphics
	Modifiers
	When to use operators vs named actions?
	Exercises – Operators
Folds
	Introduction to Folds
		Focusing all elements of a container
		Collapsing the Set
		Collecting focuses as a list
		Using lenses as folds
		Composing folds
		Foundational fold combinators
		Exercises – Simple Folds
	Custom Folds
		Mapping over folds
		Combining multiple folds on the same structure
		Exercises – Custom Folds
	Fold Actions
		Writing queries with folds
		Queries case study
		Folding with effects
		Combining fold results
		Using `view' on folds
		Customizing monoidal folds
		Exercises – Fold Actions
	Higher Order Folds
		Taking, Dropping
		Backwards
		TakingWhile, DroppingWhile
		Exercises – Higher Order Folds
	Filtering folds
		Filtered
		Exercises – Filtering
	Fold Laws
Traversals
	Introduction to Traversals
		How do Traversals fit into the hierarchy?
		A bit of Nostalgia
		From fold to traversal
	Traversal Combinators
		Traversing each element of a container
		More Combinators
		Traversing multiple paths at once
		Focusing a specific traversal element
	Traversal Composition
		Exercises – Simple Traversals
	Traversal Actions
		A Primer on Traversable
		Traverse on Traversals
		Infix traverseOf
		Using Traversals directly
		Exercises – Traversal Actions
	Custom traversals
		Optics look like traverse
		Our first custom traversal
		Traversals with custom logic
		Case Study: Transaction Traversal
		Exercises – Custom Traversals
	Traversal Laws
		Law One: Respect Purity
		Law Two: Consistent Focuses
		Good Traversal Bad Traversal
		Exercises – Traversal Laws
	Advanced manipulation
		partsOf
		Polymorphic partsOf
		partsOf and other data structures
		Exercises – partsOf
Indexable Structures
	What's an ``indexable'' structure?
	Accessing and updating values with `Ixed'
		The Ixed Class
		Accessing and setting values with ix
		Indexed Structures
		Indexing monomorphic types
		Indexing stranger structures
	Inserting & Deleting with `At'
		Map-like structures
		Manipulating Sets
		Exercises – Indexable Structures
	Custom Indexed Data Structures
		Custom Ixed: Cyclical indexing
		Custom At: Address indexing
		Exercises – Custom Indexed Structures
	Handling missing values
		Checking whether updates succeed
		Fallbacks with `failing'
		Default elements
		Checking fold success/failure
		Exercises – Missing Values
Prisms
	Introduction to Prisms
		How do Prisms fit into the hierarchy?
		Simple Pattern-Matching Prisms
		Checking pattern matches with prisms
		Generating prisms with makePrisms
		Embedding values with prisms
		Other types of patterns
		Exercises – Prisms
	Writing Custom Prisms
		Rebuilding _Just and _Nothing
		Matching String Prefixes
		Cracking the coding interview: Prisms style!
		Exercises – Custom Prisms
	Laws
		Law One: Review-Preview
		Law Two: Prism Complement
		Law Three: Pass-through Reversion
		Summary
		Exercises – Prism Laws
	Case Study: Simple Server
		Path prefix matching
		Altering sub-sets of functions
		Matching on HTTP Verb
Isos
	Introduction to Isos
		How do Isos fit into the hierarchy?
		There and back again
	Building Isos
	Flipping isos with from
	Modification under isomorphism
	Varieties of isomorphisms
		Composing isos
		Exercises – Intro to Isos
	Projecting Isos
		Exercises – Projected Isos
	Isos and newtypes
		Coercing with isos
		Newtype wrapper isos
	Laws
		The one and only law: Reversibility
		Exercises – Iso Laws
Indexed Optics
	What are indexed optics?
	Index Composition
		Custom index composition
		Exercises – Indexed Optics
	Filtering by index
		Exercises – Index Filters
	Custom indexed optics
		Custom IndexedFolds
		Custom IndexedTraversals
		Index helpers
		Exercises – Custom Indexed Optics
	Index-preserving optics
Dealing with Type Errors
	Interpreting expanded optics types
	Type Error Arena
		First Foe: Level 1 Lenslion
		Level 2 Tuplicant
		Level 3 Settersiren
		Level 4 Composicore
		Level 5 Foldasaurus
		Level 6 Higher Order Beast
		Level 7 Traversacula
Optics and Monads
	Reader Monad and View
	State Monad Combinators
	Magnify & Zoom
Classy Lenses
	What are classy lenses and when do I need them?
		No duplicate record fields
		Separating logic and minimizing global knowledge
		Granular dependencies with makeFields
		Field requirements compose
	makeFields vs makeClassy
JSON
	Introspecting JSON
	Diving deeper into JSON structures
	Traversing into multiple JSON substructures
		Traversing Arrays
		Traversing Objects
	Filtering JSON Queries
	Serializing & Deserializing within an optics path
	Exercises: Kubernetes API
		BONUS Questions
Appendices
	Optic Composition Table
	Optic Compatibility Chart
	Operator Cheat Sheet
		Legend for Getters
		Legend for Setters/Modifiers
	Optic Ingredients
Answers to Exercises
	Optic Anatomy
	Lens Actions
	Records Part One
	Records Part Two
		Laws
	Virtual Fields
	Self-Correcting Lenses
	Polymorphic Lenses
	Lens Composition
	Operators
	Simple Folds
	Writing Custom Folds
	Querying Using Folds
	Higher Order Folds
	Filtering
	Simple Traversals
	Traversal Actions
	Custom Traversals
	Traversal Laws
	partsOf
	Indexable Structures
	Custom Indexed Structures
	Missing Values
	Prisms
	Custom Prisms
	Prism Laws
	Intro to Isos
	Projected Isos
	Iso Laws
	Indexed Optics
	Index Filters
	Custom Indexed Optics
	Type Errors
		First Foe: Level 1 Lenslion
		Level 2 Tuplicant
		Level 3 Settersiren
		Level 4 Composicore
		Level 5 Foldasaurus
		Level 6 Foldasaurus
		Level 7 Traversacula
	Kubernetes API
		BONUS Questions
Upcoming Chapters
Thanks
	Patreon Supporters
	Book Cover