Index

Search in book...
Toggle Font Controls
Create new playlist

Name your new playlist

Playlist description (optional)
Sign In

Email address

Password

Forgot Password?

or

Continue with Facebook

Continue with Google
Sign Up

Full Name

Email address

Confirm Email Address

Password

or

Continue with Facebook

Continue with Google

Index

A note on the digital index

A link in an index entry is displayed as the section title in which that entry appears. Because some sections have multiple index markers, it is not unusual for an entry to have several links to the same section. Clicking on any link will take you directly to the place in the text in which the marker appears.

Symbols

! (exclamation point)

! method, sending messages to Actors, A Taste of Concurrency, Syntactic Sugar, Sending Messages to Actors
!! method, sending messages to Actors, Effective Actors
!= (not equal) method, The == and != Methods
!= (not equal) operator, Conditional Operators
encoding in Java identifiers, Scala Names in Java Code
operator precedence, Precedence Rules

" " (quotation marks, double)

enclosing string literals, String Literals
escaping in character literals, Character Literals
triples of double quotes, bounding multi-line string literals, String Literals

# (pound sign)

encoding in Java identifiers, Scala Names in Java Code
use in type projections, Reserved Words

$ (dollar sign) in identifiers, Operator? Operator?

% (percent sign)

encoding in Java identifiers, Scala Names in Java Code
operator precedence, Precedence Rules

& (ampersand)

&& (and) operator, Conditional Operators
encoding in Java identifiers, Scala Names in Java Code
operator precedence, Precedence Rules

' ' (quotation marks, single)

enclosing character literals, Character Literals
in symbol literals, Symbol Literals

( ) (parentheses)

capture groups in regular expressions, Matching on Regular Expressions
in method invocations, dropping, Operator? Operator?
omitting for by-name function parameter, Call by Name, Call by Value
omitting in method definitions, When Accessor Methods and Fields Are Indistinguishable: The Uniform Access Principle
omitting in method invocations, Methods Without Parentheses and Dots
substituting curly braces for in method call, A Taste of Concurrency

* (asterisk)

multiplication operator, encoding in Java identifiers, Scala Names in Java Code
operator precedence, Precedence Rules
zero or more repetitions in production rule, A Payroll External DSL

+ (plus sign)

++ method, appending to lists, Precedence Rules
encoding in Java identifiers, Scala Names in Java Code
operator precedence, Precedence Rules
specifying at least one repetition in production rule, A Payroll External DSL
variance annotations, Variance Under Inheritance, Variance Under Inheritance

- (minus sign)

encoding in Java identifiers, Scala Names in Java Code
operator precedence, Precedence Rules
variance annotations, Variance Under Inheritance, Variance Under Inheritance

-> (right arrow) operator, Tuples

. (dot)

infix operator notation, Infix Operator Notation
omitting in method calls, Operator? Operator?, Methods Without Parentheses and Dots
period-delimited path expressions, path.x

/ (slash)

/* */ in multi-line comments, A Taste of Scala
// in single-line comments, A Taste of Scala
division operator, encoding in Java identifiers, Scala Names in Java Code
operator precedence, Precedence Rules

: (colon)

:: (constructor) method

extracting head and tail of list, Matching on Sequences
prepending to a list, Precedence Rules

:: class, A Closer Look at Lists

: (foldRight) and :/ (foldLeft), Folding and Reducing

encoding in Java identifiers, Scala Names in Java Code

methods ending in, right-associative invocation, Precedence Rules

operator precedence, Precedence Rules

separator between identifiers and type annotations, A Taste of Scala, Reserved Words

; (semicolon)

ending production rule definitions, A Payroll External DSL
ending statements in Scala code, Semicolons
separators in for expression, Filtering

< > (angle brackets)

< (less than) operator, Conditional Operators

encoding in Java identifiers, Scala Names in Java Code

<% indicating view bound in type declaration, Reserved Words, Views and View Bounds

<- (left-arrow) operator, generators, Reserved Words, A Dog-Simple Example, Generator Expressions

<:, use in parameterized and abstract type declarations, Reserved Words

> (greater than) operator, Conditional Operators

encoding in Java identifiers, Scala Names in Java Code

>:, constraining allowed types in parameterized and abstract type declarations, Reserved Words

in method names, A Taste of Scala

operator precedence, Precedence Rules

= (equals sign)

== (equals) method, The == and != Methods

== (equals) operator, Conditional Operators, Case Classes

=> in function literals, Reserved Words

assignment operator, Reserved Words

encoding in Java identifiers, Scala Names in Java Code

in method definitions, A Taste of Scala, Method Declarations

missing, Inferring Type Information

operator precedence, Precedence Rules

? (question mark)

encoding in Java identifiers, Scala Names in Java Code

@ (at sign)

encoding in Java identifiers, Scala Names in Java Code
extracting value of XML attributes, Exploring XML
marking annotations, Reserved Words

[ ] (square brackets)

enclosing optional items in parser grammar, A Payroll External DSL
use with parameterized types, A Taste of Scala, Inferring Type Information, Abstract Types And Parameterized Types

(backslash)

in character escape sequences, Character Literals
encoding in Java identifiers, Scala Names in Java Code
escaping double quotes in string literals, String Literals
projection functions, Exploring XML
and \ operators for document structures, Syntactic Sugar

^ (caret)

encoding in Java identifiers, Scala Names in Java Code
operator precedence, Precedence Rules

_ (underscore)

in identifiers, Operator? Operator?
method chaining and function-literal shorthands, A Taste of Scala
placeholder in imports, function literals, etc., A Taste of Scala, Reserved Words
reserved word, Operator? Operator?
wildcard character in Scala, A Taste of Concurrency, Importing Types and Their Members, A Simple Match

`` (back quotes) in literals, Operator? Operator?

{ } (curly braces)

enclosing class body, A Taste of Scala
enclosing for expressions, Yielding
in method declarations, Method Declarations
substituting for parentheses in method call, A Taste of Concurrency
{ indicating more code on next line, Semicolons

| (vertical bar)

encoding in Java identifiers, Scala Names in Java Code
operator precedence, Precedence Rules
or case in parser grammar, A Scala Implementation of the External DSL Grammar
|| (or) operator, Conditional Operators

~ (tilde)

case class defined by Parsers trait, A Scala Implementation of the External DSL Grammar
encoding in Java identifiers, Scala Names in Java Code
~, ~>, and <~ combinator operators, A Scala Implementation of the External DSL Grammar

A

abstract classes, A Taste of Concurrency

abstract keyword, Stackable Traits

abstract type members, Introducing Scala, Overriding Members of Classes and Traits

overriding abstract methods, Overriding Abstract and Concrete Methods

abstract types, Abstract Types And Parameterized Types, Understanding Abstract Types–Parameterized Types Versus Abstract Types

combined with self-type annotations, Mixin Composition
defined, Glossary
overriding, Overriding Abstract Types–Overriding Abstract Types
parameterized types versus, Parameterized Types Versus Abstract Types

abstraction, Glossary

access modifier keywords, Visibility Rules

Actors, Introducing Scala, Actors–Effective Actors

in abstract, Actors in Abstract
Actor class, Actors in Scala
Actor class and object, A Taste of Concurrency
Actor model of concurrency, Glossary
defined, Glossary
effective use of, Effective Actors
example, A Taste of Concurrency–A Taste of Concurrency
example using sleeping barber problem, Actors in Depth–Actors in Depth
factory method for creating, Actors in Scala
mailbox, The Mailbox
methods, listed, Effective Actors
sending messages to, Sending Messages to Actors
shortcut operators used with, Syntactic Sugar
using with MINA NIO and Naggati library for SMTP server, Events–Events

actors.maxPoolSize system property, Events

advice (in AOP), AspectJ

alternative composition, A Payroll External DSL

and operator (&&), Conditional Operators

annotated types, Annotated Types, Annotated Types, Glossary

Annotation class, Annotations

Scala annotations derived from, Annotations

annotations, Annotations–Annotations

advantages and disadvantages of, Thoughts On Annotations and Enumerations
available only in Scala version 2.8 or later, Annotations
defined, Glossary
nesting, Annotations
Scala annotations derived from Annotation, Annotations
Scala annotations derived from StaticAnnotation, Annotations
@scala.reflect.BeanProperty, JavaBean Properties, The Spring Framework

anonymous classes

creating, Traits As Mixins

Ant, Scala plugin for, Build Tools

Any class, Parent Classes

!= (not equal) method, The == and != Methods
== (equals) method, The == and != Methods

Any object, The Scala Type Hierarchy

AnyRef class

== (equals) method, The == and != Methods
eq and ne methods, The ne and eq Methods

AnyRef object, The Scala Type Hierarchy

direct and indirect subtypes, The Scala Type Hierarchy
reflection methods, Reflecting on Types

AnyVal object, The Scala Type Hierarchy

direct subtypes, The Scala Type Hierarchy

AnyVal types, conversion to Java primitives, AnyVal Types and Java Primitives

AOP (see aspect-oriented programming)

Apache MINA, Events

application design, Application Design–Recap and What’s Next

annotations, Annotations–Annotations
Design by Contract, Better Design with Design By Contract
design patterns, Design Patterns–Dependency Injection in Scala: The Cake Pattern
effective trait design, Effective Design of Traits–Effective Design of Traits
enumerations versus case classes and pattern matching, Thoughts On Annotations and Enumerations
enumerations versus pattern matching, Enumerations Versus Pattern Matching–Enumerations Versus Pattern Matching
exceptions and alternatives, Exceptions and the Alternatives
nulls versus Options, Using Nulls Versus Options
scalable abstractions, Scalable Abstractions

applications, Glossary

apply method, Apply–Apply

for collections, Apply and UnapplySeq for Collections
objects with, considered as functions, Function Types

arity, Glossary

Array class

apply method, Apply
sameElements method, Array Equality and the sameElements Method

Array object, apply method overloaded for AnyVal and AnyRef types, Upper Type Bounds

ArrayBuffer object, Mapping

arrays, comparing for equality, Array Equality and the sameElements Method

arrow operator (<-), A Dog-Simple Example, Generator Expressions

ArrowAssoc class, The Predef Object

aspect-oriented programming (AOP), Introducing Traits, AspectJ

defined, Glossary

AspectJ library, AspectJ–AspectJ, Glossary

AtomFeed class (example), A Real-World Example

attributes, Class and Object Basics, Glossary

auxiliary constructors, Constructors in Scala, Glossary

B

bang method (see ! (exclamation point), under Symbols)

base classes, Parent Classes

base type, Glossary

BDD (Behavior-Driven Development), Domain-Specific Languages

BDD syntax provided by ScalaTest, ScalaTest
defined, Glossary
specification exercising combined Button and Subject types, Traits As Mixins
Specs library, Specs–Specs

BigDecimal class, Internal DSLs

blogging system (example), A Real-World Example–A Real-World Example

AtomFeed class, A Real-World Example

boolean literals, Boolean Literals

bound variables, Glossary

break method, Generator Expressions

build tools, Build Tools

Buildr tool, Build Tools

by-name parameters, Call by Name, Call by Value, Views and View Bounds

defined, Glossary

by-value parameters, Call by Name, Call by Value

defined, Glossary

C

C#

abstract methods, A Taste of Concurrency
override keyword for concrete methods, A Taste of Concurrency
this keyword, A Taste of Concurrency

C++

multiple inheritance, Effective Design of Traits
templates, Annotations

C.super type, C.super

C.this type, C.this

Cake Pattern, Dependency Injection in Scala: The Cake Pattern–Dependency Injection in Scala: The Cake Pattern

call site (see declaration site)

call-by-name parameters, Function Types

capture groups, defining in regular expressions, Matching on Regular Expressions

case classes, Case Classes–Case Class Inheritance

binary operations, Syntactic Sugar for Binary Operations
copy method in Scala 2.8, The copy Method in Scala Version 2.8
defined, Glossary
defining for pattern matching, Matching on Case Classes
enumerations as alternative to, Enumerations Versus Pattern Matching
enumerations versus, Thoughts On Annotations and Enumerations
inheritance, Case Class Inheritance, The Visitor Pattern: A Better Alternative
pattern matching on, Matching on Case Classes

case clauses, binding nested variables in, Binding Nested Variables in Case Clauses

case keyword, Glossary

case class example, Case Classes

case objects, Actors in Depth

case statements

pattern matching versus, A Simple Match

cases in pattern matching, Matching on Tuples (and Guards)

unreachable case, A Simple Match

character literals, Character Literals

characters

operator characters, encoding in Java, Scala Names in Java Code
used in identifiers, Operator? Operator?

child types, Glossary

class keyword, A Taste of Scala, Class and Object Basics

classes

abstract, A Taste of Concurrency, Abstract Types And Parameterized Types
adding new methods to, Implicit Conversions
basics of, Basic Object-Oriented Programming in Scala
declaration of classes as singletons, Classes and Objects: Where Are the Statics?
defined, Glossary
derived, overriding vals declared in parent classes, Variable Declarations
JDK and .NET, use in Scala, Installing Scala
nested, Nested Classes
overriding abstract and concrete fields in, Overriding Abstract and Concrete Fields in Classes
overriding abstract and concrete methods, Overriding Abstract and Concrete Methods
parent, Class and Object Basics
sealed class hierarchies, Sealed Class Hierarchies–Sealed Class Hierarchies
traits versus, Class or Trait?
Upper class (example), A Taste of Scala

ClassfileAnnotation class, Annotations

Clickable trait (example), Stackable Traits

clients, Glossary

closures, Function Literals and Closures

defined, Introducing Scala, Glossary

CLR (Common Language Runtime), Scala running on, Introducing Scala

code examples in this book, Getting the Code Examples, For More Information

code, organizing in files and namespaces, Organizing Code in Files and Namespaces

codec for SMTP (example), Events

collections

apply and unapplySeq methods, Apply and UnapplySeq for Collections
mutable and immutable, The Scala Type Hierarchy

command-line tools, Command-Line Tools–The fsc Command-Line Tool

information on, For More Information
sbaz, The sbaz Command-Line Tool
scala, The scala Command-Line Tool–Limitations of scala versus scalac
scalac, scalac Command-Line Tool
scaladoc, The scaladoc Command-Line Tool
scalap, javap, and jad, The scalap, javap, and jad Command-Line Tools

comments, A Taste of Scala, Glossary

companion classes, Companion Objects

defined, Glossary

companion objects, Companion Objects–Companion Objects and Java Static Methods

apply and unapplySeq methods for collections, Apply and UnapplySeq for Collections
apply method, Apply–Apply
conversion methods defined in, Implicit Conversions
creation for case classes, Case Classes
defined, Glossary
Java static methods and, Companion Objects and Java Static Methods
Map and Set, The Predef Object
methods defined in, visibility to Java code, Using Scala Functions in Java
Pair object for Pair class, The Predef Object
unapply method, Unapply–Unapply

compiled, command-line tool, converting script to, A Taste of Scala

compiler (see scalac compiler)

compiling versus interpreting, A Taste of Scala

component model, functional programming and, Recap: Functional Component Abstractions

components

defined, Scalable Abstractions, Glossary
fine-grained visibility rules in Scala, Fine-Grained Visibility Rules
implementing as traits, Dependency Injection in Scala: The Cake Pattern

compound types, Compound Types

defined, Glossary

comprehensions, Scala for Comprehensions

concrete types, Glossary

concurrency, A Taste of Concurrency–A Taste of Concurrency

Actor model of, Glossary

event-based, Glossary

Java and, If You Are a Java Programmer…

problems of shared, synchronized state, The Problems of Shared, Synchronized State

traditional, using threading and events, Traditional Concurrency in Scala: Threading and Events–Events

events, Events–Events
one-off threads, One-Off Threads
using java.util.concurrent, Using java.util.concurrent

using Actors, Actors–Effective Actors

Actors in abstract, Actors in Abstract
Actors in Scala, Actors in Scala–Effective Actors

conditional operators, Conditional Operators

Console.println( ) method, A Taste of Scala

constant identifiers, Operator? Operator?

constants

default argument values, Method Default and Named Arguments (Scala Version 2.8)
defining, Classes and Objects: Where Are the Statics?

constructors, A Taste of Concurrency, Constructors in Scala–Calling Parent Class Constructors

case class, Case Classes
constraints on, advantages and disadvantage of, Constructors in Scala
parent class constructors, calling, Calling Parent Class Constructors

context-free grammars, External DSLs with Parser Combinators, Glossary

contract, Variance Under Inheritance

defined, Glossary

contractual constraints in Design by Contract, Better Design with Design By Contract

contravariance or contravariant, Glossary

contravariant subclassing, Variance Under Inheritance

covariance or covariant, Glossary

covariant specialization, Self-Type Annotations and Abstract Type Members

covariant subclassing, Variance Under Inheritance

@cps (continual passing style) annotation, Annotations

cross-cutting concerns, Glossary

cross-platform installer (lzPack), Installing Scala

curried functions, Currying, Function Types

currying, Glossary

D

data types, The Scala Type System–Recap and What’s Next

abstract, Abstract Types And Parameterized Types, Understanding Abstract Types

parameterized types versus, Parameterized Types Versus Abstract Types

AnyVal types, conversion to Java primitives, AnyVal Types and Java Primitives

defined, Glossary

documentation for Scala type system, Recap and What’s Next

existential types, Existential Types

importing types and their members, Importing Types and Their Members

inferring type information, Inferring Type Information–Inferring Type Information

infinite data structures and lazy vals, Infinite Data Structures and Laziness

Nothing and Null, Nothing and Null

parameterized types, Abstract Types And Parameterized Types, Understanding Parameterized Types

path-dependent types, Path-Dependent Types

pattern matching on type, Matching on Type

reflection, Reflecting on Types

Scala’s sophisticated type system, Introducing Scala

self-type annotations, Self-Type Annotations–Self-Type Annotations

static versus dynamic typing, If You Are a Ruby, Python, etc. Programmer…

structural types, Traits As Mixins, Structural Types

type bounds, Type Bounds–Views and View Bounds

type hierarchy in Scala, The Scala Type Hierarchy

value types, Value Types–Self-Type Annotations

variance under inheritance, Variance Under Inheritance

variance in Scala versus Java, Variance In Scala Versus Java–Variance In Scala Versus Java
variance of mutable types, Variance of Mutable Types

decimal integer literals, Integer Literals

declaration site, Variance Under Inheritance, Glossary

declarations

annotations in, Annotations–Annotations
order of declaration, traits and, Stackable Traits
visibility modifiers in, Visibility Rules

declarative composition of traits, Stackable Traits

declarative programming, Glossary

decompilers (scalap, javap, and jad), The scalap, javap, and jad Command-Line Tools

deep matching, Matching on Case Classes

def keyword, A Taste of Scala, Method Declarations

default argument value, Glossary

definitions, method, Method Declarations

dependency injection (DI)

defined, Glossary
Spring Framework, The Spring Framework
using Cake Pattern, Dependency Injection in Scala: The Cake Pattern–Dependency Injection in Scala: The Cake Pattern

derived types, Glossary

access to members of parent types, Visibility Rules

Design by Contract, Variance Under Inheritance, Better Design with Design By Contract

BankAccountSpec object (example), Better Design with Design By Contract
defined, Glossary

design patterns, Design Patterns–Dependency Injection in Scala: The Cake Pattern, Glossary

alternative to Visitor Pattern, The Visitor Pattern: A Better Alternative–Dependency Injection in Scala: The Cake Pattern
dependency injection (DI) implementation, Cake Pattern, Dependency Injection in Scala: The Cake Pattern–Dependency Injection in Scala: The Cake Pattern

diamond of death (problem with multiple inheritance), Effective Design of Traits

do-while loops, Scala do-while Loops

documentation

Scala tools and APIs, For More Information
Scala type system, Recap and What’s Next

DSLs (Domain-Specific Languages), Domain-Specific Languages, Domain-Specific Languages in Scala–Recap and What’s Next

benefits and drawbacks of, Domain-Specific Languages in Scala

defined, Glossary

external DSLs with parser combinators, External DSLs with Parser Combinators–Generating Paychecks with the External DSL

generating paychecks with external DSL, Generating Paychecks with the External DSL–Generating Paychecks with the External DSL
parser combinators, About Parser Combinators
payroll external DSL, A Payroll External DSL–A Payroll External DSL
Scala implementation of external DSL grammar, A Scala Implementation of the External DSL Grammar–A Scala Implementation of the External DSL Grammar

internal DSL for payroll application (example), Internal DSLs–Internal DSLs: Final Thoughts

apply methods, Apply Methods
implicit conversions and user-defined types, Implicit Conversions and User-Defined Types
infix operator notation, Infix Operator Notation
payroll API, Internal DSLs–A Payroll Internal DSL
payroll internal DSL, A Payroll Internal DSL
payroll rules DSL implementation, Payroll Rules DSL Implementation–Payroll Rules DSL Implementation

internal versus external, Internal Versus External DSLs: Final Thoughts

duck typing, Structural Types

defined, Glossary

dynamic typing, Glossary

versus static typing, If You Are a Ruby, Python, etc. Programmer…

dynamically typed languages, If You Are a Ruby, Python, etc. Programmer…

E

eager matching, A Simple Match

EBNF (Extended Backus-Naur Form) grammar notation, External DSLs with Parser Combinators

external payroll DSL grammar, A Payroll External DSL

Eclipse IDE

developing Scala applications, Developing Scala applications
installing Scala plugin, Eclipse

Eiffel language, Better Design with Design By Contract

Either object, The Scala Type Hierarchy

else clause (if statements), Scala if Statements

Emacs editor, Text Editors

encapsulation

defined, Glossary
visibility rules and, Visibility Rules

Ensuring class, Better Design with Design By Contract

enumerated types, Enumerations

Enumeration class, Enumerations

Enumeration.Value class, Enumerations Versus Pattern Matching

enumerations, Enumerations, Enumerations Versus Pattern Matching–Enumerations Versus Pattern Matching

advantages and disadvantages of, Thoughts On Annotations and Enumerations
case classes and pattern matching versus, Thoughts On Annotations and Enumerations
HttpMethod object (example), Enumerations Versus Pattern Matching–Enumerations Versus Pattern Matching
scala.Enumeration class, Enumerations Versus Pattern Matching

eq method (AnyRef), The ne and eq Methods

equality of objects, Equality of Objects

equals method, The equals Method

case class comparisons, Case Class Inheritance

equals operator (==), Conditional Operators

events, Glossary

using for concurrency, Events–Events, Glossary

exception handling, pattern matching using try, catch, and finally clauses, Using try, catch, and finally Clauses

exceptions

@throws annotation and, Annotations
@unchecked annotation and, Annotations
and alternatives to, Exceptions and the Alternatives
throwing, Using try, catch, and finally Clauses

executing a script, A Taste of Scala

existential types, Views and View Bounds, Existential Types

defined, Glossary
examples of, Existential Types

expectations, Specs

exponentials with floating-point literals, Floating-Point Literals

expressions

for expression, Scala for Comprehensions
if statements as, Scala if Statements

extends keyword, Traits As Mixins, Parent Classes

external DSLs, Domain-Specific Languages in Scala, External DSLs with Parser Combinators

(see also DSLs)
internal DSLs versus, Internal Versus External DSLs: Final Thoughts

extractors, Glossary

translating regular expression capture groups to, Matching on Regular Expressions
unapply methods, Unapply
use in pattern matching case statements, Case Classes

F

factory methods, apply method as, Apply

family polymorphism, Self-Type Annotations and Abstract Type Members

Fibonacci sequence, calculating, Infinite Data Structures and Laziness

fields, Class and Object Basics

comparison to Java class-level, Classes and Objects: Where Are the Statics?
defined, Glossary
indistinguishable from accessor methods, overriding, When Accessor Methods and Fields Are Indistinguishable: The Uniform Access Principle–When Accessor Methods and Fields Are Indistinguishable: The Uniform Access Principle
mutable, A Taste of Concurrency
order of initialization, using lazy vals, Lazy Vals
overriding abstract and concrete fields, Overriding Abstract and Concrete Fields
overriding abstract and concrete fields in classes, Overriding Abstract and Concrete Fields in Classes
overriding abstract and concrete fields in traits, Overriding Abstract and Concrete Fields in Traits–Overriding Abstract and Concrete Fields in Traits
referencing object field, Classes and Objects: Where Are the Statics?
visibility and access to, Visibility Rules

filtering

in for expressions, Filtering
in functional programming, Filtering

final declarations, attempting to override, Attempting to Override final Declarations

final keyword, Glossary

finishing problem (in DSL design), Internal DSLs: Final Thoughts

first class, Glossary

floating-point literals, Floating-Point Literals

fluent interface, Payroll Rules DSL Implementation

folding data structures, Folding and Reducing–Folding and Reducing

for comprehensions, Scala for Comprehensions–Expanded Scope

expanded variable scope, Expanded Scope
filters in, Filtering
simple example, A Dog-Simple Example
using Options with, Options and for Comprehensions
yielding collections, Yielding
yielding successive blocks of dynamically formatted XML, A Real-World Example

foreach method, Traits As Mixins

traversal operations in functional programming, Traversal

formal parameters, Glossary

FP (see functional programming)

free variables, Glossary

fsc (fast scala compiler) tool, The fsc Command-Line Tool

function literals, Traits As Mixins

closures and, Function Literals and Closures
defined, A Taste of Scala, Glossary
passing to foreach, A Taste of Scala
passing to method for pattern matching, A Taste of Concurrency

function types, Function Types

defined, Glossary

Function.curried method, Currying

Functional Java project, ScalaCheck

functional programming, Functional Programming in Scala–Recap: Functional Component Abstractions, Glossary

call by name and call by value, Call by Name, Call by Value

component model and, Recap: Functional Component Abstractions

currying, Currying

data structures, Functional Data Structures

lists, Lists in Functional Programming
maps, Maps in Functional Programming

definition of, What Is Functional Programming?

filtering operations, Filtering

folding and reducing operations, Folding and Reducing–Folding and Reducing

functions in mathematics, Functions in Mathematics

implicit conversions, Implicits

implicit function parameters, Implicit Function Parameters

implicits, caution with, Final Thoughts on Implicits

lazy vals, Lazy Vals

mapping operations, Mapping

mixed paradigm in Scala, Introducing Scala

Options object, Functional Options

partial functions, Partial Functions

pattern matching, Pattern Matching

recursion, Recursion

in Scala, Functional Programming in Scala–Purity Inside Versus Outside

function literals and closures, Function Literals and Closures

tail calls and tail-call optimization, Tail Calls and Tail-Call Optimization

traversal of data structures, Traversal

variables, immutable values of, Variables that Aren’t

FunctionN object, The Scala Type Hierarchy

defining traits for, Function Types
variance under inheritance, Variance Under Inheritance

functions, Functional Programming in Scala

(see also functional programming)
defined, Glossary
higher order, Functions in Mathematics, Glossary
overloaded, Glossary
Scala, using in Java, Using Scala Functions in Java

futures, Effective Actors

G

Gang of Four (GOF) patterns, Design Patterns

generator expressions, Generator Expressions

generators

<- (left-arrow) operator, A Dog-Simple Example
defined, Glossary
in for comprehensions, Options and for Comprehensions

generics, Introducing Scala, Java and Scala Generics–Java and Scala Generics

defined, Glossary

Java, Abstract Types And Parameterized Types

using from Scala, Java and Scala Generics

Scala, using from Java, Java and Scala Generics

variance under inheritance, differences between Java and Scala, Variance Under Inheritance

grammars

context-free, Glossary
EBNF notation for external payroll DSL grammar, A Payroll External DSL
parsing expression grammars (PEGs), Glossary

guards, pattern matching on, Matching on Tuples (and Guards)

H

Hadoop library, Hadoop
Haskell, QuickCheck tool, ScalaCheck
hexadecimal integer literals, Integer Literals
higher-order functions, Functions in Mathematics, Glossary

I

I/O (input/output)

automatic importation of methods by Scala, A Taste of Scala
NIO (non-blocking I/O), Events

identifiers, characters allowed in, Operator? Operator?

IDEs (integrated development environments), Integration with IDEs–Text Editors

Eclipse

developing Scala applications, Developing Scala applications
installing Scala plugin, Eclipse

IntelliJ

developing Scala applications, Developing Scala applications
installing Scala plugins, IntelliJ

NetBeans

developing Scala applications, Developing Scala applications
installing Scala plugins, NetBeans

text editors, Text Editors

if statements, Scala if Statements

immutable values, Glossary

immutable variables, Introducing Scala

declaring, Variable Declarations

imperative languages, A Taste of Concurrency

imperative programming, Glossary

implicit arguments, Glossary

implicit conversions

caution with, Final Thoughts on Implicits
defined, Glossary
defining custom object and conversion method, Implicit Conversions
in functional programming, Implicits
in internal DSL payroll implementation, Implicit Conversions and User-Defined Types
Int into RichInt, Generator Expressions
Predef.any2ArrowAssoc method, The Predef Object
rules for compiler to find and use conversion methods, Implicit Conversions

implicit function parameters, Implicit Function Parameters

caution with, Final Thoughts on Implicits

implicit keyword, Implicits

defined, Glossary

implicit typing, Glossary

import statements, A Taste of Concurrency

importing Java types and their members, Importing Types and Their Members
relative path used in, Imports are Relative

infinite data structures, Glossary

laziness and, Infinite Data Structures and Laziness
using lazy vals to manage, Lazy Vals

infix notation, Operator? Operator?

defined, Glossary

infix operator notation, Infix Operator Notation

infix types, Infix Types, Glossary

inheritance

case class, Case Class Inheritance
defined, Glossary
definition, Class or Trait?
linearization of object hierarchy, Linearization of an Object’s Hierarchy–Linearization of an Object’s Hierarchy
multiple, problems with, Effective Design of Traits
single inheritance plus traits in Scala, Effective Design of Traits
variance under, Variance Under Inheritance–Implementation Notes

instance, Class and Object Basics, Glossary

instantiate, Glossary

integer literals, Integer Literals

IntelliJ IDEA

developing Scala applications, Installing the Scala plugins
installing Scala plugins, IntelliJ

interactive mode, scala command, A Taste of Scala

@interface keyword (Java), Annotations

internal DSLs, Domain-Specific Languages in Scala, Internal DSLs: Final Thoughts

(see also DSLs)
external DSLs versus, Internal Versus External DSLs: Final Thoughts

interned strings, Symbol Literals

interpreter, starting, A Taste of Scala

interpreting versus compiling, A Taste of Scala

invariance and invariant, Glossary

invariant subclassing, Variance Under Inheritance

invariants, Better Design with Design By Contract

inversion of control (IoC), Dependency Injection in Scala: The Cake Pattern, Glossary

IOHandlerActorAdapter object, Events

Iterable object, Traversal

filtering methods, Filtering
fold and reduce methods, Folding and Reducing
map method, Mapping

Iterator Pattern, Design Patterns

J

jad tool, The scalap, javap, and jad Command-Line Tools

Java, If You Are a Java Programmer…

annotations, Annotations

aspect-oriented programming, AspectJ, Introducing Traits

DI (dependency injection), Dependency Injection in Scala: The Cake Pattern

importation of data types into Scala, Importing Types and Their Members

interfacing with type system, using existential types, Existential Types

invoking method name identical to Scala reserved word, Operator? Operator?

JDK (Java Development Kit), Introducing Scala

JVM (Java Virtual Machine), If You Are a Java Programmer…

reflection methods, Reflecting on Types

libraries, interoperability with Scala, Java Library Interoperability–Hadoop

AspectJ, AspectJ–AspectJ
Hadoop, Hadoop
Spring Framework, The Spring Framework
Terracotta, Terracotta

package concept for namespaces, Organizing Code in Files and Namespaces

regular expressions, Matching on Regular Expressions

Scala interoperability with, Java Interoperability–Scala Names in Java Code

AnyVal types and Java primitives, AnyVal Types and Java Primitives
Java and Scala generics, Java and Scala Generics
JavaBean properties, JavaBean Properties
Scala names in Java code, Scala Names in Java Code
using Scala functions in Java, Using Scala Functions in Java

static methods, companion objects and, Companion Objects and Java Static Methods–Companion Objects and Java Static Methods

static typing, If You Are a Ruby, Python, etc. Programmer…

variance, Variance In Scala Versus Java–Variance In Scala Versus Java

java command, scalac Command-Line Tool

java.io.IOException class, Annotations

java.lang.String class, Implicit Conversions

java.nio package, Events

java.util.concurrent package, Using java.util.concurrent

JavaBeans

conventions for, JavaBean Properties, The Spring Framework
vetoable events, Stackable Traits

javac compiler, Introducing Scala

Javadoc-style @return annotation, Generating Paychecks with the External DSL

javap tool, The scalap, javap, and jad Command-Line Tools

JavaRebel tool, JavaRebel

JavaTokenParsers, A Scala Implementation of the External DSL Grammar

JDK (Java Development Kit), Introducing Scala

join points, AspectJ

JUnit, Traits As Mixins

running specifications, Specs

JVM (Java Virtual Machine), If You Are a Java Programmer…

JVM version of Scala, Introducing Scala

installing, Installing Scala

L

lazy evaluation, infinite data structures and, Infinite Data Structures and Laziness

lazy values, Overriding Abstract and Concrete Fields in Traits, Lazy Vals

Post class (example), A Real-World Example

lazy, defined, Glossary

left-associative method invocations, Precedence Rules

libraries

Java library interoperability, Java Library Interoperability–Hadoop

AspectJ, AspectJ–AspectJ
Hadoop, Hadoop
Spring Framework, The Spring Framework
Terracotta, Terracotta

miscellaneous smaller Scala libraries, Miscellaneous Smaller Libraries

notable Scala libraries, Other Notable Scala Libraries and Tools

Lift web framework, Lift

linearization of object hierarchy, Linearization of an Object’s Hierarchy–Linearization of an Object’s Hierarchy, C.super, Glossary

algorithm for reference types, Linearization of an Object’s Hierarchy
hand calculation for C2 (example), Linearization of an Object’s Hierarchy

LinkedList class that uses Nodes (example), Views and View Bounds

Liskov Substitution Principle, Class or Trait?

List class

apply and unapplySeq methods, Apply and UnapplySeq for Collections
declaration, Abstract Types And Parameterized Types
Nil case object, Nothing and Null
Scala implementation, A Closer Look at Lists–A Closer Look at Lists

List object

apply method, parameterized, Parameterized Methods
folding, Folding and Reducing

lists in functional programming, Lists in Functional Programming

literals, Literals–Symbol Literals

boolean, Boolean Literals
character, Character Literals
defined, Glossary
floating-point, Floating-Point Literals
integer, Integer Literals
string, String Literals
symbol, Symbol Literals

load-time weaving, AspectJ

loops

do-while, Scala do-while Loops
for loops or comprehensions, Scala for Comprehensions–Expanded Scope
generator expressions in, Generator Expressions
looping through and matching XML, Looping and Matching XML
trampoline, Trampoline for Tail Calls
while, Scala while Loops

lower type bounds, Lower Type Bounds, Understanding Abstract Types

M

Mac OS X

installing Scala, Installing Scala
TextMate editor, Text Editors

mailbox for Actors, The Mailbox, Glossary

main method, A Taste of Scala, Glossary

Manifests, Manifests

Map companion object, The Predef Object

Map values, The Predef Object

Map.apply method, The Predef Object, Mapping

MapReduce, Hadoop, Glossary

maps in functional programming, Maps in Functional Programming

MatchError object, Sealed Class Hierarchies

mathematics, functions in, Functions in Mathematics

Maven build tool, Build Tools

members, Class and Object Basics, Glossary

importing, Importing Types and Their Members

memoization, Purity Inside Versus Outside, Glossary

support by packrat parsers, Internal Versus External DSLs: Final Thoughts

messages, Glossary

metadata, Annotations

(see also annotations)
adding to declarations, Annotations
default values and, Annotations

metaprogramming, The Seductions of Scala

MetaScala library, MetaScala

method chaining, Infix Operator Notation

methods, Class and Object Basics

abstract types as arguments, Parameterized Types Versus Abstract Types

adding new methods to classes, Implicit Conversions

class-level, Classes and Objects: Where Are the Statics?

declarations, Method Declarations–Nesting Method Definitions

default and named arguments, Method Default and Named Arguments (Scala Version 2.8)
nesting method definitions, Nesting Method Definitions

defined, Glossary

defining, A Taste of Scala

Java static methods and companion objects, Companion Objects and Java Static Methods–Companion Objects and Java Static Methods, Using Scala Functions in Java

operators as, Operator? Operator?

infix notation, Operator? Operator?

overriding, Overriding Abstract and Concrete Methods

overriding accessor methods indistinguishable from fields, When Accessor Methods and Fields Are Indistinguishable: The Uniform Access Principle–When Accessor Methods and Fields Are Indistinguishable: The Uniform Access Principle

parameterized, Parameterized Methods

without parentheses and dots, Methods Without Parentheses and Dots

operator precedence, Precedence Rules

referencing object method, Classes and Objects: Where Are the Statics?

Meyer, Bertrand, Better Design with Design By Contract

MINA (Apache), Events

events provided by, Events

mixin composition, Introducing Scala, Mixin Composition, Effective Design of Traits

using traits, Introducing Scala

mixins, Introducing Traits

defined, Glossary
invasive, Effective Design of Traits
traits as, Traits As Mixins–Traits As Mixins

modules

components and, Scalable Abstractions
contract of, Better Design with Design By Contract

multiple inheritance, Glossary

mutable fields, A Taste of Concurrency

mutable values, Glossary

N

Naggati library, Events

named arguments, Method Default and Named Arguments (Scala Version 2.8), Glossary

namespaces, Organizing Code in Files and Namespaces

relationship to Scala’s nested package syntax, Organizing Code in Files and Namespaces

ne method (AnyRef), The ne and eq Methods

nested classes, Nested Classes

.NET

invoking method name identical to Scala reserved word, Operator? Operator?
regular expressions, Matching on Regular Expressions

.NET version of Scala, Introducing Scala

NetBeans

developing Scala applications, Developing Scala applications
installing Scala plugins, NetBeans

new operator, A Taste of Scala

Nil case object, Nothing and Null

NIO (non-blocking I/O), Events

NioSocketAcceptor object, Events

NodeSeq class, and \ methods, Syntactic Sugar

NodeSeq object, Reading XML

None class, Option, Some, and None: Avoiding nulls

nonterminals, A Payroll External DSL, Glossary

Nothing type, Variance In Scala Versus Java, Nothing and Null

Null object, Nothing and Null

nulls

avoiding using Option, Some, and None classes, Option, Some, and None: Avoiding nulls–Option, Some, and None: Avoiding nulls
Options versus, Using Nulls Versus Options

O

object system (Scala), The Predef Object–Recap and What’s Next

classes and objects, Classes and Objects: Where Are the Statics?

package objects, Package Objects

linearization of object hierarchy, Linearization of an Object’s Hierarchy–Linearization of an Object’s Hierarchy

Predef object, The Predef Object

sealed class hierarchies, Sealed Class Hierarchies–Sealed Class Hierarchies

type hierarchy, The Scala Type Hierarchy

object-oriented programming (OOP), Basic Object-Oriented Programming in Scala

case classes, Case Classes–Case Class Inheritance
classes and objects, basics of, Basic Object-Oriented Programming in Scala
companion objects, Companion Objects–Companion Objects and Java Static Methods
constructors, Constructors in Scala–Calling Parent Class Constructors
defined, Glossary
equality of objects, Equality of Objects
mixed paradigm in Scala, Introducing Scala
nested classes, Nested Classes
overriding members of classes and traits, Advanced Object-Oriented Programming In Scala–When Accessor Methods and Fields Are Indistinguishable: The Uniform Access Principle
parent classes, Class and Object Basics
reusable software components and, Recap: Functional Component Abstractions
visibility rules, Visibility Rules–Final Thoughts on Visibility

objects

basics of, Basic Object-Oriented Programming in Scala

deep matching on contents, Matching on Case Classes

defined, Glossary

instantiation in Scala, Classes and Objects: Where Are the Statics?

in Scala, Introducing Scala

versus class-level members, A Taste of Scala

ObservableClicks trait (example), Stackable Traits

working with VetoableClicks trait (example), Stackable Traits

Observer Pattern, Traits As Mixins, Design Patterns

trait implementing, Traits As Mixins

octal integer literals, Integer Literals

Odersky, Martin, Introducing Scala, Introducing Scala

Open-Closed Principle (OCP), Sealed Class Hierarchies

violation by Visitor Pattern, The Visitor Pattern: A Better Alternative

operator characters, Operator? Operator?

defined, Glossary
encoding in Java identifiers, Scala Names in Java Code
in identifiers, Operator? Operator?

operator notation, Glossary

infix operator notation, Operator? Operator?, Infix Operator Notation

operator overloading, Glossary

operator precedence, Precedence Rules

operators, Operator? Operator?

conditional, Conditional Operators

Option class, Option, Some, and None: Avoiding nulls–Option, Some, and None: Avoiding nulls

alternatives to exceptions, Exceptions and the Alternatives
functional operations on, Functional Options
nulls versus, Using Nulls Versus Options
using with for comprehensions, Options and for Comprehensions

or operator (||), Conditional Operators

overloaded functions, Glossary

overloaded methods, Class and Object Basics

explicit return type requirement, Inferring Type Information

override keyword, A Taste of Concurrency, Traits As Mixins, Overriding Members of Classes and Traits

overriding class and trait members, Overriding Members of Classes and Traits–When Accessor Methods and Fields Are Indistinguishable: The Uniform Access Principle

abstract and concrete fields, Overriding Abstract and Concrete Fields

in classes, Overriding Abstract and Concrete Fields in Classes
in traits, Overriding Abstract and Concrete Fields in Traits–Overriding Abstract and Concrete Fields in Traits

abstract and concrete methods, Overriding Abstract and Concrete Methods

abstract types, Overriding Abstract and Concrete Fields in Classes–Overriding Abstract Types

accessor methods indistinguishable from fields, When Accessor Methods and Fields Are Indistinguishable: The Uniform Access Principle–When Accessor Methods and Fields Are Indistinguishable: The Uniform Access Principle

final declarations, Attempting to Override final Declarations

P

package objects, Package Objects, Glossary

packages, Organizing Code in Files and Namespaces

defining using nested package syntax in Scala, Organizing Code in Files and Namespaces
root package for Scala library classes, Organizing Code in Files and Namespaces

packrat parsers, Internal Versus External DSLs: Final Thoughts, Glossary

Pair class, The Predef Object

apply method, Apply

Pair object, The Predef Object

parameterized methods, Parameterized Methods

parameterized types, A Taste of Scala, Abstract Types And Parameterized Types, Understanding Parameterized Types

abstract types versus, Parameterized Types Versus Abstract Types
defined, Glossary
Manifests, Manifests
parameterized methods, Parameterized Methods
value types created from, Parameterized Types

parameters

constructor, initialization of vals and vars, Variable Declarations
implicit function parameters, Implicit Function Parameters
order of, named arguments and, Method Default and Named Arguments (Scala Version 2.8)
required return type annotations, Inferring Type Information

parent classes, Parent Classes, Glossary

parser combinators, external DSLs with, External DSLs with Parser Combinators–Generating Paychecks with the External DSL

generating paychecks with PayrollParserCombinators, Generating Paychecks with the External DSL–Generating Paychecks with the External DSL
payroll external DSL, A Payroll External DSL–A Payroll External DSL
Scala implementation of external DSL grammar, A Scala Implementation of the External DSL Grammar–A Scala Implementation of the External DSL Grammar

Parsers object, A Scala Implementation of the External DSL Grammar

documentation of composition operators, A Payroll External DSL
~ case class, A Scala Implementation of the External DSL Grammar

parsing expression grammars (PEGs), Internal Versus External DSLs: Final Thoughts, Glossary

partial application, Glossary

partial functions, Partial Functions, Glossary

path-dependent types, Path-Dependent Types, Glossary

C.super, C.super
C.this, C.this
p.Success case class (example), A Scala Implementation of the External DSL Grammar
period-delimited path expressions, path.x

pattern matching, A Taste of Concurrency, Pattern Matching–Concluding Remarks on Pattern Matching

binding nested variables in case clauses, Binding Nested Variables in Case Clauses
on case classes, Matching on Case Classes
defined, Glossary
on enumerations, Enumerations Versus Pattern Matching
extractors in case statements, Case Classes
in functional programming, Pattern Matching
matching on tuples and guards, Matching on Tuples (and Guards)
polymorphism versus, A Taste of Concurrency
on regular expressions, Matching on Regular Expressions
on sequences, Matching on Sequences
simple match of boolean values, A Simple Match
on type, Matching on Type
using on XML structures, Looping and Matching XML
using try, catch, and finally clauses, Using try, catch, and finally Clauses
using with case classes, enumerations versus, Thoughts On Annotations and Enumerations
variables in matches, Variables in Matches

pattern matching identifiers, Operator? Operator?

payroll external DSL (example), A Payroll External DSL–A Payroll External DSL

payroll internal DSL (example), A Payroll Internal DSL

PEGs (parsing expression grammars), Internal Versus External DSLs: Final Thoughts, Glossary

performance, Introducing Scala

Pimp My Library design pattern, Implicit Conversions, Glossary

plain identifiers, Operator? Operator?

pointcuts, AspectJ

polymorphism

family polymorphism, Self-Type Annotations and Abstract Type Members
pattern matching versus, A Taste of Concurrency, Concluding Remarks on Pattern Matching, Pattern Matching

postconditions, Better Design with Design By Contract, Glossary

postfix notation, Operator? Operator?, Glossary

@Pre annotation, Annotations

pre-initialized fields, Overriding Abstract and Concrete Fields in Traits

precedence, operator, Precedence Rules

preconditions, Better Design with Design By Contract, Glossary

Predef object, The Predef Object

any2ArrowAssoc method, The Predef Object
declaring types and exceptions, The Predef Object
documentation, The Predef Object
implicit conversion methods for value types, The Scala Type Hierarchy
items imported or defined by, The Predef Object
require and assume methods, using for contract enforcement, Better Design with Design By Contract
stringWrapper method, Implicit Conversions

primary constructor, Constructors in Scala, Glossary

primitive data types, Glossary