Muutke küpsiste eelistusi

E-raamat: Scala for the Impatient

4.09/5 (639 hinnangut Goodreads-ist)
  • Formaat: 400 pages
  • Ilmumisaeg: 27-Dec-2022
  • Kirjastus: Addison Wesley
  • Keel: eng
  • ISBN-13: 9780138033576
Teised raamatud teemal:
  • Formaat - EPUB+DRM
  • Hind: 38,60 €*
  • * hind on lõplik, st. muud allahindlused enam ei rakendu
  • Lisa ostukorvi
  • Lisa soovinimekirja
  • See e-raamat on mõeldud ainult isiklikuks kasutamiseks. E-raamatuid ei saa tagastada.
Scala for the ImpatientSuurem pilt
  • Formaat: 400 pages
  • Ilmumisaeg: 27-Dec-2022
  • Kirjastus: Addison Wesley
  • Keel: eng
  • ISBN-13: 9780138033576
Teised raamatud teemal:

DRM piirangud

  • Kopeerimine (copy/paste):

    ei ole lubatud

  • Printimine:

    ei ole lubatud

  • Kasutamine:

    Digitaalõiguste kaitse (DRM)
    Kirjastus on väljastanud selle e-raamatu krüpteeritud kujul, mis tähendab, et selle lugemiseks peate installeerima spetsiaalse tarkvara. Samuti peate looma endale  Adobe ID Rohkem infot siin. E-raamatut saab lugeda 1 kasutaja ning alla laadida kuni 6'de seadmesse (kõik autoriseeritud sama Adobe ID-ga).

    Vajalik tarkvara
    Mobiilsetes seadmetes (telefon või tahvelarvuti) lugemiseks peate installeerima selle tasuta rakenduse: PocketBook Reader (iOS / Android)

    PC või Mac seadmes lugemiseks peate installima Adobe Digital Editionsi (Seeon tasuta rakendus spetsiaalselt e-raamatute lugemiseks. Seda ei tohi segamini ajada Adober Reader'iga, mis tõenäoliselt on juba teie arvutisse installeeritud )

    Seda e-raamatut ei saa lugeda Amazon Kindle's. 

Clear, Concise Guide to Scala for Professional Programmers--Updated through Scala 3.x

Scala 3 is more concise, consistent, flexible, robust, and efficient, but there's a lot to learn and navigating features and improvements can be challenging. Scala for the Impatient, Third Edition, is a complete yet concise guide that reflects the major enhancements of Scala 3, from improved syntax and revamped type system to powerful contextual abstractions.

Written by renowned programming instructor Cay S. Horstmann--author of the classic Core Java--this indispensable tutorial offers a faster, easier pathway for learning today's Scala. Horstmann covers everything working developers need to know, focusing on hands-on solutions, not academic theory. Given the size and scope of Scala 3, there's plenty to cover but it's presented in small chunks organized for quick access and easy understanding, with plenty of practical insights and focused sample code.

  • Get started quickly with Scala 3 interpreter, syntax, tools, and current usage
  • Master core language features: functions, arrays, maps, tuples, packages, imports, exception handling, and more
  • Design and build better object-oriented code with Scala 3
  • Use Scala for real-world programming tasks: working with files, regular expressions, and XML
  • Work with higher-order functions and the powerful Scala collections library
  • Create concurrent programs with Scala futures
  • Understand the Scala type system, including revamped enums, intersection and union types, and enhanced type inference
  • Use contextual abstractions to easily extend class hierarchies, enrich existing classes, perform automatic conversions, and elegantly hide tedious details
  • Apply advanced "power tools" such as annotations and implicits
  • Discover how to "program with types," analyzing and generating types at compile time
  • Get a taste of what’s now possible with Scala macros

If you're a Java, C++, or C# programmer who's new to Scala or functional programming--or even if you've already used earlier versions of Scala--this guide will help you write code that's more robust, more efficient, and more secure.

Foreword to the First Edition xix
Preface xxi
About the Author xxv
1 The Basics A1
1(16)
1.1 The Sea la Interpreter
1(3)
1.2 Declaring Values and Variables
4(1)
1.3 Commonly Used Types
5(2)
1.4 Arithmetic and Operator Overloading
7(1)
1.5 More about Calling Methods
8(1)
1.6 The apply Method
9(2)
1.7 Scaladoc
11(6)
Exercises
14(3)
2 Control Structures And Functions A1
17(22)
2.1 Conditional Expressions
18(2)
2.2 Statement Termination
20(1)
2.3 Block Expressions and Assignments
21(1)
2.4 Input and Output
22(1)
2.5 Loops
23(2)
2.6 More about the for Loop
25(2)
2.7 Functions
27(2)
2.8 Default and Named Arguments L1
29(1)
2.9 Variable Arguments L1
30(1)
2.10 The Main Function
31(1)
2.11 Functions without Parameters
31(1)
2.12 Lazy Values L1
32(1)
2.13 Exceptions
33(6)
Exercises
36(3)
3 Working With Arrays A1
39(12)
3.1 Fixed-Length Arrays
39(1)
3.2 Variable-Length Arrays: Array Buffers
40(1)
3.3 Traversing Arrays and Array Buffers
41(1)
3.4 Transforming Arrays
42(2)
3.5 Common Algorithms
44(1)
3.6 Deciphering Scaladoc
45(1)
3.7 Multidimensional Arrays
46(1)
3.8 Interoperating with Java
47(4)
Exercises
48(3)
4 Maps, Options, And Tuples A1
51(12)
4.1 Constructing a Map
52(1)
4.2 Accessing Map Values
52(1)
4.3 Updating Map Values
53(1)
4.4 Iterating over Maps
54(1)
4.5 Linked and Sorted Maps
54(1)
4.6 Interoperating with Java
55(1)
4.7 The Option Type
56(1)
4.8 Tuples
57(2)
4.9 Zipping
59(4)
Exercises
59(4)
5 Classes A1
63(14)
5.1 Simple Classes and Parameterless Methods
63(2)
5.2 Properties with Getters and Setters
65(2)
5.3 Properties with Only Getters
67(1)
5.4 Private Fields
68(1)
5.5 Auxiliary Constructors
69(1)
5.6 The Primary Constructor
70(3)
5.7 Nested Classes L1
73(4)
Exercises
74(3)
6 Objects And Enumerations A1
77(8)
6.1 Singletons
78(1)
6.2 Companion Objects
78(1)
6.3 Objects Extending a Class or Trait
79(1)
6.4 The apply Method
80(1)
6.5 Application Objects
81(1)
6.6 Enumerations
81(4)
Exercises
83(2)
7 Packages, Imports, And Exports A1
85(12)
7.1 Packages
86(1)
7.2 Package Scope Nesting
87(1)
7.3 Chained Package Clauses
88(1)
7.4 Top-of-File Notation
88(1)
7.5 Package-Level Functions and Variables
89(1)
7.6 Package Visibility
89(1)
7.7 Imports
90(1)
7.8 Imports Can Be Anywhere
91(1)
7.9 Renaming and Hiding Members
91(1)
7.10 Implicit Imports
92(1)
7.11 Exports
92(5)
Exercises
93(4)
8 Inheritance A1
97(20)
8.1 Extending a Class
98(1)
8.2 Overriding Methods
98(1)
8.3 Type Checks and Casts
99(1)
8.4 Superclass Construction
100(1)
8.5 Anonymous Subclasses
101(1)
8.6 Abstract Classes
101(1)
8.7 Abstract Fields
102(1)
8.8 Overriding Fields
102(2)
8.9 Open and Sealed Classes
104(1)
8.10 Protected Fields and Methods
105(1)
8.11 Construction Order
105(1)
8.12 The Scala Inheritance Hierarchy
106(3)
8.13 Object Equality L1
109(1)
8.14 Multiversal Equality L2
110(1)
8.15 Value Classes L2
111(6)
Exercises
112(5)
9 Files And Regular Expressions A1
117(12)
9.1 Reading Lines
118(1)
9.2 Reading Characters
118(1)
9.3 Reading Tokens and Numbers
119(1)
9.4 Reading from URLs and Other Sources
120(1)
9.5 Writing Files
120(1)
9.6 Visiting Directories
120(1)
9.7 Serialization
121(1)
9.8 Process Control A1
122(2)
9.9 Regular Expressions
124(2)
9.10 Regular Expression Groups
126(3)
Exercises
126(3)
10 Traits L1
129(20)
10.1 Why No Multiple Inheritance?
129(2)
10.2 Traits as Interfaces
131(1)
10.3 Traits with Concrete Methods
132(1)
10.4 Traits for Rich Interfaces
133(1)
10.5 Objects with Traits
133(1)
10.6 Layered Traits
134(1)
10.7 Overriding Abstract Methods in Traits
135(1)
10.8 Concrete Fields in Traits
136(1)
10.9 Abstract Fields in Traits
137(1)
10.10 Trait Construction Order
138(1)
10.11 Trait Constructors with Parameters
139(1)
10.12 Traits Extending Classes
140(1)
10.13 What Happens under the Hood
141(2)
10.14 Transparent Traits L2
143(1)
10.15 Self Types L2
143(6)
Exercises
145(4)
11 Operators L1
149(20)
11.1 Identifiers
150(1)
11.2 Infix Operators
151(1)
11.3 Unary Operators
152(1)
11.4 Assignment Operators
153(1)
11.5 Precedence
153(1)
11.6 Associativity
154(1)
11.7 The apply and update Methods
155(1)
11.8 The unapply Method L2
155(2)
11.9 The unapplySeq Method L2
157(1)
11.10 Alternative Forms of the unapply and unapplySeq Methods L3
158(1)
11.11 Dynamic Invocation L2
159(3)
11.12 Typesafe Selection and Application L2
162(7)
Exercises
163(6)
12 Higher-Order Functions L1
169(14)
12.1 Functions as Values
170(1)
12.2 Anonymous Functions
170(1)
12.3 Parameters That Are Functions
171(1)
12.4 Parameter Inference
172(1)
12.5 Useful Higher-Order Functions
173(1)
12.6 Closures
174(1)
12.7 Interoperability with Lambda Expressions
175(1)
12.8 Currying
176(1)
12.9 Methods for Composing, Currying, and Tupling
177(1)
12.10 Control Abstractions
178(1)
12.11 Nonlocal Returns
179(4)
Exercises
180(3)
13 Collections A2
183(26)
13.1 The Main Collections Traits
184(1)
13.2 Mutable and Immutable Collections
185(2)
13.3 Sequences
187(1)
13.4 Lists
188(1)
13.5 Sets
189(1)
13.6 Operators for Adding or Removing Elements
190(3)
13.7 Common Methods
193(2)
13.8 Mapping a Function
195(2)
13.9 Reducing, Folding, and Scanning A3
197(3)
13.10 Zipping
200(1)
13.11 Iterators
201(1)
13.12 Lazy Lists A3
202(2)
13.13 Interoperability with Java Collections
204(5)
Exercises
205(4)
14 Pattern Matching A2
209(22)
14.1 A Better Switch
210(1)
14.2 Guards
211(1)
14.3 Variables in Patterns
211(1)
14.4 Type Patterns
212(1)
14.5 The Matchable Trait
213(1)
14.6 Matching Arrays, Lists, and Tuples
214(2)
14.7 Extractors
216(1)
14.8 Patterns in Variable Declarations
217(1)
14.9 Patterns in for Expressions
218(1)
14.10 Case Classes
219(2)
14.11 Matching Nested Structures
221(1)
14.12 Sealed Classes
222(1)
14.13 Parameterized Enumerations
223(1)
14.14 Partial Functions A3
224(1)
14.15 Infix Notation in case Clauses L2
225(6)
Exercises
226(5)
15 Annotations A2
231(14)
15.1 What Are Annotations?
232(1)
15.2 Annotation Placement
232(1)
15.3 Annotation Arguments
233(1)
15.4 Annotations for Java Features
234(2)
15.4.1 Bean Properties
234(1)
15.4.2 Serialization
234(1)
15.4.3 Checked Exceptions
235(1)
15.4.4 Variable Arguments
235(1)
15.4.5 Java Modifiers
236(1)
15.5 Annotations for Optimizations
236(2)
15.5.1 Tail Recursion
236(2)
15.5.2 Lazy Values
238(1)
15.6 Annotations for Errors and Warnings
238(1)
15.7 Annotation Declarations
239(6)
Exercises
241(4)
16 Futures A2
245(18)
16.1 Running Tasks in the Future
246(2)
16.2 Waiting for Results
248(1)
16.3 The Try Class
249(1)
16.4 Callbacks
250(1)
16.5 Composing Future Tasks
251(2)
16.6 Other Future Transformations
253(2)
16.7 Methods in the Future Object
255(2)
16.8 Promises
257(1)
16.9 Execution Contexts
258(5)
Exercises
259(4)
17 Type Parameters L2
263(2)
17.1 Generic Classes
264(1)
17.2 Generic Functions
264(1)
1 7.3 Bounds for Type Variables
265(12)
17.4 Context Bounds
266(1)
17.5 The CI assTag Context Bound
267(1)
17.6 Multiple Bounds
267(1)
17.7 Type Constraints L3
267(1)
17.8 Variance
268(2)
17.9 Co-and Contravariant Positions
270(1)
17.10 Objects Can't Be Generic
271(1)
17.11 Wildcards
272(1)
17.12 Polymorphic Functions
273(4)
Exercises
274(3)
18 Advanced Types L2
277(18)
18.1 Union Types
277(1)
18.2 Intersection Types
278(1)
18.3 Type Aliases
279(2)
18.4 Structural Types
281(2)
18.5 Literal Types
283(1)
18.6 The Singleton Type Operator
284(2)
18.7 Abstract Types
286(1)
18.8 Dependent Types
287(2)
18.9 Abstract Type Bounds
289(6)
Exercises
290(5)
19 Contextual Abstractions L3
295(22)
19.1 Context Parameters
296(1)
19.2 More about Context Parameters
297(2)
19.3 Declaring Given Instances
299(2)
19.4 Givens in for and match Expressions
301(1)
19.5 Importing Givens
302(1)
19.6 Extension Methods
303(1)
19.7 Where Extension Methods Are Found
304(2)
19.8 Implicit Conversions
306(1)
19.9 Rules for Implicit Conversions
307(1)
19.10 Importing Implicit Conversions
308(1)
19.11 Context Functions
309(2)
19.12 Evidence
311(1)
19.13 The @implicit Not Found Annotation
312(5)
Exercises
313(4)
20 Type-Level Programming L3
317(26)
20.1 Match Types
318(1)
20.2 Heterogeneous Lists
319(3)
20.3 Literal Type Arithmetic
322(1)
20.4 Inline Code
323(3)
20.5 Type Classes
326(2)
20.6 Mirrors
328(2)
20.7 Type Class Derivation
330(2)
20.8 Higher-Kinded Types
332(2)
20.9 Type Lambdas
334(1)
20.10 A Brief Introduction into Macros
335(8)
Exercises
339(4)
Index 343
Cay S. Horstmann is principal author of Core Java, Volumes I and II, Twelfth Edition (Pearson, 2022), and author of Core Java for the Impatient, Third Edition (Addison-Wesley, 2022), and Modern JavaScript for the Impatient (Addison-Wesley, 2020). He has written more than a dozen other books for professional programmers and computer science students. He is professor emeritus of computer science at San Jose State University and a Java Champion.
Lisainfo e-raamatute kohta Lisainfo e-raamatute kohta
Püsilink: https://www.kriso.ee/db/97801380335766e.html
Märksõnad: