a big book of fp for noobs

https://leanpub.com/outsidefp 

( table of contents )

Table of Contents

•  
  • Introduction
    • Why bother with static functional languages?
    • Why is this book called an “outsider’s” guide?
    • What the book covers
    • How the book covers it
    • Prerequisites
    • The exercises
    • The back of the book
    • About the cover
    • Your problems and questions
    • Change log
    • Thanks for the help
• I Elm
  • 1. Functions
    • Applying functions
    • Defining functions
    • Partially-applied functions
    • Idiom: Self goes last
    • Flip: a function that only cares about functions
    • Point-free style
    • Function composition
    • let
    • Two apparently pointless functions
    • What now?
  • 2. Some types
    • The old problem with static typing
    • Concrete types
    • Function types
    • Quantified types
    • Elm cheats, a bit
    • Functions that take functions as arguments
    • What now?
  • 3. Type annotations
    • Terminology. Yay. Terminology
    • Elm is still in charge
    • Narrowing
    • What now?
  • 4. A digression: immutability
    • Building lists
    • Eu sou verde, e daí?
    • “Purity” and other jargon
    • Practical implications: the outside world
    • What now?
  • 5. Maybe and its idioms
    • Making use of Maybe
    • Maybe.map and pipelines of iffy computations
    • At the end of the pipeline
    • Haven’t I seen map somewhere before?
    • Lists of Maybes
    • Multiple Maybe arguments
    • What now?
  • 6. A teaser: designing with types
    • Taking “type-driven” all the way
    • What now?
  • 7. Sum types
    • Sum types explicitly name cases
    • The whole story on sum type declarations
    • Importing modules containing sum types
    • A bit more on pattern matching
    • What now?
  • 8. Sum type idioms
    • Making invalid values impossible
    • Grouping related data
    • Heterogeneous data
    • Abstractions that destroy: Int and Float
    • Generalizing tagged types using phantom types
    • Type aliases: Tagged Percent Float is an OK password, but…
    • What now?
  • 9. Working with the outside world
    • The Elm Architecture (structure)
    • The Elm Architecture (behavior)
    • Producing HTML
    • Random numbers
    • Our first app: a peculiar counter
    • Subscribing to events
    • Responding to browser events
    • What now?
  • 10. Types and program structure
    • Types tie the Elm Architecture together
    • Type variables and libraries
    • What now?
  • 11. Records
    • Making and manipulating records
    • Record types
    • Pattern matching
    • Records are product types
    • Nested records
    • What now?
• II The ToInt Saga
  • 12. Conventional testing
    • Installation and directory layout
    • Structure of a test
    • The Result type
    • Expect functions
    • Characterizing String.toInt
    • Explaining my results
    • What does the repl know, and when does it know it?
    • What now?
  • 13. Recursion and folding
    • Tail recursion
    • Folding
    • The performance of lists
    • Two types of recursion
    • What now?
  • 14. Surviving a messy problem: a real toInt
    • Recursion and wrappers
    • Lazy evaluation
    • Visibility and testing
    • toInt at last
    • What now?
• III The Saga of the Animation App
  • 15. Architecture and animation
    • A nested architecture
    • Basic animation
    • Time travel
    • Libraries that create Cmd values
    • What now?
  • 16. Pragmatics of multiple modules
    • Circular module dependencies
    • Hiding implementation details
    • What now?
  • 17. A refactoring
    • What now?
  • 18. Animation extras
    • Names
    • A repeating animation
    • Falling realistically
    • Simultaneous animations (an exercise)
    • Multi-step animations (an exercise)
    • Sending messages during animations
    • What now?
  • 19. Text input, form state, and validation
    • Storing state
    • Fields can make invalid values impossible
    • Tracking validation state
    • What now?
  • 20. This app’s structure
  • 21. Design tidbits
    • Tagged types in practice
    • Defining and using operators
    • Information hiding and partitioning
    • Simplifying via deferred computation
    • Ordering computation
    • Too many tuples
    • What now?
  • 22. Continuation-passing style as a design inspiration
    • Continuation-passing style
    • Continuation-passing style for humans
    • The solution, sketched
    • Sequencing animations
    • Looking ahead to PureScript and similar languages
    • What now?
• IV Lenses and Laws
  • 23. Dictionaries and arrays
    • Dictionaries
    • Arrays
    • About data structures
    • What now?
  • 24. Nested structures, law-based design, and a kind of polymorphism
    • Planning a solution
    • Lenses work with records and tuples
    • Using lenses and laws with Dict
    • Combining lenses
    • The Upsert lens
    • Phantom types, Elm records, and polymorphism
    • The Humble lens and its laws
    • Using lenses
    • Working with sum types
    • Terminology, again
    • What now?
  • 25. Monoids, laws, and the avoidance of creepiness
    • Lens composition behaves sensibly
    • Motivating monoids
    • Spot the Monoid
    • Function composition is not quite a Monoid
    • Can lenses be an instance of Category?
    • About creepiness
    • What now?
  • 26. Error handling, pipelines, and JSON
    • The example app
    • The three errors
    • A version with no error handling
    • A version with branchy error handling
    • A version with flow-style error handling
    • A new lens type
    • Flowing state through a pipeline
    • Reporting an error via HTTP
    • Unstunting exercises
    • What now?
  • 27. JSON decoders, functors, and type constructors
    • Functor and its laws
    • What’s up with Result? (type constructors)
    • Are functions functors?
    • Equality
    • Are JSON decoders functors?
    • Using functors
    • Metaphors
    • What now?
• V Design Topics
  • 28. Combining records and sum types
  • 29. More examples of making invalid values impossible
• VI Purescript
  • 30. Blundering into PureScript
    • PureScript expects projects
    • Starting the repl
    • Trying out functions
    • Printing types
    • Numbers
    • Lists and arrays
    • Defining functions
    • Anonymous functions
    • Type signatures
    • Type classes and type signatures
    • Oh pretty boy, can’t you Show me nothing but surrender?
    • Sum types
    • Phantom types and type aliases
    • Implementing Show
    • Adding type annotations to values
    • Modules and imports
    • A module definition
    • import variants (reference)
    • Import style
    • Total and partial functions
    • Pipelines
    • Records
    • Result is Either
    • What now?
  • 31. Finer-grained access to the outside world
    • Two random numbers at once
    • Adding functions to effects
    • Composing effects
    • What now?
• VII A Child’s Garden of Type Classes
• VIII Idris and Dependent Types
• Appendices
  • Glossary
  • A quick but incomplete Elm reference
    • Declaring a module
    • Importing modules
    • Types with literal syntax
    • Types
    • Records
    • Type annotations
    • Pattern matching
    • Other control structures
  • Differences between Elm and Purescript
    • Your favorite types
    • Type annotations
    • Importing modules
    • The repl
    • Records
  • Which type class do I want?
  • How can I make my type less creepy?
  • The singular truth about functions
    • Single-argument functions
    • How point-free style works
  • Functions all the way down
    • Thunks
    • Boolean values as functions
    • This way lies madness
  • For fun: William James’s story of the squirrel
• Notes