Functional Programming in Scala video edition

Video description

In Video Editions the narrator reads the book while the content, figures, code listings, diagrams, and text appear on the screen. Like an audiobook that you can also watch as a video.

"Leads to deep insights into the nature of computation."
From the Foreword by Martin Odersky, Creator of Scala

Functional Programming in Scala is a serious tutorial for programmers looking to learn FP and apply it to the everyday business of coding. This Video Editions book guides readers from basic techniques to advanced topics in a logical, concise, and clear progression. In it, you'll find concrete examples that open up the world of functional programming.

Functional programming (FP) is a style of software development emphasizing functions that don't depend on program state. Functional code is easier to test and reuse, simpler to parallelize, and less prone to bugs than other code. Scala is an emerging JVM language that offers strong support for FP. Its familiar syntax and transparent interoperability with Java make Scala a great place to start learning FP.

  • Functional programming concepts
  • The whys and hows of FP
  • How to write multicore programs
  • Checks for understanding
This title assumes no prior experience with functional programming. Some prior exposure to Scala or Java is helpful.

Paul Chiusano and Rúnar Bjarnason are recognized experts in functional programming with Scala and are core contributors to the Scalaz library.

The definitive guide to functional programming for Scala and Java 8 developers!
William E. Wheeler, TekSystems

Shows you the approach and mindset to raise your Scala way beyond 'a better Java'.
Fernando Dobladez, Code54


Table of contents

  1. Chapter 1. What is functional programming?
  2. Chapter 1. A functional solution: removing the side effects
  3. Chapter 1. Exactly what is a (pure) function?
  4. Chapter 1. Referential transparency, purity, and the substitution model
  5. Chapter 2. Getting started with functional programming in Scala
  6. Chapter 2. Running our program
  7. Chapter 2. Higher-order functions: passing functions to functions
  8. Chapter 2. Polymorphic functions: abstracting over types
  9. Chapter 2. Following types to implementations
  10. Chapter 3. Functional data structures
  11. Chapter 3. Pattern matching
  12. Chapter 3. Data sharing in functional data structures
  13. Chapter 3. Recursion over lists and generalizing to higher-order functions
  14. Chapter 3. Trees
  15. Chapter 4. Handling errors without exceptions
  16. Chapter 4. Possible alternatives to exceptions
  17. Chapter 4. The Option data type
  18. Chapter 4. Option composition, lifting, and wrapping exception-oriented APIs
  19. Chapter 4. The Either data type
  20. Chapter 5. Strictness and laziness
  21. Chapter 5. An extended example: lazy lists
  22. Chapter 5. Separating program description from evaluation
  23. Chapter 5. Infinite streams and corecursion
  24. Chapter 6. Purely functional state
  25. Chapter 6. Making stateful APIs pure
  26. Chapter 6. A better API for state actions
  27. Chapter 6. A general state action data type
  28. Chapter 7. Purely functional parallelism
  29. Chapter 7. A data type for parallel computations
  30. Chapter 7. Combining parallel computations
  31. Chapter 7. Explicit forking
  32. Chapter 7. Picking a representation
  33. Chapter 7. Refining the API
  34. Chapter 7. The algebra of an API
  35. Chapter 7. The law of forking
  36. Chapter 7. A fully non-blocking Par implementation using actors
  37. Chapter 7. Refining combinators to their most general form
  38. Chapter 8. Property-based testing
  39. Chapter 8. Choosing data types and functions
  40. Chapter 8. The meaning and API of generators
  41. Chapter 8. Test case minimization
  42. Chapter 8. Using the library and improving its usability
  43. Chapter 8. Testing higher-order functions and future directions
  44. Chapter 9. Parser combinators
  45. Chapter 9. Designing an algebra, first
  46. Chapter 9. A possible algebra
  47. Chapter 9. Handling context sensitivity
  48. Chapter 9. Error reporting
  49. Chapter 9. Controlling branching and backtracking
  50. Chapter 9. Implementing the algebra
  51. Chapter 9. Failover and backtracking
  52. Chapter 10. Monoids
  53. Chapter 10. Folding lists with monoids
  54. Chapter 10. Example: Parallel parsing
  55. Chapter 10. Foldable data structures
  56. Chapter 11. Monads
  57. Chapter 11. Monads: generalizing the flatMap and unit functions
  58. Chapter 11. Monadic combinators
  59. Chapter 11. Just what is a monad?
  60. Chapter 11. The State monad and partial type application
  61. Chapter 12. Applicative and traversable functors
  62. Chapter 12. The difference between monads and applicative functors
  63. Chapter 12. The advantages of applicative functors
  64. Chapter 12. The applicative laws
  65. Chapter 12. Traversable functors
  66. Chapter 12. Uses of Traverse
  67. Chapter 12. Traversal fusion
  68. Chapter 13. External effects and I/O
  69. Chapter 13. A simple IO type
  70. Chapter 13. Benefits and drawbacks of the simple IO type
  71. Chapter 13. Avoiding the StackOverflowError
  72. Chapter 13. A more nuanced IO type
  73. Chapter 13. Non-blocking and asynchronous I/O
  74. Chapter 13. Why the IO type is insufficient for streaming I/O
  75. Chapter 14. Local effects and mutable state
  76. Chapter 14. A data type to enforce scoping of side effects
  77. Chapter 14. Running mutable state actions
  78. Chapter 14. Purity is contextual
  79. Chapter 15. Stream processing and incremental I/O
  80. Chapter 15. Simple stream transducers
  81. Chapter 15. Composing and appending processes
  82. Chapter 15. An extensible process type
  83. Chapter 15. Ensuring resource safety
  84. Chapter 15. Multiple input streams
  85. Chapter 15. Applications

Product information

  • Title: Functional Programming in Scala video edition
  • Author(s): Paul Chiusano, Runar Bjarnason
  • Release date: September 2014
  • Publisher(s): Manning Publications
  • ISBN: None