舉報(bào) 
會(huì)員
Learn Scala Programming
Slava Schmidt 著
更新時(shí)間：2021-06-10 19:36:39
開會(huì)員，本書免費(fèi)讀 >
ThesecondversionofScalahasundergonemultiplechangestosupportfeaturesandlibraryimplementations.Scala2.13,withitsmainfocusonmodularizingthestandardlibraryandsimplifyingcollections,bringswithitahostofupdates.LearnScalaProgrammingaddressesbothtechnicalandarchitecturalchangestotheredesignedstandardlibraryandcollections,alongwithcoveringin-depthtypesystemsandfirst-levelsupportforfunctions.YouwilldiscoverhowtoleverageimplicitsasaprimarymechanismforbuildingtypeclassesandlookatdifferentwaystotestScalacode.Youwillalsolearnaboutabstractbuildingblocksusedinfunctionalprogramming,givingyousufficientunderstandingtopickanduseanyexistingfunctionalprogramminglibraryoutthere.Intheconcludingchapters,youwillexplorereactiveprogrammingbycoveringtheAkkaframeworkandreactivestreams.Bytheendofthisbook,youwillhavebuiltmicroservicesandlearnedtoimplementthemwiththeScalaandLagomframework.
最新章節(jié)
- Leave a review - let other readers know what you think
- Other Books You May Enjoy
- Chapter 15
- Chapter 14
- Chapter 13
- Chapter 12
品牌：中圖公司
上架時(shí)間：2021-06-10 18:27:01
出版社：Packt Publishing
本書數(shù)字版權(quán)由中圖公司提供，并由其授權(quán)上海閱文信息技術(shù)有限公司制作發(fā)行
- Leave a review - let other readers know what you think 更新時(shí)間：2021-06-10 19:36:39
- Other Books You May Enjoy
- Chapter 15
- Chapter 14
- Chapter 13
- Chapter 12
- Chapter 11
- Chapter 10
- Chapter 9
- Chapter 8
- Chapter 7
- Chapter 6
- Chapter 5
- Chapter 4
- Chapter 3
- Chapter 2
- Chapter 1
- Assessments
- Using REPL
- Using the SBT console
- Working with the source code
- Getting the code
- Working with the code
- Installing SBT
- Installing Java Virtual Machine (JVM)
- Installing software
- Preparing the Environment and Running Code Samples
- Further reading
- Questions
- Summary
- Testing
- Running the application
- Service API from the client side
- Message Broker API
- Persistence API
- Service API
- Lagom's APIs
- Project setup
- The bakery project
- Project overview and setup
- Why Lagom?
- Technical requirements
- Project 2 - Building Microservices with Lagom
- Further reading
- Questions
- Summary
- Running the application
- Testing
- Bringing it all together
- Akka-HTTP
- The persistent actor
- Domain models
- Configuring Akka Persistence
- Event-Sourcing and CQRS
- Project structure
- Building microservices with Akka-HTTP and Akka Persistence
- Running the application
- Testing
- Bringing it all together
- http4s – streaming HTTP
- Doobie – functional database access
- Configuration with PureConfig
- Database migrations
- FS2 – functional streams
- Project structure
- Building a microservice with http4s and doobie
- Essentials of microservices
- Technical requirements
- Project 1 - Building Microservices with Scala
- Further reading
- Questions
- Summary
- Running the application
- Streams TestKit
- Akka TestKit
- Testing
- Handling failure
- Materialization
- Logging
- Graphs
- Flows
- Sources and sinks
- Basics of Akka Streams
- Structure of the example
- Essential concepts
- Setup and dependency
- Akka Streams
- Reactive Streams and backpressure
- Introduction to Akka Streams
- Technical requirements
- Basics of Akka Streams
- Summary
- Running the application
- Asynchronous testing
- Synchronous testing
- Dependencies and setup
- Testing
- Cluster
- Combining behaviors
- Stashing
- Timers
- Watching an actor
- Supervision
- Life cycle of an actor
- Akka Typed – beyond the basics
- Discovering an actor
- Stopping an actor
- Creating an actor
- Akka Typed basics
- First example
- Example actor system
- The typed approach and the differences between Akka untyped
- Introduction
- Technical requirements
- Building Reactive Applications with Akka Typed
- Further reading
- Questions
- Summary
- Running the application
- Testing actors
- Actor supervision
- The actor path
- Akka remoting
- Akka FSM
- Advanced topics
- Changing an actor's behavior using context
- The ask pattern
- Terminating actors
- Dispatchers
- The life cycle of an actor
- Defining actors
- Akka basics
- Introduction to the actor model
- Technical requirements
- An Introduction to the Akka and Actor Models
- Further reading
- Questions
- Summary
- Free monads
- Monad transformers stacks
- Monad transformers
- Combining monads
- Technical requirements
- A Look at Monad Transformers and Free Monad
- Further reading
- Questions
- Summary
- Writer monad
- Reader monad
- State monad
- Id Monad
- Introduction to monads
- Technical requirements
- Familiarizing Yourself with Basic Monads
- Further reading
- Questions
- Summary
- Traversable
- Applicative
- Functor
- Technical requirements
- Dealing with Effects
- Further reading
- Questions
- Summary
- Group
- Foldable
- Monoid
- Semigroup
- Introduction to abstract algebraic structures
- Technical requirements
- Understanding Algebraic Structures
- Questions
- Summary
- Future as an effect
- Reading values from a Future
- Creating a Future
- Future
- Try as an effect
- Reading values from Try
- Creating a Try
- Try
- Either as an Effect
- Reading values from Either
- Creating Either
- Either
- Option as an effect
- Reading from an Option
- Creating an Option
- Option
- Introduction to effects
- Technical requirements
- Exploring Built-In Effects
- Questions
- Summary
- Shrinkers
- Combining generators
- Existing generators
- Generators
- Combining properties
- Checking property
- Defining a property
- Test Oracle
- Symmetry
- Induction
- Idempotence
- Invariants
- Identity
- Associativity
- Commutativity
- Types of properties
- Properties
- ScalaCheck
- From unit tests to properties
- Introduction to property-based testing
- Technical requirements
- Property-Based Testing in Scala
- Further reading
- Questions
- Summary
- Static overloading rules
- Implicit scope
- Lexical scope
- Implicit scope resolution
- Type class variance
- Type class recursive resolution
- Type classes
- Type classes
- Context bounds
- View bounds
- View and context bounds
- Implicit classes
- Implicit parameters
- Implicit conversions
- Types of implicits
- Technical requirements
- Getting to Know Implicits and Type Classes
- Further reading
- Questions
- Summary
- Extending functions
- Function object
- Partial functions
- Functions are traits
- Object-oriented aspects of functions
- Trampolining
- Tail recursion
- Recursion
- Recursion and trampolining
- Higher-order functions
- Polymorphic functions
- Polymorphism and higher order functions
- Currying
- Function literals
- Partial application and functions
- Closures
- Local functions
- Function as a method
- Ways to define a function
- Technical requirements
- Deep Dive into Functions
- Further reading
- Questions
- Summary
- Self-recursive types
- Phantom types
- Using types to define domain constraints
- Type lambdas
- Higher kinded types
- Existential types
- Variance
- Infix types
- Generalized type constraints
- Type members
- Type parameters
- Types – all the way down
- Path-dependent types
- Type inference
- Scala's types hierarchy and special types
- Type constraints
- Compound (intersection) types
- Literal types
- Ways to create a type
- Understanding types
- Technical requirements
- Understanding Types in Scala
- Further reading
- Questions
- Summary
- Scala Collection Contrib library
- Buffers
- LinearSeq
- IndexedSeq
- Seq
- SeqMap
- MultiMap
- HashMap
- SortedMap
- Map
- Set
- View
- IterableFactory
- WithFilter
- IterableOps
- IterableOnceOps
- The Scala 2.13 Collection Library
- Automatic Resource Management
- Added methods for chaining operations
- Products can report the names of their element
- Optional parsing for string literals
- New features of Scala 2.13
- Introduction to Scala 2.13
- Technical requirements
- An Introduction to Scala 2.13
- Reviews
- Get in touch
- Conventions used
- Download the color images
- Download the example code files
- To get the most out of this book
- What this book covers
- Who this book is for
- Preface
- Packt is searching for authors like you
- About the reviewers
- About the author
- Contributors
- Packt.com
- Why subscribe?
- Packt Upsell
- Dedication
- Title Page
- coverpage
- coverpage
- Title Page
- Dedication
- Packt Upsell
- Why subscribe?
- Packt.com
- Contributors
- About the author
- About the reviewers
- 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
- Download the color images
- Conventions used
- Get in touch
- Reviews
- An Introduction to Scala 2.13
- Technical requirements
- Introduction to Scala 2.13
- New features of Scala 2.13
- Optional parsing for string literals
- Products can report the names of their element
- Added methods for chaining operations
- Automatic Resource Management
- The Scala 2.13 Collection Library
- IterableOnceOps
- IterableOps
- WithFilter
- IterableFactory
- View
- Set
- Map
- SortedMap
- HashMap
- MultiMap
- SeqMap
- Seq
- IndexedSeq
- LinearSeq
- Buffers
- Scala Collection Contrib library
- Summary
- Questions
- Further reading
- Understanding Types in Scala
- Technical requirements
- Understanding types
- Ways to create a type
- Literal types
- Compound (intersection) types
- Type constraints
- Scala's types hierarchy and special types
- Type inference
- Path-dependent types
- Types – all the way down
- Type parameters
- Type members
- Generalized type constraints
- Infix types
- Variance
- Existential types
- Higher kinded types
- Type lambdas
- Using types to define domain constraints
- Phantom types
- Self-recursive types
- Summary
- Questions
- Further reading
- Deep Dive into Functions
- Technical requirements
- Ways to define a function
- Function as a method
- Local functions
- Closures
- Partial application and functions
- Function literals
- Currying
- Polymorphism and higher order functions
- Polymorphic functions
- Higher-order functions
- Recursion and trampolining
- Recursion
- Tail recursion
- Trampolining
- Object-oriented aspects of functions
- Functions are traits
- Partial functions
- Function object
- Extending functions
- Summary
- Questions
- Further reading
- Getting to Know Implicits and Type Classes
- Technical requirements
- Types of implicits
- Implicit conversions
- Implicit parameters
- Implicit classes
- View and context bounds
- View bounds
- Context bounds
- Type classes
- Type classes
- Type class recursive resolution
- Type class variance
- Implicit scope resolution
- Lexical scope
- Implicit scope
- Static overloading rules
- Summary
- Questions
- Further reading
- Property-Based Testing in Scala
- Technical requirements
- Introduction to property-based testing
- From unit tests to properties
- ScalaCheck
- Properties
- Types of properties
- Commutativity
- Associativity
- Identity
- Invariants
- Idempotence
- Induction
- Symmetry
- Test Oracle
- Defining a property
- Checking property
- Combining properties
- Generators
- Existing generators
- Combining generators
- Shrinkers
- Summary
- Questions
- Exploring Built-In Effects
- Technical requirements
- Introduction to effects
- Option
- Creating an Option
- Reading from an Option
- Option as an effect
- Either
- Creating Either
- Reading values from Either
- Either as an Effect
- Try
- Creating a Try
- Reading values from Try
- Try as an effect
- Future
- Creating a Future
- Reading values from a Future
- Future as an effect
- Summary
- Questions
- Understanding Algebraic Structures
- Technical requirements
- Introduction to abstract algebraic structures
- Semigroup
- Monoid
- Foldable
- Group
- Summary
- Questions
- Further reading
- Dealing with Effects
- Technical requirements
- Functor
- Applicative
- Traversable
- Summary
- Questions
- Further reading
- Familiarizing Yourself with Basic Monads
- Technical requirements
- Introduction to monads
- Id Monad
- State monad
- Reader monad
- Writer monad
- Summary
- Questions
- Further reading
- A Look at Monad Transformers and Free Monad
- Technical requirements
- Combining monads
- Monad transformers
- Monad transformers stacks
- Free monads
- Summary
- Questions
- Further reading
- An Introduction to the Akka and Actor Models
- Technical requirements
- Introduction to the actor model
- Akka basics
- Defining actors
- The life cycle of an actor
- Dispatchers
- Terminating actors
- The ask pattern
- Changing an actor's behavior using context
- Advanced topics
- Akka FSM
- Akka remoting
- The actor path
- Actor supervision
- Testing actors
- Running the application
- Summary
- Questions
- Further reading
- Building Reactive Applications with Akka Typed
- Technical requirements
- Introduction
- The typed approach and the differences between Akka untyped
- Example actor system
- First example
- Akka Typed basics
- Creating an actor
- Stopping an actor
- Discovering an actor
- Akka Typed – beyond the basics
- Life cycle of an actor
- Supervision
- Watching an actor
- Timers
- Stashing
- Combining behaviors
- Cluster
- Testing
- Dependencies and setup
- Synchronous testing
- Asynchronous testing
- Running the application
- Summary
- Basics of Akka Streams
- Technical requirements
- Introduction to Akka Streams
- Reactive Streams and backpressure
- Akka Streams
- Setup and dependency
- Essential concepts
- Structure of the example
- Basics of Akka Streams
- Sources and sinks
- Flows
- Graphs
- Logging
- Materialization
- Handling failure
- Testing
- Akka TestKit
- Streams TestKit
- Running the application
- Summary
- Questions
- Further reading
- Project 1 - Building Microservices with Scala
- Technical requirements
- Essentials of microservices
- Building a microservice with http4s and doobie
- Project structure
- FS2 – functional streams
- Database migrations
- Configuration with PureConfig
- Doobie – functional database access
- http4s – streaming HTTP
- Bringing it all together
- Testing
- Running the application
- Building microservices with Akka-HTTP and Akka Persistence
- Project structure
- Event-Sourcing and CQRS
- Configuring Akka Persistence
- Domain models
- The persistent actor
- Akka-HTTP
- Bringing it all together
- Testing
- Running the application
- Summary
- Questions
- Further reading
- Project 2 - Building Microservices with Lagom
- Technical requirements
- Why Lagom?
- Project overview and setup
- The bakery project
- Project setup
- Lagom's APIs
- Service API
- Persistence API
- Message Broker API
- Service API from the client side
- Running the application
- Testing
- Summary
- Questions
- Further reading
- Preparing the Environment and Running Code Samples
- Installing software
- Installing Java Virtual Machine (JVM)
- Installing SBT
- Working with the code
- Getting the code
- Working with the source code
- Using the SBT console
- Using REPL
- Assessments
- Chapter 1
- Chapter 2
- Chapter 3
- Chapter 4
- Chapter 5
- Chapter 6
- Chapter 7
- Chapter 8
- Chapter 9
- Chapter 10
- Chapter 11
- Chapter 12
- Chapter 13
- Chapter 14
- Chapter 15
- Other Books You May Enjoy
- Leave a review - let other readers know what you think 更新時(shí)間：2021-06-10 19:36:39
