Learning Scala Programming
Vikash Sharma更新时间：2021-06-30 19:08:34
最新章节：Leave a review - let other readers know what you thinkcoverpage
Title Page
Packt Upsell
Why subscribe?
PacktPub.com
Contributors
About the author
About the reviewer
Packt is searching for authors like you
Preface
Who this book is for
What this book covers
To get the most out of this book
Download the example code files
Conventions used
Get in touch
Reviews
Getting Started with Scala Programming
Introduction to Scala
A programming paradigm
Object-oriented versus functional paradigms
Scala is multi-paradigm
Scala advantages
Runs on JVM
Super smart syntax
Best of both worlds
Type is the core
Concurrency made easy
Asynchronous code
Asynchronous versus parallel versus concurrent programming
Now available for the frontend
Smart IDEs
Extensive language
Online support
Working with Scala
Java installation
SBT installation
Scala REPL
Scala IDEs
Running our first program
Summary
Building Blocks of Scala
What is underneath a Scala program?
Vals and vars
Literals
Integer literals
Floating point literals
Boolean literals
Character literals
String literals
Symbol literals
Tuple literals
Function literals
Data types
Scala's class hierarchy
Any
AnyVal and AnyRef
AnyRef
AnyVal
Unit
Boolean
Null and Nothing
Type inference
Operators in Scala
Arithmetic operators
Relational operators
Logical operators
Bitwise operators
Operator precedence
Wrapper classes
String Interpolators
The s interpolator
f Interpolator
The raw interpolator
Summary
Shaping our Scala Program
Looping
The for loop
The while Loop
The do while loop
The for expressions
The for yield expressions
Recursion
Why recursion over iteration?
Limitations of recursion
The ideal way to write recursive functions
Conditional statements
The if else conditional expression
Pattern matching
Summary
Giving Meaning to Programs with Functions
Function syntax
Nesting of functions
Calling a function
Passing a variable number of arguments
Calling a function with a default parameter value
Calling a function while passing named arguments
Function literals
Evaluation strategies
Call by name
Call by value
Partial functions
Summary
Getting Familiar with Scala Collections
Motivation
Immutable and mutable collections
Differences between the root and immutable collections
Hierarchy of collections in Scala
Traversable
Iterable
Seq
Sequences
Map
Set
Commonly used collections in Scala
List
Map
SortedSet
Streams
Vector
Immutable stack
Immutable queue
Ranges
ArrayBuffer
ListBuffer
StringBuilder
Array
Rich operations performed on collections
Parallel collections in Scala
ParArray
ParVector
Converting a Java collection into a Scala collection
Choosing a collection
Collection performance
Summary
Object-Oriented Scala Basics
Classes
Abstract classes
Abstract classes and traits
The final classes
Objects as singletons
Companion objects
Case classes
Summary
Next Steps in Object-Oriented Scala
Composition and inheritance
Class inheritance
Extending classes
Subtyping versus subclassing
Overriding data and behavior
Restricting inheritance – final keyword
Dynamic binding in function invocation
Misusing inheritance
Default and parameterized constructors
Traits
Traits as mix-ins
Traits as composable mix-ins
Traits as stackable modifications
Linearization
Packaging and importing
Package statements
Multiple package statements in a file
Nested package statements
Chaining package statements
Importing packages
Visibility rules
Sealed traits
Summary
More on Functions
Function literals
Methods
Functions versus methods
Methods or functions?
What are closures?
Higher-order functions
Currying
Converting a function with multiple parameters to curried form
Partially applied functions
Summary
Using Powerful Functional Constructs
For expressions
Pattern matching
Different ways we can pattern match
Matching a variable
Matching a constant
Matching a constructor
Option type
Lazy declaration
Tail call optimization
Combinators
Type parameterization
Summary
Advanced Functional Programming
Why so serious about types?
Here comes type parameterization
Another way around - generic classes and traits
Type parameter names
Container types
Type erasure
Variance under inheritance
When to use what type of variance relation
Abstract types
Type bounds
Abstract versus parameterized types
Type-classes
Summary
Working with Implicits and Exceptions
Exception handling – the old way
Using the Option way
Either left or right
Implicits - what and why
Implicit parameters
The implicitly method
Implicit conversions
Looking for implicits
Type-classes ahead!
Summary
Introduction to Akka
Why do we care about Akka?
What's up with the Actor Model?
Understanding the Actor system
Props
Actor references and paths
Selecting existing actorRefs via actorSelection
How the Actor life cycle works
Hello world in Akka
Setting up the environment
Writing our first Actor
The tell versus ask versus forward method
Stopping Actors
The preStart and postStop hooks
Actor communication via messages and its semantics
Supervising fault in our actors
OneForOne versus AllForOne strategy
Default supervision strategy
Applying the supervision strategy
Testing actors
Summary
Concurrent Programming in Scala
Concurrent programming
Building blocks of concurrency
Understanding processes and threads
Locks and synchronization
Executor and ExecutionContext
Asynchronous programming
Working with Futures
What if Future computations go wrong?
Why not compose two or more Futures?
Working with Promises
Parallel collections
Summary
Programming with Reactive Extensions
Reactive programming
Reactive extensions
React to RxScala
Creating Observables
Summary
Testing in Scala
The why and what of TDD
The process of TDD
Step 1 - write a test that will fail
Step 2 - write code to pass the failing test
Step 3 - refactor the code to improve the quality
Step 4 - repeat steps 1 to 3
Scenario
Behavior driven development (BDD)
ScalaTest
Setting up for testing
Testing in style using ScalaTest
Assertions
Matchers
ScalaMock – a native library to mock objects
Summary
Other Books You May Enjoy
Leave a review - let other readers know what you think
更新时间：2021-06-30 19:08:34