Programming In Scala A Comprehensive Step By Guide, Third Edition Martin Odersky

User Manual:

Open the PDF directly: View PDF .
Page Count: 592 [warning: Documents this large are best viewed by clicking the View PDF Link!]

Scroll down to view the document on your mobile browser.

Praise for the earlier editions of Programming in Scala
Table of Contents
Foreword
Acknowledgments
Introduction
- WHO SHOULD READ THIS BOOK
- HOW TO USE THIS BOOK
- HOW TO LEARN SCALA
- EBOOK FEATURES
- TYPOGRAPHIC CONVENTIONS
- CONTENT OVERVIEW
- RESOURCES
- SOURCE CODE
- ERRATA
- Chapter 1
A Scalable Language
- 1.1 A LANGUAGE THAT GROWS ON YOU
  - Growing new types
  - Growing new control constructs
- 1.2 WHAT MAKES SCALA SCALABLE?
  - Scala is object-oriented
  - Scala is functional
- 1.3 WHY SCALA?
- 1.4 SCALA'S ROOTS
- 1.5 CONCLUSION
  - Footnotes for Chapter 1:
- Chapter 2
First Steps in Scala
- STEP 1. LEARN TO USE THE SCALA INTERPRETER
- STEP 2. DEFINE SOME VARIABLES
- STEP 3. DEFINE SOME FUNCTIONS
  - Figure 2.1 - The basic form of a function definition in Scala.
- STEP 4. WRITE SOME SCALA SCRIPTS
- STEP 5. LOOP WITH WHILE; DECIDE WITH IF
  - Note
- STEP 6. ITERATE WITH FOREACH AND FOR
  - Figure 2.2 - The syntax of a function literal in Scala.
- CONCLUSION
  - Footnotes for Chapter 2:
- Chapter 3
Next Steps in Scala
- STEP 7. PARAMETERIZE ARRAYS WITH TYPES
  - Listing 3.1 - Parameterizing an array with a type.
  - Note
    - Figure 3.1 - All operations are method calls in Scala.
    - Listing 3.2 - Creating and initializing an array.
- STEP 8. USE LISTS
  - Listing 3.3 - Creating and initializing a list.
  - Note
- WHY NOT APPEND TO LISTS?
  - Some List methods and usages
- STEP 9. USE TUPLES
  - Listing 3.4 - Creating and using a tuple.
- ACCESSING THE ELEMENTS OF A TUPLE
- STEP 10. USE SETS AND MAPS
- STEP 11. LEARN TO RECOGNIZE THE FUNCTIONAL STYLE
  - Listing 3.9 - A function without side effects or vars.
- A BALANCED ATTITUDE FOR SCALA PROGRAMMERS
- STEP 12. READ LINES FROM A FILE
  - Listing 3.10 - Reading lines from a file.
  - Listing 3.11 - Printing formatted character counts for the lines of a file.
- CONCLUSION
  - Footnotes for Chapter 3:
- Chapter 4
Classes and Objects
- 4.1 CLASSES, FIELDS, AND METHODS
  - Note
    - Listing 4.1 - Final version of class ChecksumAccumulator.
- 4.2 SEMICOLON INFERENCE
- THE RULES OF SEMICOLON INFERENCE
- 4.3 SINGLETON OBJECTS
  - Listing 4.2 - Companion object for class ChecksumAccumulator.
- 4.4 A SCALA APPLICATION
  - Listing 4.3 - The Summer application.
  - Note
- 4.5 THE APP TRAIT
  - Listing 4.4 - Using the App trait.
- 4.6 CONCLUSION
  - Footnotes for Chapter 4:
- Chapter 5
Basic Types and Operations
- 5.1 SOME BASIC TYPES
  - Table 5.1 - Some basic types
- 5.2 LITERALS
- FAST TRACK FOR JAVA PROGRAMMERS
- 5.3 STRING INTERPOLATION
- 5.4 OPERATORS ARE METHODS
- ANY METHOD CAN BE AN OPERATOR
- FAST TRACK FOR JAVA PROGRAMMERS
- 5.5 ARITHMETIC OPERATIONS
- 5.6 RELATIONAL AND LOGICAL OPERATIONS
  - Note
- 5.7 BITWISE OPERATIONS
- 5.8 OBJECT EQUALITY
- HOW SCALA'S == DIFFERS FROM JAVA'S
- 5.9 OPERATOR PRECEDENCE AND ASSOCIATIVITY
  - Table 5.3 - Operator precedence
- 5.10 RICH WRAPPERS
  - Table 5.4 - Some rich operations
  - Table 5.5 - Rich wrapper classes
- 5.11 CONCLUSION
  - Footnotes for Chapter 5:
- Chapter 6
Functional Objects
- 6.1 A SPECIFICATION FOR CLASS RATIONAL
- 6.2 CONSTRUCTING A RATIONAL
- IMMUTABLE OBJECT TRADE-OFFS
  - Note
- 6.3 REIMPLEMENTING THE TOSTRING METHOD
- 6.4 CHECKING PRECONDITIONS
- 6.5 ADDING FIELDS
  - Listing 6.1 - Rational with fields.
- 6.6 SELF REFERENCES
- 6.7 AUXILIARY CONSTRUCTORS
  - Listing 6.2 - Rational with an auxiliary constructor.
  - Note
- 6.8 PRIVATE FIELDS AND METHODS
  - Listing 6.3 - Rational with a private field and method.
- 6.9 DEFINING OPERATORS
  - Listing 6.4 - Rational with operator methods.
- 6.10 IDENTIFIERS IN SCALA
  - Note
- 6.11 METHOD OVERLOADING
  - Listing 6.5 - Rational with overloaded methods.
  - Note
- 6.12 IMPLICIT CONVERSIONS
- 6.13 A WORD OF CAUTION
- 6.14 CONCLUSION
  - Footnotes for Chapter 6:
- Chapter 7
Built-in Control Structures
- 7.1 IF EXPRESSIONS
  - Listing 7.1 - Scala's idiom for conditional initialization.
- 7.2 WHILE LOOPS
- 7.3 FOR EXPRESSIONS
- 7.4 EXCEPTION HANDLING WITH TRY EXPRESSIONS
- 7.5 MATCH EXPRESSIONS
  - Listing 7.14 - A match expression with side effects.
  - Listing 7.15 - A match expression that yields a value.
- 7.6 LIVING WITHOUT BREAK AND CONTINUE
- 7.7 VARIABLE SCOPE
- FAST TRACK FOR JAVA PROGRAMMERS
  - Listing 7.18 - Variable scoping when printing a multiplication table.
- 7.8 REFACTORING IMPERATIVE-STYLE CODE
  - Listing 7.19 - A functional way to create a multiplication table.
- 7.9 CONCLUSION
  - Footnotes for Chapter 7:
- Chapter 8
Functions and Closures
- 8.1 METHODS
  - Listing 8.1 - LongLines with a private processLine method.
- 8.2 LOCAL FUNCTIONS
  - Listing 8.2 - LongLines with a local processLine function.
- 8.3 FIRST-CLASS FUNCTIONS
- 8.4 SHORT FORMS OF FUNCTION LITERALS
- 8.5 PLACEHOLDER SYNTAX
- 8.6 PARTIALLY APPLIED FUNCTIONS
- 8.7 CLOSURES
- WHY THE TRAILING UNDERSCORE?
- 8.8 SPECIAL FUNCTION CALL FORMS
- 8.9 TAIL RECURSION
  - Tracing tail-recursive functions
- TAIL CALL OPTIMIZATION
  - Limits of tail recursion
- 8.10 CONCLUSION
  - Footnotes for Chapter 8:
- Chapter 9
Control Abstraction
- 9.1 REDUCING CODE DUPLICATION
  - Listing 9.1 - Using closures to reduce code duplication.
- 9.2 SIMPLIFYING CLIENT CODE
- 9.3 CURRYING
  - Listing 9.2 - Defining and invoking a "plain old" function.
  - Listing 9.3 - Defining and invoking a curried function.
- 9.4 WRITING NEW CONTROL STRUCTURES
  - Listing 9.4 - Using the loan pattern to write to a file.
- 9.5 BY-NAME PARAMETERS
  - Listing 9.5 - Using a by-name parameter.
- 9.6 CONCLUSION
  - Footnotes for Chapter 9:
- Chapter 10
Composition and Inheritance
- 10.1 A TWO-DIMENSIONAL LAYOUT LIBRARY
- 10.2 ABSTRACT CLASSES
  - Listing 10.1 - Defining an abstract method and class.
- 10.3 DEFINING PARAMETERLESS METHODS
  - Listing 10.2 - Defining parameterless methods width and height.
- 10.4 EXTENDING CLASSES
  - Listing 10.3 - Defining ArrayElement as a subclass of Element.
  - Figure 10.1 - Class diagram for ArrayElement.
- 10.5 OVERRIDING METHODS AND FIELDS
  - Listing 10.4 - Overriding a parameterless method with a field.
- 10.6 DEFINING PARAMETRIC FIELDS
  - Listing 10.5 - Defining contents as a parametric field.
- 10.7 INVOKING SUPERCLASS CONSTRUCTORS
  - Listing 10.6 - Invoking a superclass constructor.
  - Figure 10.2 - Class diagram for LineElement.
- 10.8 USING OVERRIDE MODIFIERS
- 10.9 POLYMORPHISM AND DYNAMIC BINDING
  - Figure 10.3 - Class hierarchy of layout elements.
- 10.10 DECLARING FINAL MEMBERS
  - Listing 10.7 - Declaring a final method.
  - Listing 10.8 - Declaring a final class.
- 10.11 USING COMPOSITION AND INHERITANCE
  - Figure 10.4 - Class hierarchy with revised LineElement.
- 10.12 IMPLEMENTING ABOVE, BESIDE, AND TOSTRING
  - Listing 10.9 - Class Element with above, beside, and toString.
- 10.13 DEFINING A FACTORY OBJECT
  - Listing 10.10 - A factory object with factory methods.
  - Listing 10.11 - Class Element refactored to use factory methods.
- 10.14 HEIGHTEN AND WIDEN
  - Listing 10.12 - Hiding implementation with private classes.
  - Listing 10.13 - Element with widen and heighten methods.
- 10.15 PUTTING IT ALL TOGETHER
  - Listing 10.14 - The Spiral application.
- 10.16 CONCLUSION
  - Footnotes for Chapter 10:
- Chapter 11
Scala's Hierarchy
- 11.1 SCALA'S CLASS HIERARCHY
  - Class hierarchy of Scala.
- 11.2 HOW PRIMITIVES ARE IMPLEMENTED
- 11.3 BOTTOM TYPES
- 11.4 DEFINING YOUR OWN VALUE CLASSES
  - Avoiding a types monoculture
- 11.5 CONCLUSION
  - Footnotes for Chapter 11:
- Chapter 12
Traits
- 12.1 HOW TRAITS WORK
- 12.2 THIN VERSUS RICH INTERFACES
- 12.3 EXAMPLE: RECTANGULAR OBJECTS
  - Listing 12.5 - Defining an enrichment trait.
- 12.4 THE ORDERED TRAIT
- 12.5 TRAITS AS STACKABLE MODIFICATIONS
- 12.6 WHY NOT MULTIPLE INHERITANCE?
  - Note
    - Figure 12.1 - Inheritance hierarchy and linearization of class Cat.
    - Table 12.1 - Linearization of types in Cat's hierarchy
- 12.7 TO TRAIT OR NOT TO TRAIT?
- 12.8 CONCLUSION
  - Footnotes for Chapter 12:
- Chapter 13
Packages and Imports
- 13.1 PUTTING CODE IN PACKAGES
  - Listing 13.1 - Placing the contents of an entire file into a package.
  - Note
- 13.2 CONCISE ACCESS TO RELATED CODE
- 13.3 IMPORTS
  - Listing 13.7 - Bob's delightful fruits, ready for import.
  - Listing 13.8 - Importing the members of a regular (not singleton) object.
- SCALA'S FLEXIBLE IMPORTS
  - Listing 13.9 - Importing a package name.
- 13.4 IMPLICIT IMPORTS
- 13.5 ACCESS MODIFIERS
- 13.6 PACKAGE OBJECTS
  - Listing 13.14 - A package object.
- 13.7 CONCLUSION
  - Footnotes for Chapter 13:
- Chapter 14
Assertions and Tests
- 14.1 ASSERTIONS
  - Listing 14.1 - Using an assertion.
  - Listing 14.2 - Using ensuring to assert a function's result.
- 14.2 TESTING IN SCALA
  - Listing 14.3 - Writing tests with FunSuite.
- 14.3 INFORMATIVE FAILURE REPORTS
- 14.4 TESTS AS SPECIFICATIONS
- 14.5 PROPERTY-BASED TESTING
  - Listing 14.7 - Writing property-based tests with ScalaCheck.
- 14.6 ORGANIZING AND RUNNING TESTS
  - Figure 14.1 - The output of org.scalatest.run.
- 14.7 CONCLUSION
  - Footnotes for Chapter 14:
- Chapter 15
Case Classes and Pattern Matching
- 15.1 A SIMPLE EXAMPLE
- 15.2 KINDS OF PATTERNS
- 15.3 PATTERN GUARDS
  - Listing 15.14 - A match expression with a pattern guard.
- 15.4 PATTERN OVERLAPS
  - Listing 15.15 - Match expression in which case order matters.
- 15.5 SEALED CLASSES
  - Listing 15.16 - A sealed hierarchy of case classes.
- 15.6 THE OPTION TYPE
- 15.7 PATTERNS EVERYWHERE
- 15.8 A LARGER EXAMPLE
- 15.9 CONCLUSION
  - Footnotes for Chapter 15:
- Chapter 16
Working with Lists
- 16.1 LIST LITERALS
- 16.2 THE LIST TYPE
- 16.3 CONSTRUCTING LISTS
- 16.4 BASIC OPERATIONS ON LISTS
  - Table 16.1 - Basic list operations
- 16.5 LIST PATTERNS
- ABOUT PATTERN MATCHING ON LISTS
- 16.6 FIRST-ORDER METHODS ON CLASS LIST
- THE FAST TRACK
  - Listing 16.1 - A merge sort function for Lists.
- 16.7 HIGHER-ORDER METHODS ON CLASS LIST
- 16.8 METHODS OF THE LIST OBJECT
- 16.9 PROCESSING MULTIPLE LISTS TOGETHER
- THE FAST TRACK
- 16.10 UNDERSTANDING SCALA'S TYPE INFERENCE ALGORITHM
- 16.11 CONCLUSION
  - Footnotes for Chapter 16:
- Chapter 17
Working with Other Collections
- 17.1 SEQUENCES
- 17.2 SETS AND MAPS
- 17.3 SELECTING MUTABLE VERSUS IMMUTABLE COLLECTIONS
- 17.4 INITIALIZING COLLECTIONS
  - Converting to array or list
  - Converting between mutable and immutable sets and maps
- 17.5 TUPLES
- 17.6 CONCLUSION
  - Footnotes for Chapter 17:
- Chapter 18
Mutable Objects
- 18.1 WHAT MAKES AN OBJECT MUTABLE?
  - Listing 18.1 - A mutable bank account class.
- 18.2 REASSIGNABLE VARIABLES AND PROPERTIES
- 18.3 CASE STUDY: DISCRETE EVENT SIMULATION
- THE FAST TRACK
  - Figure 18.1 - Basic gates.
- 18.4 A LANGUAGE FOR DIGITAL CIRCUITS
- 18.5 THE SIMULATION API
  - Listing 18.8 - The Simulation class.
- 18.6 CIRCUIT SIMULATION
- 18.7 CONCLUSION
  - Footnotes for Chapter 18:
- Chapter 19
Type Parameterization
- 19.1 FUNCTIONAL QUEUES
  - Listing 19.1 - A basic functional queue.
- 19.2 INFORMATION HIDING
  - Private constructors and factory methods
  - An alternative: private classes
- 19.3 VARIANCE ANNOTATIONS
  - Listing 19.5 - A nonvariant (rigid) Cell class.
  - Variance and arrays
- 19.4 CHECKING VARIANCE ANNOTATIONS
- THE FAST TRACK
- 19.5 LOWER BOUNDS
  - Listing 19.6 - A type parameter with a lower bound.
- 19.6 CONTRAVARIANCE
- 19.7 OBJECT PRIVATE DATA
- 19.8 UPPER BOUNDS
  - Listing 19.11 - A Person class that mixes in the Ordered trait.
  - Listing 19.12 - A merge sort function with an upper bound.
- 19.9 CONCLUSION
  - Footnotes for Chapter 19:
- Chapter 20
Abstract Members
- 20.1 A QUICK TOUR OF ABSTRACT MEMBERS
- 20.2 TYPE MEMBERS
- 20.3 ABSTRACT VALS
  - Listing 20.1 - Overriding abstract vals and parameterless methods.
- 20.4 ABSTRACT VARS
  - Listing 20.2 - Declaring abstract vars.
  - Listing 20.3 - How abstract vars are expanded into getters and setters.
- 20.5 INITIALIZING ABSTRACT VALS
- LAZY FUNCTIONAL LANGUAGES
- 20.6 ABSTRACT TYPES
  - Listing 20.9 - Modeling suitable food with an abstract type.
  - Listing 20.10 - Implementing an abstract type in a subclass.
- 20.7 PATH-DEPENDENT TYPES
- 20.8 REFINEMENT TYPES
- 20.9 ENUMERATIONS
- 20.10 CASE STUDY: CURRENCIES
- 20.11 CONCLUSION
  - Footnotes for Chapter 20:
- Chapter 21
Implicit Conversions and Parameters
- 21.1 IMPLICIT CONVERSIONS
- 21.2 RULES FOR IMPLICITS
  - Naming an implicit conversion
  - Where implicits are tried
- 21.3 IMPLICIT CONVERSION TO AN EXPECTED TYPE
- 21.4 CONVERTING THE RECEIVER
- 21.5 IMPLICIT PARAMETERS
- 21.6 CONTEXT BOUNDS
- 21.7 WHEN MULTIPLE CONVERSIONS APPLY
- 21.8 DEBUGGING IMPLICITS
  - Listing 21.7 - Sample code that uses an implicit parameter.
  - Listing 21.8 - Sample code after type checking and insertion of implicits.
- 21.9 CONCLUSION
  - Footnotes for Chapter 21:
- Chapter 22
Implementing Lists
- 22.1 THE LIST CLASS IN PRINCIPLE
- 22.2 THE LISTBUFFER CLASS
- 22.3 THE LIST CLASS IN PRACTICE
  - Listing 22.5 - The definition of method map in class List.
  - Listing 22.6 - The definition of the :: subclass of List.
- 22.4 FUNCTIONAL ON THE OUTSIDE
- 22.5 CONCLUSION
  - Footnotes for Chapter 22:
- Chapter 23
For Expressions Revisited
- 23.1 FOR EXPRESSIONS
- 23.2 THE N-QUEENS PROBLEM
- 23.3 QUERYING WITH FOR EXPRESSIONS
- 23.4 TRANSLATION OF FOR EXPRESSIONS
- 23.5 GOING THE OTHER WAY
- 23.6 GENERALIZING FOR
- 23.7 CONCLUSION
- Chapter 24
Collections in Depth
- 24.1 MUTABLE AND IMMUTABLE COLLECTIONS
  - Collection hierarchy.
- 24.2 COLLECTIONS CONSISTENCY
- 24.3 TRAIT TRAVERSABLE
  - Operations in trait Traversable
- 24.4 TRAIT ITERABLE
- 24.5 THE SEQUENCE TRAITS SEQ, INDEXEDSEQ, AND LINEARSEQ
  - Operations in trait Seq
  - Buffers
    - Operations in trait Buffer
- 24.6 SETS
  - Operations in trait Set
  - Operations in trait mutable.Set
- 24.7 MAPS
  - Operations in trait Map
  - Operations in trait mutable.Map
- 24.8 CONCRETE IMMUTABLE COLLECTION CLASSES
- 24.9 CONCRETE MUTABLE COLLECTION CLASSES
- 24.10 ARRAYS
- 24.11 STRINGS
- 24.12 PERFORMANCE CHARACTERISTICS
  - Performance characteristics of sequence types
  - Performance characteristics of set and map types
- 24.13 EQUALITY
- 24.14 VIEWS
- 24.15 ITERATORS
  - Operations in trait Iterator
  - Buffered iterators
- 24.16 CREATING COLLECTIONS FROM SCRATCH
  - Factory methods for sequences
- 24.17 CONVERSIONS BETWEEN JAVA AND SCALA COLLECTIONS
- 24.18 CONCLUSION
  - Footnotes for Chapter 24:
- Chapter 25
The Architecture of Scala Collections
- 25.1 BUILDERS
  - Listing 25.1 - An outline of the Builder class.
- 25.2 FACTORING OUT COMMON OPERATIONS
- THE FAST TRACK
- 25.3 INTEGRATING NEW COLLECTIONS
- 25.4 CONCLUSION
  - Footnotes for Chapter 25:
- Chapter 26
Extractors
- 26.1 AN EXAMPLE: EXTRACTING EMAIL ADDRESSES
- 26.2 EXTRACTORS
  - Listing 26.1 - The EMail string extractor object.
  - Note
- 26.3 PATTERNS WITH ZERO OR ONE VARIABLES
  - Listing 26.2 - The Twice string extractor object.
  - Listing 26.3 - The UpperCase string extractor object.
- 26.4 VARIABLE ARGUMENT EXTRACTORS
  - Listing 26.4 - The Domain string extractor object.
  - Listing 26.5 - The ExpandedEMail extractor object.
- 26.5 EXTRACTORS AND SEQUENCE PATTERNS
  - Listing 26.6 - An extractor that defines an unapplySeq method.
- 26.6 EXTRACTORS VERSUS CASE CLASSES
- 26.7 REGULAR EXPRESSIONS
- 26.8 CONCLUSION
  - Footnotes for Chapter 26:
- Chapter 27
- Chapter 28
Working with XML
- 28.1 SEMI-STRUCTURED DATA
- 28.2 XML OVERVIEW
- 28.3 XML LITERALS
- 28.4 SERIALIZATION
  - Note
- 28.5 TAKING XML APART
  - Note
- 28.6 DESERIALIZATION
- 28.7 LOADING AND SAVING
- 28.8 PATTERN MATCHING ON XML
- 28.9 CONCLUSION
  - Footnotes for Chapter 28:
- Chapter 29
Modular Programming Using Objects
- 29.1 THE PROBLEM
- 29.2 A RECIPE APPLICATION
- 29.3 ABSTRACTION
- 29.4 SPLITTING MODULES INTO TRAITS
- 29.5 RUNTIME LINKING
  - Listing 29.16 - An app that dynamically selects a module implementation.
- CONFIGURING WITH SCALA CODE
- 29.6 TRACKING MODULE INSTANCES
  - Listing 29.17 - Using a singleton type.
- 29.7 CONCLUSION
  - Footnotes for Chapter 29:
- Chapter 30
Object Equality
- 30.1 EQUALITY IN SCALA
- 30.2 WRITING AN EQUALITY METHOD
- 30.3 DEFINING EQUALITY FOR PARAMETERIZED TYPES
  - Listing 30.3 - Hierarchy for binary trees.
  - Listing 30.4 - A parameterized type with equals and hashCode.
- 30.4 RECIPES FOR EQUALS AND HASHCODE
  - Recipe for equals
    - Listing 30.5 - Class Rational with equals and hashCode.
  - Recipe for hashCode
- 30.5 CONCLUSION
  - Footnotes for Chapter 30:
- Chapter 31
Combining Scala and Java
- 31.1 USING SCALA FROM JAVA
- 31.2 ANNOTATIONS
- 31.3 WILDCARD TYPES
- 31.4 COMPILING SCALA AND JAVA TOGETHER
- 31.5 JAVA 8 INTEGRATION IN SCALA 2.12
  - Lambda expressions and "SAM" types
  - Using Java 8 Streams from Scala 2.12
- 31.6 CONCLUSION
  - Footnotes for Chapter 31:
- Chapter 32
Futures and Concurrency
- 32.1 TROUBLE IN PARADISE
- 32.2 ASYNCHRONOUS EXECUTION AND TRYS
  - Figure 32.1 - Class hierarchy for Try.
- 32.3 WORKING WITH FUTURES
- 32.4 TESTING WITH FUTURES
  - Listing 32.1 - Returning a future assertion to ScalaTest.
- 32.5 CONCLUSION
  - Footnotes for Chapter 32:
- Chapter 33
Combinator Parsing
- 33.1 EXAMPLE: ARITHMETIC EXPRESSIONS
  - Listing 33.1 - An arithmetic expression parser.
- 33.2 RUNNING YOUR PARSER
- 33.3 BASIC REGULAR EXPRESSION PARSERS
  - Listing 33.2 - A regular expression parser for Java identifiers.
- 33.4 ANOTHER EXAMPLE: JSON
  - Listing 33.3 - Data in JSON format.
  - Listing 33.4 - A simple JSON parser.
- 33.5 PARSER OUTPUT
  - Listing 33.5 - A full JSON parser that returns meaningful results.
  - Table 33.1 - Summary of parser combinators
- TURNING OFF SEMICOLON INFERENCE
  - Symbolic versus alphanumeric names
- CHOOSING BETWEEN SYMBOLIC AND ALPHABETIC NAMES
- 33.6 IMPLEMENTING COMBINATOR PARSERS
- 33.7 STRING LITERALS AND REGULAR EXPRESSIONS
- 33.8 LEXING AND PARSING
- 33.9 ERROR REPORTING
- 33.10 BACKTRACKING VERSUS LL(1)
- 33.11 CONCLUSION
  - Footnotes for Chapter 33:
- Chapter 34
GUI Programming
- Figure 34.1 - A simple Swing application: initial (left) and resized (right).
- 34.1 A FIRST SWING APPLICATION
  - Listing 34.1 - A simple Swing application in Scala.
- 34.2 PANELS AND LAYOUTS
  - Figure 34.2 - A reactive Swing application: initial (left) after clicks (right).
  - Listing 34.2 - Component assembly on a panel.
- 34.3 HANDLING EVENTS
- 34.4 EXAMPLE: CELSIUS/FAHRENHEIT CONVERTER
- 34.5 CONCLUSION
  - Footnotes for Chapter 34:
- Chapter 35
The SCells Spreadsheet
- Figure 35.1 - A simple spreadsheet table.
- 35.1 THE VISUAL FRAMEWORK
  - Listing 35.1 - Code for spreadsheet in Figure 35.1.
  - Listing 35.2 - The main program for the spreadsheet application.
- 35.2 DISCONNECTING DATA ENTRY AND DISPLAY
- 35.3 FORMULAS
  - Listing 35.5 - Classes representing formulas.
- 35.4 PARSING FORMULAS
  - Listing 35.6 - A spreadsheet that parses formulas.
  - Figure 35.3 - Cells displaying their formulas.
- 35.5 EVALUATION
  - Listing 35.7 - The evaluate method of trait Evaluator.
- 35.6 OPERATION LIBRARIES
  - Listing 35.8 - A library for arithmetic operations.
  - Figure 35.4 - Cells that evaluate.
- 35.7 CHANGE PROPAGATION
  - Listing 35.9 - The finished spreadsheet component.
- 35.8 CONCLUSION
  - Footnotes for Chapter 35:
- Appendix A
Scala Scripts on Unix and Windows
Glossary
Bibliography
About the Authors

Navigation menu