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