MARC details
| 000 -LEADER |
|---|
| fixed length control field |
16637nam a22002177a 4500 |
| 003 - CONTROL NUMBER IDENTIFIER |
|---|
| control field |
CUTN |
| 005 - DATE AND TIME OF LATEST TRANSACTION |
|---|
| control field |
20250820154623.0 |
| 008 - FIXED-LENGTH DATA ELEMENTS--GENERAL INFORMATION |
|---|
| fixed length control field |
250820b |||||||| |||| 00| 0 eng d |
| 020 ## - INTERNATIONAL STANDARD BOOK NUMBER |
|---|
| International Standard Book Number |
9789391043452 |
| 041 ## - LANGUAGE CODE |
|---|
| Language |
English |
| 082 ## - DEWEY DECIMAL CLASSIFICATION NUMBER |
|---|
| Edition number |
23 |
| Classification number |
005.133 |
| Item number |
WAM |
| 100 ## - MAIN ENTRY--PERSONAL NAME |
|---|
| Personal name |
Wampler, Dean |
| 245 ## - TITLE STATEMENT |
|---|
| Title |
Programming Scala : |
| Remainder of title |
Third Edition Scalability = Functional Programming + Objects/ |
| 260 ## - PUBLICATION, DISTRIBUTION, ETC. (IMPRINT) |
|---|
| Place of publication, distribution, etc |
New Delhi : |
| Name of publisher, distributor, etc |
Shroff publishers, |
| Date of publication, distribution, etc |
2021. |
| 300 ## - PHYSICAL DESCRIPTION |
|---|
| Extent |
xxxi, 520p. : |
| 500 ## - GENERAL NOTE |
|---|
| General note |
Home/Books/Programming Scala, Third Edition<br/><br/><br/>Programming Scala, Third Edition<br/>Scalability = Functional Programming + Objects<br/>Publisher: Shroff/O'Reilly<br/>ISBN:<br/>9789391043452<br/>You Pay: ₹2,05000<br/>Leadtime to ship in days (default): ships in 1-2 days<br/>Ships only in the (Bangladesh, Bhutan, India, Maldives, Nepal, Sri Lanka)<br/>In Stock<br/>Quantity:<br/>1<br/>Minimum quantity for "Programming Scala, Third Edition" is 1.<br/><br/>Add to wish list<br/>Compare<br/>Share<br/><br/><br/>— Different payment methods<br/>— Best price<br/><br/><br/>Description<br/>Features<br/>Table of Contents<br/>Reviews<br/>All Indian Reprints of O'Reilly are printed in Grayscale<br/><br/>Get up to speed on Scala--the JVM, JavaScript, and natively compiled language that offers all the benefits of functional programming, a modern object model, and an advanced type system. Packed with code examples, this comprehensive book shows you how to be productive with the language and ecosystem right away. You'll learn why Scala is ideal for building today's highly scalable, data-centric applications while maximizing developer productivity.<br/><br/>While Java remains popular and Kotlin has become popular, Scala hasn't been sitting still. This third edition covers the new features in Scala 3 with updates throughout the book. Programming Scala is ideal for beginning to advanced developers who want a complete understanding of Scala's design philosophy and features with a thoroughly practical focus.<br/><br/>Program faster with Scala's succinct and flexible syntax<br/>Dive into basic and advanced functional programming techniques<br/>Build killer big data and distributed apps using Scala's functional combinators and tools like Spark and Akka<br/>Create concise solutions to challenging design problems with the sophisticated type system, mixing composition with traits, pattern matching, and more |
| 505 ## - FORMATTED CONTENTS NOTE |
|---|
| Contents |
Table of Contents<br/>Foreword. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xvii<br/>Preface. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xxi<br/>1. Zero to Sixty: Introducing Scala. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1<br/>Why Scala? 1<br/>The Appeal of Scala 2<br/>Why Scala 3? 3<br/>Migrating to Scala 3 3<br/>Installing the Scala Tools You Need 3<br/>Building the Code Examples 4<br/>More Tips 5<br/>Using sbt 5<br/>Running the Scala Command-Line Tools Using sbt 7<br/>A Taste of Scala 9<br/>A Sample Application 20<br/>Recap and What’s Next 29<br/>2. Type Less, Do More. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31<br/>New Scala 3 Syntax—Optional Braces 31<br/>Semicolons 33<br/>Variable Declarations 33<br/>Ranges 35<br/>Partial Functions 36<br/>Method Declarations 39<br/>Method Default and Named Parameters 39<br/>Methods with Multiple Parameter Lists 40<br/>Nesting Method Definitions and Recursion 45<br/>vii<br/>Inferring Type Information 48<br/>Repeated Parameter Lists 49<br/>Language Keywords 51<br/>Literal Values 54<br/>Numeric Literals 54<br/>Boolean Literals 55<br/>Character Literals 56<br/>String Literals 56<br/>Symbol Literals 58<br/>Function Literals 58<br/>Tuples 58<br/>Option, Some, and None: Avoiding Nulls 60<br/>When You Really Can’t Avoid Nulls 61<br/>Sealed Class Hierarchies and Enumerations 62<br/>Organizing Code in Files and Namespaces 63<br/>Importing Types and Their Members 64<br/>Package Imports and Package Objects 65<br/>Parameterized Types Versus Abstract Type Members 66<br/>Recap and What’s Next 69<br/>3. Rounding Out the Basics. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71<br/>Defining Operators 71<br/>Allowed Characters in Identifiers 76<br/>Methods with Empty Parameter Lists 77<br/>Operator Precedence Rules 78<br/>Enumerations and Algebraic Data Types 79<br/>Interpolated Strings 82<br/>Scala Conditional Expressions 83<br/>Conditional and Comparison Operators 85<br/>for Comprehensions 86<br/>for Loops 86<br/>Generators 87<br/>Guards: Filtering Values 87<br/>Yielding New Values 87<br/>Expanded Scope and Value Definitions 88<br/>Scala while Loops 90<br/>Using try, catch, and finally Clauses 90<br/>Call by Name, Call by Value 94<br/>Lazy Values 97<br/>Traits: Interfaces and Mixins in Scala 99<br/>When new Is Optional 102<br/>Recap and What’s Next 103<br/>viii | Table of Contents<br/>4. Pattern Matching. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105<br/>Safer Pattern Matching with Matchable 105<br/>Values, Variables, and Types in Matches 107<br/>Matching on Sequences 111<br/>Pattern Matching on Repeated Parameters 114<br/>Matching on Tuples 114<br/>Parameter Untupling 116<br/>Guards in Case Clauses 117<br/>Matching on Case Classes and Enums 117<br/>Matching on Regular Expressions 120<br/>Matching on Interpolated Strings 121<br/>Sealed Hierarchies and Exhaustive Matches 121<br/>Chaining Match Expressions 122<br/>Pattern Matching Outside Match Expressions 122<br/>Problems in Pattern Bindings 124<br/>Pattern Matching as Filtering in for Comprehensions 125<br/>Pattern Matching and Erasure 126<br/>Extractors 127<br/>unapply Method 127<br/>Alternatives to Option Return Values 129<br/>unapplySeq Method 132<br/>Implementing unapplySeq 134<br/>Recap and What’s Next 135<br/>5. Abstracting Over Context: Type Classes and Extension Methods. . . . . . . . . . . . . . . . . . 137<br/>Four Changes 138<br/>Extension Methods 139<br/>Build Your Own String Interpolator 142<br/>Type Classes 142<br/>Scala 3 Type Classes 143<br/>Alias Givens 150<br/>Scala 2 Type Classes 152<br/>Scala 3 Implicit Conversions 154<br/>Type Class Derivation 158<br/>Givens and Imports 159<br/>Givens Scoping and Pattern Matching 161<br/>Resolution Rules for Givens and Extension Methods 162<br/>The Expression Problem 163<br/>Recap and What’s Next 163<br/>6. Abstracting Over Context: Using Clauses. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165<br/>Using Clauses 165<br/>Table of Contents | ix<br/>Context Bounds 167<br/>Other Context Parameters 171<br/>Context Functions 172<br/>Constraining Allowed Instances 175<br/>Implicit Evidence 178<br/>Working Around Type Erasure with Using Clauses 179<br/>Rules for Using Clauses 180<br/>Improving Error Messages 182<br/>Recap and What’s Next 183<br/>7. Functional Programming in Scala. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185<br/>What Is Functional Programming? 185<br/>Functions in Mathematics 186<br/>Variables That Aren’t 187<br/>Functional Programming in Scala 190<br/>Anonymous Functions, Lambdas, and Closures 190<br/>Purity Inside Versus Outside 193<br/>Recursion 193<br/>Tail Calls and Tail-Call Optimization 194<br/>Partially Applied Functions Versus Partial Functions 195<br/>Currying and Uncurrying Functions 196<br/>Tupled and Untupled Functions 197<br/>Partial Functions Versus Functions Returning Options 198<br/>Functional Data Structures 199<br/>Sequences 200<br/>Maps 202<br/>Sets 203<br/>Traversing, Mapping, Filtering, Folding, and Reducing 204<br/>Traversing 204<br/>Mapping 205<br/>Flat Mapping 206<br/>Filtering 208<br/>Folding and Reducing 210<br/>Left Versus Right Folding 215<br/>Combinators: Software’s Best Component Abstractions 219<br/>What About Making Copies? 222<br/>Recap and What’s Next 224<br/>8. for Comprehensions in Depth. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225<br/>Recap: The Elements of for Comprehensions 225<br/>for Comprehensions: Under the Hood 227<br/>Translation Rules of for Comprehensions 230<br/>x | Table of Contents<br/>Options and Container Types 232<br/>Option as a Container? 232<br/>Either: An Alternative to Option 236<br/>Try: When There Is No Do 239<br/>Validated from the Cats Library 241<br/>Recap and What’s Next 243<br/>9. Object-Oriented Programming in Scala. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245<br/>Class and Object Basics: Review 246<br/>Open Versus Closed Types 247<br/>Classes Open for Extension 250<br/>Overriding Methods? The Template Method Pattern 251<br/>Reference Versus Value Types 252<br/>Opaque Types and Value Classes 253<br/>Opaque Type Aliases 255<br/>Value Classes 258<br/>Supertypes 261<br/>Constructors in Scala 262<br/>Calling Supertype Constructors 263<br/>Export Clauses 263<br/>Good Object-Oriented Design: A Digression 265<br/>Fields in Types 267<br/>The Uniform Access Principle 268<br/>Unary Methods 270<br/>Recap and What’s Next 270<br/>10. Traits. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271<br/>Traits as Mixins 271<br/>Stackable Traits 275<br/>Union and Intersection Types 279<br/>Transparent Traits 281<br/>Using Commas Instead of with 282<br/>Trait Parameters 282<br/>Should That Type Be a Class or Trait? 284<br/>Recap and What’s Next 284<br/>11. Variance Behavior and Equality. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285<br/>Parameterized Types: Variance Under Inheritance 285<br/>Functions Under the Hood 286<br/>Variance of Mutable Types 290<br/>Improper Variance of Java Arrays 292<br/>Equality of Instances 292<br/>Table of Contents | xi<br/>The equals Method 293<br/>The == and != Methods 293<br/>The eq and ne Methods 294<br/>Array Equality and the sameElements Method 294<br/>Equality and Inheritance 295<br/>Multiversal Equality 296<br/>Case Objects and hashCode 299<br/>Recap and What’s Next 300<br/>12. Instance Initialization and Method Resolution. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301<br/>Linearization of a Type Hierarchy 301<br/>Initializing Abstract Fields 305<br/>Overriding Concrete Fields 307<br/>Abstract Type Members and Concrete Type Aliases 308<br/>Recap and What’s Next 309<br/>13. The Scala Type Hierarchy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311<br/>Much Ado About Nothing (and Null) 312<br/>The scala Package 315<br/>Products, Case Classes, Tuples, and Functions 316<br/>Tuples and the Tuple Trait 317<br/>The Predef Object 319<br/>Implicit Conversions 319<br/>Type Definitions 321<br/>Condition Checking Methods 321<br/>Input and Output Methods 322<br/>Miscellaneous Methods 323<br/>Recap and What’s Next 323<br/>14. The Scala Collections Library. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325<br/>Different Groups of Collections 326<br/>Abstractions with Multiple Implementations 326<br/>The scala.collection.immutable Package 327<br/>The scala.collection.mutable Package 329<br/>The scala.collection Package 331<br/>The scala.collection.concurrent Package 333<br/>The scala.collection.convert Package 333<br/>The scala.collection.generic Package 333<br/>Construction of Instances 333<br/>The Iterable Abstraction 335<br/>Polymorphic Methods 336<br/>Equality for Collections 337<br/>xii | Table of Contents<br/>Nonstrict Collections: Views 338<br/>Recap and What’s Next 339<br/>15. Visibility Rules. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341<br/>Public Visibility: The Default 342<br/>Visibility Keywords 342<br/>Protected Visibility 343<br/>Private Visibility 343<br/>Scoped Private and Protected Visibility 343<br/>Recap and What’s Next 345<br/>16. Scala’s Type System, Part I. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347<br/>Parameterized Types 347<br/>Abstract Type Members and Concrete Type Aliases 348<br/>Comparing Abstract Type Members Versus Parameterized Types 348<br/>Type Bounds 349<br/>Upper Type Bounds 349<br/>Lower Type Bounds 350<br/>Context Bounds 352<br/>View Bounds 352<br/>Intersection and Union Types 353<br/>Intersection Types 353<br/>Union Types 356<br/>Phantom Types 359<br/>Structural Types 362<br/>Refined Types 367<br/>Existential Types (Obsolete) 367<br/>Recap and What’s Next 368<br/>17. Scala’s Type System, Part II. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369<br/>Match Types 369<br/>Dependently Typed Methods 371<br/>Dependent Method and Dependent Function Types 373<br/>Dependent Typing 374<br/>Path-Dependent Types 380<br/>Using this 380<br/>Using super 381<br/>Stable Paths 381<br/>Self-Type Declarations 382<br/>Type Projections 385<br/>More on Singleton Types 386<br/>Self-Recursive Types: F-Bounded Polymorphism 387<br/>Table of Contents | xiii<br/>Higher-Kinded Types 388<br/>Type Lambdas 391<br/>Polymorphic Functions 393<br/>Type Wildcard Versus Placeholder 394<br/>Recap and What’s Next 395<br/>18. Advanced Functional Programming. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 397<br/>Algebraic Data Types 397<br/>Sum Types Versus Product Types 397<br/>Properties of Algebraic Data Types 399<br/>Final Thoughts on Algebraic Data Types 400<br/>Category Theory 400<br/>What Is a Category? 401<br/>Functor 402<br/>The Monad Endofunctor 404<br/>The Semigroup and Monoid Categories 408<br/>Recap and What’s Next 409<br/>19. Tools for Concurrency. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411<br/>The scala.sys.process Package 411<br/>Futures 413<br/>Robust, Scalable Concurrency with Actors 416<br/>Akka: Actors for Scala 417<br/>Actors: Final Thoughts 425<br/>Stream Processing 426<br/>Recap and What’s Next 427<br/>20. Dynamic Invocation in Scala. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 429<br/>Structural Types Revisited 429<br/>A Motivating Example: ActiveRecord in Ruby on Rails 432<br/>Dynamic Invocation with the Dynamic Trait 433<br/>DSL Considerations 437<br/>Recap and What’s Next 437<br/>21. Domain-Specific Languages in Scala. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 439<br/>Internal DSLs 440<br/>External DSLs with Parser Combinators 446<br/>About Parser Combinators 447<br/>A Payroll External DSL 447<br/>Internal Versus External DSLs: Final Thoughts 449<br/>Recap and What’s Next 450<br/>xiv | Table of Contents<br/>22. Scala Tools and Libraries. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 451<br/>Scala 3 Versions 451<br/>Command-Line Interface Tools 452<br/>Coursier 453<br/>Managing Java JDKs with Coursier 453<br/>The scalac Command-Line Tool 454<br/>The scala Command-Line Tool 455<br/>The scaladoc Command-Line Tool 456<br/>Other Scala Command-Line Tools 456<br/>Build Tools 457<br/>Integration with IDEs and Text Editors 457<br/>Using Notebook Environments with Scala 457<br/>Testing Tools 458<br/>Scala for Big Data: Apache Spark 459<br/>Typelevel Libraries 461<br/>Li Haoyi Libraries 462<br/>Java and Scala Interoperability 462<br/>Using Java Identifiers in Scala Code 462<br/>Scala Identifiers in Java Code 463<br/>Java Generics and Scala Parameterized Types 463<br/>Conversions Between Scala and Java Collections 464<br/>Java Lambdas Versus Scala Functions 464<br/>Annotations for JavaBean Properties and Other Purposes 464<br/>Recap and What’s Next 465<br/>23. Application Design. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 467<br/>Recap of What We Already Know 467<br/>Annotations 468<br/>Using @main Entry Points 469<br/>Design Patterns 470<br/>Creational Patterns 470<br/>Structural Patterns 471<br/>Behavioral Patterns 472<br/>Better Design with Design by Contract 474<br/>The Parthenon Architecture 477<br/>Recap and What’s Next 483<br/>24. Metaprogramming: Macros and Reflection. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 485<br/>Scala Compile Time Reflection 487<br/>Java Runtime Reflection 488<br/>Scala Reflect API 490<br/>Type Class Derivation: Implementation Details 491<br/>Table of Contents | xv<br/>Scala 3 Metaprogramming 491<br/>Inline 491<br/>Macros 496<br/>Staging 500<br/>Wrapping Up and Looking Ahead 502<br/>A. Significant Indentation Versus Braces Syntax. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503<br/>Bibliography. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 507<br/>Index. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 509<br/>xvi | Table of Contents |
| 650 ## - SUBJECT ADDED ENTRY--TOPICAL TERM |
|---|
| Topical term or geographic name as entry element |
Scala Programming, Functional Programming, Object-Oriented Programming (OOP), Scalability Software Development, JVM (Java Virtual Machine), Concurrency Big Data Akka Domain-Specific Languages (DSLs) Type Systems Design Patterns Software Engineering |
| 690 ## - LOCAL SUBJECT ADDED ENTRY--TOPICAL TERM (OCLC, RLIN) |
|---|
| Department Name |
Computer Science |
| 942 ## - ADDED ENTRY ELEMENTS (KOHA) |
|---|
| Source of classification or shelving scheme |
Dewey Decimal Classification |
| Koha item type |
General Books |
