Scala Functional Programming Patterns

Table of contents

1. Scala Functional Programming Patterns
   1. Table of Contents
   2. Scala Functional Programming Patterns
   3. Credits
   4. About the Author
   5. Aknowledgement
   6. About the Reviewers
   7. www.PacktPub.com
      1. Support files, eBooks, discount offers, and more
         1. Why subscribe?
         2. Free access for Packt account holders
   8. Preface
      1. What this book covers
      2. What you need for this book
      3. Who this book is for
      4. Conventions
      5. Reader feedback
      6. Customer support
         1. Downloading the example code
         2. Errata
         3. Piracy
         4. Questions
   9. 1. Grokking the Functional Way
      1. Abstractions
      2. Concise expression
      3. Functions
      4. Immutable
      5. Referential transparency
      6. The problem – grouping continuous integers
         1. Java code
         2. Going scalaish
         3. Thinking recursively...
         4. Reusability – the commonality/variability analysis
         5. The one-liner shockers
      7. Scala idioms
      8. Patterns and those aha! moments
         1. The command design pattern
         2. The strategy design pattern
            1. Passing algorithms around
      9. Summary
   10. 2. Singletons, Factories, and Builders
       1. Singletons – being one and only one
       2. Null Objects – singletons in another garb
          1. Null Objects – the Scala way
          2. Options are container
       3. Scala singletons
          1. The apply() factory method
          2. The factory method pattern
          3. The Scala version
       4. Builders
          1. Ease of object creation
          2. Scala shines again
       5. Summary
   11. 3. Recursion and Chasing your Own Tail
       1. Recursive structures
       2. Pattern matching
          1. Deconstruction with case statements
          2. Stack overflows
       3. Tail recursion to the rescue
       4. Getting the nth element of a list
       5. An expression parser
       6. Persistent data structures
       7. Two forms of recursion
       8. Summary
   12. 4. Lazy Sequences – Being Lazy, Being Good
       1. Illusion and reality – the proxy pattern
       2. Hibernate's lazy loading
       3. Lazy val – calling by need
       4. Infinite sequences – Scala streams
       5. Recursive streams
       6. Memoization and the flyweight pattern
       7. Call by name
       8. Streams are collections
       9. Sieve of Eratosthenes
       10. A view to a collection
       11. Summary
   13. 5. Taming Multiple Inheritance with Traits
       1. The iterator design pattern
       2. Interfaces as types
       3. The dreaded diamond
       4. Traits – Scala's rich interfaces
       5. Mix-ins – rich interfaces
       6. Frills and thrills – the decorator pattern
       7. Scala's easy and breezy decorations – stackable modifications
       8. Dependencies injection pattern
       9. A taste of the cake pattern
       10. Sealed traits
       11. Defeating the dreaded diamond
       12. Summary
   14. 6. Currying Favors with Your Code
       1. Functions as first-class values
       2. Roping in a scope
       3. Local functions – hiding and biding their time
       4. The underscore – Scala's Swiss army knife
       5. A taste of the curry
          1. Type inference
          2. Of implicits and explicits
          3. Stylish blocks
       6. The loan pattern
       7. Serving the curry
       8. Frills and thrills – decorators again
       9. Wrapping it up
       10. Summary
   15. 7. Of Visitors and Chains of Responsibilities
       1. A tale of two hierarchies
       2. The Visitor pattern
          1. Many hues of pattern matching
             1. De-structuring
             2. Typed patterns
             3. Pattern guards
             4. Tuple explosion
       3. Partial functions
          1. Visitor pattern – the Scala way
          2. Lifting it up
       4. The chain of responsibility
          1. Scalaish Chain Of Responsibilities
          2. Match and mismatch – the collect idiom
       5. Summary
   16. 8. Traversals – Mapping/Filtering/Folding/Reducing
       1. Iterating the Scala way
       2. A validation problem
          1. Setting the stage
             1. First cut–using arrays
             2. Second cut–using a map
             3. Third cut–using a for expression
             4. Fourth cut–using foldLeft
             5. Fifth cut–using andThen
             6. Sixth cut–using compose
       3. Foreach–sugary sweetener
          1. One generator
          2. A generator and a filter
          3. Two generators
       4. Monads
       5. Reduce
       6. Summary
   17. 9. Higher Order Functions
       1. The strategy design pattern
       2. A strategy in Scala land
       3. Functors
          1. Maps
       4. Monads
       5. FlatMap
       6. Monoids
       7. An inverted index
       8. Pipes and filters
       9. Pipes and filters – the Scala version
       10. It is a Monoid
       11. Lazy collections
       12. Summary
   18. 10. Actors and Message Passing
       1. The recursive grep
       2. The producer/consumer pattern
       3. Threads – masters and slaves
       4. Events
       5. Immutability is golden
       6. Akka actors take the stage
       7. Summary
   19. 11. It's a Paradigm Shift
       1. Verbosity
       2. Sorting it out!
          1. Sorted
          2. SortBy
          3. SortWith
          4. Scalaish Schwartzian transform
       3. Functional error handling
          1. Pattern matching
       4. Threads and futures
          1. Scala's Futures
       5. Parser combinators
       6. Summary
   20. Index