Symbols
! (invert)
on class
Boolean
! (message send)
on trait Actor
!= (not equals)
method on
Any
" (string delimiter)
""" (raw string delimiter)
@ (at sign)
in annotations
in patterns
to extract XML
attributes
& (bitwise-and)
on integral types
& (intersect)
on
Set traits
&& (logical-and)
on class Boolean
&~ (diff)
on Set traits
> (greater than)
on numeric types
>> (shift right)
on integral types
>>> (unsigned shift right)
on integral types
>: (lower bound)
>= (greater than or equal to)
on numeric types
< (less than)
on numeric types
<< (shift left)
on integral types
<- (in)
in for expressions
<: (upper bound)
<= (less than or equal to)
on numeric types
' (character delimiter)
() (empty parentheses)
on method definitions
shorthand for apply method invocation
() (unit value)
* (repeat)
on class String
* (repeated
parameter)
* (times)
on numeric types
+ (add element)
on
Map traits
on
Set traits
+ (covariant in)
variance annotation
List's type parameter
+ (plus)
on numeric types
++ (add elements)
on
Map traits
on
Set traits
on trait Iterator
on Traversable traits
++= (add elements to)
on trait
mutable.Map
on trait
mutable.Set
++= (append)
on trait Buffer
++=: (prepend)
on trait Buffer
+: (prepend)
on Seq traits
+= (add element to)
on trait
mutable.Map
on trait
mutable.Set
+= (add to)
on trait mutable.Set
reassignment with immutable sets and vars
+= (append)
on class ArrayBuffer
on class
ListBuffer
on trait Buffer
+=: (prepend)
on class ListBuffer
on trait Buffer
- (contravariant in)
variance annotation
- (minus)
on numeric types
- (remove element)
on
Map traits
on
Set traits
-> (map to)
in
implicit conversion
— (remove elements)
on
Map traits
on
Set traits
—= (remove elements from)
on trait
mutable.Map
on trait
mutable.Set
-= (remove element from)
on trait
mutable.Map
on trait
mutable.Set
on trait Buffer
/ (divided by)
on numeric types
/: (fold left)
on class List
on trait Iterator
on Traversable traits
: (colon)
in type annotations
:+ (append)
on Seq traits
:: (cons) class
as pattern constructor
subclass of List
:: (cons) method
on class
List
right associativity of
::: (concatenation)
on class
List
: (fold right)
on class List
on trait Iterator
on Traversable traits
; (semicolon)
inference
= (variable assignment)
=> (right arrow, or "rocket")
in function literals
in import statements
in self types
in match alternatives
in this aliasing
== (equals)
in set membership
== (equals)
in Scala versus Java
in-depth treatment
method on
Any
quick introduction
??? (unimplemented)
on object Predef
# (pound sign)
in inner class type names
% (remainder)
on numeric types
_ (underscore)
in curried functions
in function literals
in identifiers
in import statements
in wildcard types
in match expressions
used to initialize a field to its default value
_* (underscore asterisk)
in XML pattern
matching
repeated parameter
sequence
wildcard pattern
_1, _2, etc.(tuple accessors)
_= (underscore equals)
in setter method names
^ (exclusive-or)
on integral types
^^
(result conversion, or "eyebrows")
parser combinator
(bitwise complement)
on integral types
(sequential composition, or "squiggle")
parser combinator
! (committed sequential composition)
parser
combinator
> (sequential composition
right)
parser combinator
<
(sequential composition left)
parser combinator
(extract)
on class Elem
\ (deep extract)
on class Elem
| (alternative composition)
parser
combinator
parser combinator
| (bitwise-or)
on integral types
| (union)
on Set traits
|| (logical-or)
on class Boolean
{} (curly braces)
and variable scope
in class
definitions
in imports
in XML
patterns
in XML literals
instead of parentheses in method invocations
instead of parentheses in for expressions
` (back tick)
in constants
in identifiers
A
Abelson, Harold
abs method
on class Double (via RichDouble)
on class
Int (via
RichInt)
abstract
members
abstract modifier
not needed on abstract methods,
fields, or types
not needed on abstract methods, fields, or types
on classes
with override modifier on members of traits
abstract types
access modifiers
accessor methods
Actor trait
methods
! (message send)
actors
add method
on trait mutable.Set
addString method
on class List
on trait Iterator
on Traversable traits
Aho, Alfred
Akka
aliases
AnyRef for Object
type
aliasing
object,
see defensive copies
this
alphabetic versus symbolic names
alternatives
catch-all
definition of
in
match expressions
in catch clauses
in partial function literals
andThen method
on trait Future
annotations
and reflection
applied to expressions
arguments to
@BeanProperty
@deprecated
in meta-programming
Java-specific
@native
nested
@serializable
@SerialVersionUID
standard
syntax of
@tailrec
@Test
in JUnit 4
@throws
@transient
type
for debugging
@unchecked
used with named arguments
variance
@volatile
anonymous classes
anonymous functions,
see function literals
ANTLR
Any class
in Scala class hierarchy diagram
AnyRef class
as alias of Object
in Scala class hierarchy diagram
AnyVal class
in Scala class hierarchy diagram
App trait
application
function to arguments
partial function
applications, Scala
apply method
called with parentheses
in extractors
on
Array
class
object
on
List
class
object
on
Map
objects
traits
on object Future
on Seq objects
on Seq traits
on Set objects
on trait PartialFunction
on FunctionN traits
args variable
in scripts
arguments
command line, in scripts
named
variable length
versus parameters
arithmetic operations (
+,
-,
*,
/,
%)
on numeric types
Array class
ArrayBuffer class
arrays
accessed with () not []
converting to lists
creating and initializing
generic
passing elements as arguments with _*
quick introduction
asInstanceOf method
on class Any
assert method
on object
Predef
AssertionError
class
assertions
assignment
result is unit value
associativity
right versus left
attributes
XML
automatic
boxing
conversion,
see implicit conversion
imports
auxiliary constructors
B
backtracking
base classes,
see superclasses
BDD,
see behavior-driven development
BeanProperty annotation
BeanProperty annotation
behavior-driven
development
BigInt class
BigInteger class
binary compatibility
Bison
bitwise operations, on integral types
logical (&, |, ^, )
shift (<<, >>, >>>)
blank finals (Java)
not in Scala
Bloch, Joshua
blocks, definition of
Boolean class
boolean literals
bottom types
bound variables
boxing, of value types
Bracha, Gilad
break keyword (Java)
living without
not in match expressions
break method
on class Breaks
breakable method
on class Breaks
Breaks class
buffer
members
Buffer trait
methods
clear
clone
insert
insertAll
remove
trimEnd
trimStart
++=: (prepend)
++= (append)
+=: (prepend)
+= (append)
-= (remove element from)
buffered method
on trait Iterator
ButtonClicked class
by-name parameters
by-value parameters
Byte class
C
C
language
parser generators
C language
C++ language
C# language
enumerations
properties
static extension methods
camel casing
CanBuildFrom trait
capitalization, of identifiers
capitalize method
on class Int (via RichInt)
case
classes
case classes
versus extractors
cases,
see alternatives
casting,
see also toInt,
toChar,
etc.
with asInstanceOf
with typed patterns (the preferred style)
catch clauses
Cathedral and the Bazaar, The (Raymond)
chained package clauses
Char class
character encoding
in
XML
character literals
escape sequences
checked exceptions
Church, Alonzo
Class class,
see classOf method
class hierarchy diagram
for Try
for lists
for maps
for Scala
for sets
class parameters
initialization order compared to abstract fields
not legal on singleton
objects
used to implement abstract fields
classes
abstract
annotating
anonymous
case
companion
generic
implicit
inner,
see inner classes
nesting of
private
sealed
virtual
classOf method
on object Predef
clear method
on trait mutable.Map
on trait
mutable.Set
on trait Buffer
clone method
on trait mutable.Map
on trait mutable.Set
on trait Buffer
closures
versus Java's inner classes
code duplication
reducing
collect method
on trait Future
collect method
on trait Iterator
on Traversable traits
collections
api
architecture
conversion between Java and Scala
parallel
views of
combinators
companion
objects
companion classes
companion objects
and
implicit conversion
and factory methods
visibility
compare method
of trait
Ordered
compatibility, Scala with Java
compiler
errors
class ...needs to be abstract, since method ...in class ...of type ...is not
defined
compiler errors
overloaded method value ...with alternatives ...cannot be applied to ...
';' expected but ',' found
...is already defined as ...
...is not a legal prefix for a constructor
class ...is abstract; cannot be instantiated
class type required
constructor ...cannot be accessed in ...
could not find implicit value for parameter asTraversable
covariant type ...occurs in contravariant
position in type ...of parameter of setter ...
covariant type ...occurs in contravariant
position in type ...of value ...
error overriding
method ...in class ...of type ...method ...needs 'override' modifier
error overriding method ...in class ...of type ...method ...
cannot override final member
illegal inheritance from final class
inferred type arguments
...do not conform to method ...type parameter bounds ...
method ...overrides nothing
missing arguments for method ...follow this method with '_' if you want to
treat it as a partially applied function
no implicit argument
matching parameter type ...was found
no implicit argument matching parameter type ...was found
not found: value ...
overloaded method value ...with
alternatives ...cannot be applied to ...
pattern is unchecked since it is eliminated by erasure
reassignment to val
trait ...takes type parameters
type mismatch
10 11 12
unreachable code
value ...is not a member of ...
compiler warnings
match is not exhaustive
non variable type-argument ...
in type pattern is unchecked since it is eliminated by erasure
non variable type-argument ...in type pattern is unchecked since it is eliminated by erasure
Compilers: Principles, Techniques, and Tools (Aho, et. al.)
compiling
Scala and Java together
complete function
complete method
on trait Promise
completeWith method
on trait Promise
complexity, managing
Component class
composition
mixin,
see mixin composition
concat method
on object List
on Seq objects
conciseness
Scala versus Java
concurrency
actors model
and testing
futures
shared data and locks
concurrentmap
members
ConcurrentMap trait
methods
remove
replace
ConcurrentMap trait
methods
putIfAbsent
configuring
to wire modules together
with Scala code
cons (
::) method
on class
List
right
associativity of
short for construct
Console object
constant patterns
constants
constructor patterns
constructors
auxiliary
in Java versus Scala
invoking superclass
primary
private
Container
trait
contains method
on
Map traits
on Seq traits
on
Set traits
containsSlice method
on Seq traits
contents property
on trait Container
context bounds
context-free grammars
continue keyword (Java)
living without
contravariance
control abstraction
conventions, identifier capitalization
conversion
between Java and Scala collections
between mutable and immutable collections
implicit
to specific collection types
copyToArray method
on class List
on trait Iterator
on Traversable traits
copyToBuffer method
on trait Iterator
on Traversable traits
corresponds method
on Seq traits
count method
on class List
on trait Iterator
on Traversable traits
covariance
of arrays in Java
of function result type
of lists
creating and initializing
arrays
lists
maps
objects with factories
objects with new
sets
singleton objects
tuples
curly braces
and variable scope
in class definitions
in imports
in XML literals
in XML patterns
instead of parentheses in method invocations
instead of parentheses in for expressions
currying
D
data
structures
fully persistent
semi-structured
deadlock
deafTo method
on Reactor
declarations, versus definitions
decrementing
with
-= 1, not
—,
see incrementing
def keyword
annotating
default methods
in Java 8
default values
of fields
defensive copies
definitions, versus declarations
dependency injection
deprecated
annotation
dequeue method
on class Queue
DeRemer,
Frank
derived classes,
see subclasses
deserialization
XML
Design Patterns (Gamma, et. al.)
diff method
on Seq traits
on Set traits
Dijkstra, Edsger
distinct method
on Seq traits
divide and conquer principle
do-while loops
domain objects
Domain-Driven Design (Evans)
domain-specific languages
a little language for digital circuits
and implicit conversions
defining an external DSL with parser combinators
in Smalltalk and Lisp
parser combinators as an internal DSL
rich wrappers and
internal versus external DSLs
ScalaTest's matchers DSL
Double class
downloading
Scala
source code for book examples
drop method
on
class List
on class List
on trait Iterator
on Traversable traits
dropRight method
on class List
on Iterable traits
dropWhile method
on class List
on trait Iterator
on Traversable traits
DSLs,
see domain-specific languages
duplicate method
on trait Iterator
dynamic
binding
typing
E
Eckel, Bruce
Eclipse IDE
EditDone class
Effective Java, Second Edition (Bloch)
Effective C++ (Meyers)
Effective
Java, Second Edition (Bloch)
efficiency
and hash consing
of abstract classes versus traits
of arrays
of case classes versus extractors
of class
ListBuffer
of fold left and right
of functional on the outside,
imperative on the inside approach
of immutable objects
of lists
of LL(1) versus backtracking parsers
of looping versus recursion
of maps
of merge versus insertion sort
of sets
of tail versus non-tail recursion
of value types
Eiffel language
Elem class
Elem type
in trait
Parsers
elements, XML
else clauses
embedded DSLs,
see domain-specific languages
empty method
on
Map objects
on Seq objects
on
Set objects
on Set traits
empty-paren methods
enclosing instances,
see inner classes
endsWith method
on Seq traits
enqueue method
on class Queue
ensuring method
on object Predef
entities
enum keyword (Java),
see Enumeration class
Enumeration class
eq method
on class
AnyRef
equality,
see also equals method
!= (not equals) method
on class
Any
== (equals) method
on class
Any
eq method
on class
AnyRef
in Scala versus Java
in-depth treatment
ne method
on class
AnyRef
quick introduction
value versus reference
equals method
on class Any
equals method,
see also equality
generated for case classes
on class
Any
contract of
recipe for writing
erasure
and pattern matching
Erlang language
errata, viewing and reporting
errors,
see also compiler errors
handling with exceptions
in
parsing
preventing
escape sequences, for character literals
Evans, Eric
event
sources
event handling
event listeners
eventually method
on trait Eventually
example code, for book
downloading
license of
exception
handling
and checked exceptions
exception handling
ExecutionContext
exists method
on class
List
on class
StringOps
on class
List
on trait Iterator
on Traversable traits
extends keyword
external DSLs,
see domain-specific languages
extractors
and injections
extractor
pattern
extractor pattern
F
f string interpolator
F# language
factory
objects
factory methods
collect method
on trait Future
failed method
on object Future
Failure class
failure method
on trait Promise
fallbackTo method
on trait Future
false value
fields
abstract
defining
initializing to default values with an underscore
overriding
parametric
pre-initialized
private
FileReader class
files
ensuring closed with finally
opening
reading lines from
fill method
on object List
on Seq objects
filter method
on trait Future
filter method
on class
List
on trait Iterator
on Traversable traits
filterKeys method
on Map traits
filterNot method
on trait Iterator
on Traversable traits
filters
in
for expressions
in for expressions
final modifier
on variables (Java),
see vals
finally clauses
find method
on class List
on trait Iterator
on Traversable traits
findAllIn method
on class
Regex
findFirstIn method
on
class Regex
findPrefixOf method
on class
Regex
first-order methods
on class
List
flatMap method
on class List
on trait Future
on trait Iterator
on Traversable traits
translating for expressions to invocations of
flatten method
on trait Future
flatten method
on class
List
on class List
Flex
Float class
floating-point literals
floatingPointNumber method
in trait
JavaTokenParsers
fold
left
right
fold method
on object Future
foldLeft method
on class List
on trait Iterator
on Traversable traits
foldRight method
on class List
on trait Iterator
on Traversable traits
for expressions
translated before type checking
types valid after ->
for expressions
and
extractors
and Futures
and XML patterns
notation
using patterns in
for loops,
see also for expressions
forall method
on class
List
on trait Iterator
on Traversable traits
force method
on views
foreach method
on trait Future
foreach method
on class Array
on class
List
on Traversable traits
overriding
translating for expressions to invocations of
formatted method
on
Any (via StringAdd)
formatting strings
Fortran language
Fowler, Martin
free variables
fromTry method
on object Future
fsc (fast Scala compiler)
fully qualified names
function
literals
underscores in
function literals
and closures
and single abstract method types
for partial functions
placeholder syntax
syntax of
underscores in
versus function values
function values
and closures
functional
programming
lazy initialization
functional programming
main ideas of
functional style
combining with imperative style
in
parsing
methods without side effects
recognizing
refactoring functional style to
functions
basic form of
first-class
higher-order
local
partial
partially applied
predicates
procedures
pure
recursive
tail recursive
future method
on trait Promise
Future object
methods
apply
failed
fold
fromTry
reduce
sequence
successful
traverse
Future trait
methods
andThen
collect
failed
fallbackTo
filter
flatMap
flatten
foreach
isCompleted
map
onComplete
recoverWith
recover
transformWith
transform
value
withFilter
zipWith
zip
futures
G
Gamma,
Erich
generator, in for
expressions
generic
types
generic arrays
generic types
get method
on Map traits
getLines method
on object Source
getOrElse method
on Map traits
getOrElseUpdate method
on trait mutable.Map
getter methods
Gosling, James
graphical user
interfaces,
see user interfaces
groupBy method
on Traversable traits
grouped method
on Iterable traits
on trait Iterator
"Growing a language" (Steele)
GUI programming,
see user
interfaces
Guice
H
handlers, exception,
see catch clauses
hasDefiniteSize method
on trait Iterator
on Traversable traits
hash consing
hashCode method
caching
generated for case classes
if overriding equals
on class Any
contract of
recipe for writing
HashMap class
in class hierarchy diagram
HashSet class
creating and initializing immutable
in class hierarchy diagram
Haskell
language
Haskell language
as a lazy functional language
hasNext method
on trait Iterator
head method
on class
List
on Traversable traits
headOption method
on Traversable traits
Hejlsberg, Anders
Hibernate
hiding
names in import clauses
names in nested
packages
variables in nested
blocks
higher-kinded types,
see http:// booksites.artima.com/ programming_in_scala_3ed
higher-order
functions
higher-order methods
on class
List
I
identifiers
alphanumeric
capitalization conventions for
literal (with back ticks)
mixed
operator
identity
of objects, testing with eq method
idioms,
see patterns and idioms
if expressions
immutability
as functional style
selecting mutable versus immutable collections
trade-offs
imperative style
combining with functional style
recognizing
refactoring to functional style
implementation traits
implements keyword (Java),
see mixin composition
implicit keyword
implicit
conversion
in-depth treatment
to rich wrappers
implicit classes
implicit conversion
a word of caution
implicit classes
quick introduction
implicit conversions
when multiple apply
implicit parameters
implicit resolution
imports
hiding clauses
implicit
on-demand (i.e., wildcard)
renaming clauses
selector clauses
incrementing
with += 1, not ++
IndexedSeqLike implementation trait
indexOf method
on Seq traits
on trait Iterator
indexOfSlice method
on Seq traits
indexWhere method
on Seq traits
on trait Iterator
indices method
on class List
on Seq traits
inference
semicolon
turning off
type
Hindley-Milner style
the algorithm
infix operator notation
information hiding
with factory methods
inheritance
and self types
extending classes
mixing in traits
versus composition
inheritance hierarchy diagram,
see class hierarchy diagram
init method
on class
List
on Traversable traits
initialization
lazy
of abstract vals
of arrays
of classes,
see constructors
of fields to default values
of instance variables with constructor parameters,
see class parameters
of lists
of maps
of sets
of traits
initializers
injections
inner classes
accessing outer class members with a this alias
and path-dependent types
and private members
example of
granting access to private members of inner classes
private, to hide implementation
insert method
on trait Buffer
insertAll method
on trait Buffer
insertion sort
instance variables
instanceOf (Java),
see type tests
Int class
integer literals
IntelliJ IDE
interfaces (Java),
see traits
internal DSLs,
see domain-specific languages
interoperability, Scala with
Java
interpolated string literals
interpreter
intersect method
on Seq traits
on Set traits
invoking a superclass constructor
is-a relationships
isCompleted method
on trait Future
isDefinedAt method
on Map traits
on Seq traits
on trait PartialFunction
isEmpty method
on class
List
on Map traits
on trait Iterator
on Traversable traits
isInstanceOf method
on class Any
iterable
members
Iterable traits
methods
dropRight
grouped
iterator
sameElements
sliding
takeRight
zip
zipAll
zipWithIndex
iterate method
on Seq objects
iterator method
members
on class List
on Iterable traits
on mutable map
Iterator trait
methods
/: (fold left)
: (fold right)
addString
buffered
collect
copyToArray
copyToBuffer
count
drop
dropWhile
duplicate
exists
filter
filterNot
find
flatMap
foldLeft
foldRight
forall
grouped
hasDefiniteSize
hasNext
indexOf
indexWhere
isEmpty
length
map
max
min
mkString
next
nonEmpty
padTo
partition
patch
product
reduceLeft
reduceRight
sameElements
size
slice
sliding
sum
take
takeWhile
toArray
toIndexedSeq
toIterable
toList
toMap
toSeq
toSet
toStream
withFilter
zip
zipAll
zipWithIndex
++ (add elements)
J
Java
language
ANTLR
concurrency utilities
exception handling
Swing framework
wildcards
javac
Java 8
default methods
lambda expressions
Stream interface
Java language
bytecodes
collections
compiling with Scala
covariance of arrays
dependency
injection in
enumerations
inner classes
interfaces and Scala traits
interoperability with
Scala
interoperability with Scala
raw types
static methods
threading model
throws keyword
value types
wildcard types
Java Native Interface
Java Persistence Architecture
JavaBeans
JavaConversions object
JavaScript Object
Notation,
see JSON
JavaTokenParsers
trait
JFlex
JNI
Joy, Bill
JSON
JUnit
K
Kay, Alan
keys method
on
Map traits
keySet method
on
Map traits
keysIterator method
on Map traits
keywords, using as identifiers
L
Label class
LALR(1) parsers
lambda calculus
lambda expressions
in Java 8
Landin, Peter
last method
on class
List
on Traversable traits
lastIndexOf method
on Seq traits
lastIndexOfSlice method
on Seq traits
lastOption method
on Traversable traits
laws
layouts, in GUIs
lazy modifier
lazy functional
languages
length method
on class
List
on trait Iterator
lengthCompare method
on Seq traits
Lex
lexical
analysis
lexical analysis
linearization, of traits
linked lists
linking
of modules at runtime
Liskov Substitution Principle
and equals
method
Lisp language
List class,
see also lists
first-order methods on
higher-order methods on
immutability
implementation of
methods
/: (fold left)
::: (concatenation)
: (fold right)
addString
apply
copyToArray
count
drop
dropRight
dropWhile
exists
filter
find
flatMap
flatten
foldLeft
foldRight
forall
foreach
head
indices
init
isEmpty
iterator
last
length
map
mkString
partition
reduceLeft
remove
reverse
sort
sortWith
span
splitAt
tail
take
takeWhile
toArray
toString
unzip
zip
zipWithIndex
:: (cons)
List object
methods
apply
concat
fill
range
tabulate
ListBuffer class
listenTo method
on
Reactor
lists,
see also List class
appending
to
class hierarchy diagram
concatenation (:::)
converting
to arrays
converting to strings
creating and initializing
diagram
showing linked-list structure
in-depth treatment
passing elements as arguments with _*
table of methods
ListView class
literal method
on trait
RegexParsers
literals
array
boolean
character
class,
see classOf method
floating point
identifier
integer
interpolated string
list
string
symbol
XML
little languages,
see domain-specific languages
LL(1)
grammars
loadFile method
on XML
loan pattern
local functions
local variables
locks, and shared data
logical operations (
&&,
||,
!)
on class Boolean
Long class
lower bounds
LowPriorityImplicits class
LSP,
see Liskov Substitution Principle
M
magic numbers
main method
of GUI applications
of Scala applications
MainFrame class
attributes
contents
title
map
members
map method
on class
List
on trait Iterator
on trait Future
on Traversable traits
translating for expressions to invocations of
Map objects
Map traits,
see maps
methods
+ (add element)
++ (add elements)
- (remove element)
— (remove elements)
apply
clear
clone
contains
filterKeys
get
getOrElse
getOrElseUpdate
isDefinedAt
keys
keySet
keysIterator
mapValues
put
remove
retain
update
updated
values
valuesIterator
++= (add elements to)
+= (add element to)
—= (remove elements from)
-= (remove element from)
maps
class hierarchy diagram
creating and initializing immutable
creating and initializing mutable
in library, not language
mutability modeled in hierarchy
table of methods
mapValues method
on Map traits
match expressions
in-depth coverage
quick introduction
MatchError class
and "not exhaustive" warning
and extractors
not thrown in
for expressions
Matsumoto, Yukihiro
max method
on class
Int (via
RichInt)
on trait Iterator
on Traversable traits
member functions,
see methods
member variables,
see fields
members
abstract
field
initialization
order of
method
no static
type
merge sort
message passing
meta-programming
methods,
see also functions
abstract
as operators
as procedures
empty-paren
first-order
native
overloading
overriding
parameterless
overriding with
vals
parameters of
private
return from
when to invoke with empty parentheses
Meyer, Bertrand
Meyers, Scott
min method
on class
Int (via
RichInt)
on trait Iterator
on Traversable traits
mixed identifiers
mixin
composition
and self types
mixin composition,
see also traits
and self types
example of
syntax for
mkString method
on class
List
on trait Iterator
on
Traversable traits
mock objects
modules
runtime linking
monads
monitors
Multi-Java language
multi-threaded
programming,
see concurrency
multicore
multiple return values
multiple variable definitions
multiple-line statements
mutability
and equals
of collections
of object state
N
named arguments
namespaces
in C#
Scala's two instead of Java's four
naming conventions
NaN (not a number)
native annotation
ne method
on class
AnyRef
nested annotations
nesting
of classes and objects
of functions
of packages
.NET
NetBeans
IDE
new keyword
not needed when calling factory methods
not needed with case classes
next method
on trait Iterator
Nice language
Nil object
Nilsson, Rickard
Node class
NodeSeq class
nominal subtyping
None object
in extractors
nonEmpty method
on trait Iterator
on Traversable traits
nonvariance
Nothing type
as result type of throw expressions
as type parameter of List
in Scala class hierarchy diagram
Null class
in Scala class hierarchy diagram
null value
in equals methods
using Option instead for optional values
NullPointerException, preventing
O
Object class,
see also AnyRef class
in Scala class hierarchy diagram
object keyword
object-oriented
programming
object-oriented programming
Object-Oriented Software Construction (Meyer)
object-private access with private[this]
objects
annotating
companion,
see companion objects
domain
entity
equality of,
see equality
functional (immutable)
immutable
mock, in testing
mutable
serializing
singleton,
see singleton objects
standalone
OCaml language
on-demand import
onComplete method
on trait Future
operator
associativity
example: class Rational with
operator methods
identifiers
when to use
notation
infix
postfix
prefix
"overloading"
precedence
table of
opt method
on trait Parsers
optimization
of tail recursion
turning off with notailcalls
of value types
Option class
Ordered trait
outer classes,
see inner classes
overloading
constructors
methods
"operator"
override modifier
on parametric fields
overriding
defs with
vals
methods
and fields
equals method
P
package
objects
package clauses
package-private access (Java)
packages
as modules
hiding
implicitly imported
unnamed package
packaging
padTo method
on Seq traits
on trait Iterator
pair, name for Tuple2
Panel class
parallel
programming
parallel collections
parameterization
with
types
with
values
parameterized types
and object equality
parameterless methods
overriding with
vals
parameters
by-name
by-value
class,
see class
parameters
default
values
implicit
named
repeated
vararg matching
type
versus
arguments
parametric fields
parentheses
using curly braces instead of
when to use on method calls
parser
combinators
parser
generators
Parser class
parser combinators
ParseResult class
parsers
Parsers
trait
partial functions
PartialFunction trait
partially applied functions
partition method
on class List
on trait Iterator
on Traversable traits
passing arguments
to
superclass a constructor
patch method
on Seq traits
on trait Iterator
path-dependent types
and inner classes
Patricia tries
pattern
matching
and extractors
in exception handling
in lists
in equals method
pattern guards
pattern matching
constant patterns
constructor patterns
examples of
in
equals method
in event handling
in
for expressions
in lists
in variable definitions
in-depth coverage
on XML
quick introduction
sequence patterns
tuple patterns
typed patterns
variable patterns
variable-binding patterns
wildcard patterns
patterns
and idioms
divide and conquer principle
ensuring a resource is closed
patterns and idioms
conditional initialization
functional on the outside,
imperative on the inside
loan pattern
reading lines, characters, etc., with do-while
rich wrappers pattern
using Option not null to indicate optional values
performance
and multi-core processors
of collection types
of Scala compared to Java
Perl language
Pizza language
placeholder syntax
in
wildcards
in function literals
PLT-Scheme language
pointers,
see references
polymorphism
and type inference
pop method
on
class Stack
postconditions,
see ensuring method
postfix operator notation
pre-initialized
fields
precedence, operator
table of
preconditions
Predef object
methods
???
assert
classOf
ensuring
println
predicates
prefix operator notation
prefixLength method
on Seq traits
primary constructors
private
primitive types
private modifier
and inner classes
augmented with qualifiers, i.e., private[meeting]
granting access to private members of inner classes
in modules
object-private access with private[this]
on constructors
on fields
on methods
on parametric
fields
procedures
processed string literals
product method
on trait Iterator
on Traversable traits
programming
style
imperative
modular
programming in the large
programming in the small
programming style
functional
Promise trait
methods
completeWith
complete
failure
future
success
pronunciation of Scala
properties
verifiable with static typing
protected modifier
on parametric
fields
public access
Publisher trait
push method
on class
Stack
put method
on trait mutable.Map
putIfAbsent method
on trait ConcurrentMap
Python language
Q
Queue
class
R
r method
on class
String (via StringOps)
range method
on object
List
on object List
on Seq objects
ranges, of basic types
raw string interpolator
raw strings
in regular expressions
raw types (Java)
Raymond, Eric
reactions property
on
Reactor
on Reactor
Reactor
trait
Reader class
reading
from standard input
with do-while
lines from a file
receive method
on trait Actor
recommended style,
see style recommendations
recover method
on trait Future
recoverWith method
on trait Future
recursion,
see recursion
in
combinator parsers
tail
optimization
using ListBuffer to prevent stack overflow
reduce method
on object Future
reduceLeft method
on class List
on trait Iterator
on Traversable traits
reduceRight method
on trait Iterator
on Traversable traits
refactoring
and static typing
and vals
imperative to functional style
reducing code duplication with closures
reference
classes
definition of
equality
referential transparency
refinement types
reflection
Regex class
regex method
on trait
RegexParsers
RegexParsers trait
regular expressions
as parsers
relational operations (
>,
<,
>=,
<=)
on numeric types
on trait Ordered
remove method
on class List
on trait ConcurrentMap
on trait mutable.Map
on trait mutable.Set
on trait Buffer
rendererComponent method
on class Table
rep method
on trait
Parsers
repeated parameters
vararg matching
replace method
on trait ConcurrentMap
representation independence
repsep method
on trait
Parsers
require method
on object
Predef
resources, ensuring release of
result type
covariance of
retain method
on trait mutable.Map
on trait mutable.Set
return keyword
return type
returning multiple values
reverse method
on class
List
on Seq traits
reverseIterator method
on Seq traits
reverseMap method
on Seq traits
rich wrappers pattern
RichInt class,
see Int class
rowHeaderView property
on class ScrollPane
Ruby language
Rumbaugh, James
running a Scala program,
see scala
runtime type, definition of
S
s string interpolator
SAM types,
see single abstract method types
sameElements method
on Iterable traits
on trait Iterator
save method
on
XML
Scala
language
compiling
scalability of
scala (Scala launcher)
to launch applications
to launch scripts
to launch the interpreter
Scala language
2.12 release
class hierarchy diagram
compatibility
with Java
compatibility with Java
compiling
with Java
conciseness versus Java
downloading
IDEs
influences on
interpreter shell
naming of source files
pronunciation of "Scala"
scalability of
scripts,
see scripts, Scala
specification
Scala.js
scalability
of configuration
of Scala language
of teams
scalac (Scala compiler)
ScalaCheck
Scaladoc
ScalaTest
scanner generators
Scheme language
scope
of implicit conversions
of variables
scripts, Scala
running on Unix
running on Windows
ScrollPane
class
sealed classes
sealed modifier
segmentLength method
on Seq traits
selectors
in match expressions
selectors, in imports
self
types
self references
self types
semi-structured data
semicolon inference
turning off
seq
factory
members
Seq objects
methods
apply
concat
empty
fill
iterate
range
tabulate
Seq traits
methods
+: (prepend)
:+ (append)
apply
contains
containsSlice
corresponds
diff
distinct
endsWith
indexOf
indexOfSlice
indexWhere
indices
intersect
isDefinedAt
lastIndexOf
lastIndexOfSlice
lengthCompare
padTo
patch
prefixLength
reverse
reverseIterator
reverseMap
segmentLength
sortBy
sorted
sortWith
startsWith
union
update
updated
sequence method
on object Future
sequence patterns
serializable annotation
serialization
binary
to and from XML
SerialVersionUID annotation
set
members
Set objects
Set traits,
see sets
methods
add
clear
clone
contains
diff
empty
intersect
remove
retain
subsetOf
union
update
| (union)
&~ (diff)
& (intersect)
++= (add elements to)
++ (add elements)
+= (add element to)
—= (remove elements from)
— (remove elements)
-= (remove element from)
- (remove element)
+ (add element)
sets
and generic types
class hierarchy diagram
creating and initializing immutable
creating and initializing mutable
mutability modeled in hierarchy
table of methods
setter methods
shadowing variables
shared
data and locks
shell, Scala interpreter
shift operations (
<<,
>>,
>>>)
on integral types
short circuiting, of logical operations
Short class
side effects
minimizing
SimpleSwingApplication
class
Simula language
single abstract method types
singleton
objects
as modules
singleton objects
as seen from Java
in testing
initialization semantics
nesting of
shown with rounded corners in hierarchy diagrams
singleton types
size method
on Set traits
on trait Iterator
on Traversable traits
slice method
on trait Iterator
on Traversable traits
sliding method
on Iterable traits
on trait Iterator
Smalltalk language
SML language
snoc
Some class
in extractors
sort
insertion
merge
sort method
on class List
sortBy method
on Seq traits
sorted method
on Seq traits
SortedMap trait
SortedSet trait
sortWith method
on class
List
on Seq traits
source code, downloading,
see example code
source files, naming of
Source object
span method
on class List
on Traversable traits
specifiers, access,
see access modifiers
specs2
split method
on class String
splitAt method
on class List
on Traversable traits
spreadsheets
Spring
Framework
Spring Framework
Stack class
stack, the
and tail-recursive functions
and thrown exceptions
and variables captured by closures
stackable modifications
standalone objects
standard error stream
startsWith method
on Seq traits
statements
multiple-line
static members
static typing
Steele, Guy
Stream class
in Scala
Stream interface
in Java 8
String class
methods
r (via StringOps)
stripMargin (via StringOps)
StringBuilder class
stringLiteral method
in trait JavaTokenParsers
stringly typed code
StringOps class,
see also String class
stringPrefix method
on Traversable traits
strings
formatting
interpolated (processed)
iterating through the characters of
literals
long
raw
treating as a sequence (via WrappedString)
treating like a sequence (via
StringOps)
structural subtyping
Structure
and Interpretation of Computer Programs (Abelson, et. al.)
style recommendations
prefer alphabetic names unless symbolic names have
established meaning
prefer classes to tuples when data combination has meaning
prefer vals, immutable objects, and
methods without side effects
use
implicit conversions with restraint
subclasses
and equals method
defining
subsetOf method
on Set traits
subtyping
and type parameters
nominal vs. structural
versus subclassing
subtyping polymorphism
Success class
success method
on trait Promise
successful method
on object Future
sum method
on trait Iterator
on Traversable traits
super references
special treatment in traits
superclasses
invoking constructor on
supertype
Sussman, Gerald J.
Swing
methods
EmptyBorder
switch statement (Java)
symbol literals
symbolic versus alphabetic
names
syntactical analysis
T
Table class
TableUpdated class
tabulate method
on object List
on Seq objects
tags, XML
tail
recursion
tail method
on class
List
on Traversable traits
tail recursion
optimization
turning off with notailcalls
verifying with @tailrec
tailrec annotation
take method
on class List
on trait Iterator
on Traversable traits
takeRight method
on Iterable traits
takeWhile method
on class List
on trait Iterator
on Traversable traits
target typing
template, definition of
term, in function literals
Test annotation
in JUnit 4
test suites
testing
integration
unit
with mock objects
with singletons
Text class
text method
on class Node
text processing in
XML
text processing in XML
TextField class
Thinking in Java (Eckel)
this
aliasing
and self
types
throw expressions
throws annotation
tiny types
to method
on class
Int (via
RichInt)
toArray method
on class List
on trait Iterator
on Traversable traits
toChar method
on class Int
toIndexedSeq method
on trait Iterator
on Traversable traits
toInt method
on class String (via StringOps)
toIterable method
on trait Iterator
on Traversable traits
toList method
on
class ListBuffer
on class
Array
on class ListBuffer
on trait Iterator
on Traversable traits
toMap method
on trait Iterator
on Traversable traits
top method
on class
Stack
top method
on class SimpleSwingApplication
Torreborre, Eric
toSeq method
on trait Iterator
on Traversable traits
toSet method
on trait Iterator
on Traversable traits
toStream method
on trait Iterator
on Traversable traits
toString method
generated for case classes
on class Any
overriding
total function,
see complete function
traits,
see also mixin composition
and
abstract parameters
and Java interfaces
annotating
generic
implementation
initializing
linearization of
mixing in
transform method
on trait Future
transformers
transformWith method
on trait Future
transient annotation
Traversable traits
methods
/: (fold left)
: (fold right)
addString
collect
copyToArray
copyToBuffer
count
drop
dropWhile
exists
filter
filterNot
find
flatMap
foldLeft
foldRight
forall
foreach
groupBy
hasDefiniteSize
head
headOption
init
isEmpty
last
lastOption
map
max
min
mkString
nonEmpty
partition
product
reduceLeft
reduceRight
size
slice
span
splitAt
stringPrefix
sum
tail
take
takeWhile
toArray
toIndexedSeq
toIterable
toList
toMap
toSeq
toSet
toStream
view
withFilter
++ (add elements)
TraversableLike implementation trait
traverse method
on object Future
TreeMap class
TreeSet class
trimEnd method
on trait Buffer
trimStart method
on trait Buffer
true value
Try class
class hierarchy diagram
try expressions
tuple patterns
tuples
creating and using
one-based element access
result of -> operation
when to use a class
instead
zipped method on
type
constructors
type
parameters
lower bounds
type aliases
type annotations
for debugging
type casts,
see casting
type erasure
type inference
Hindley-Milner style
the algorithm
type keyword
in singleton types, such as db.type
in type alias definitions
type members
type parameterization,
see parameterized types
type parameters
in parser results
upper bounds
type tests
with isInstanceOf
with typed patterns (preferred style)
type-driven
design
typed patterns
types
abstract
bottom
erasure
generic
ground
in for expressions
integral
numeric
path-dependent
primitive
refinement
result
return
runtime
self
singleton
static
wildcard
typing
dynamic
static
target
U
Ullman, Jeffrey
unapply method
in
extractors
unapplySeq method
in extractors
unary operations
unchecked annotation
Unicode
Unified Modeling Language Reference Manual, The (Rumbaugh, et. al.)
uniform access
principle
union method
on Seq traits
on Set traits
Unit class
unit testing
unit value
unnamed package
until method
on class
Int (via
RichInt)
unzip method
on class List
update method
on class Array
on Seq traits
on trait mutable.Map
on trait mutable.Set
updated method
on Map traits
on Seq traits
upper bounds
user
interfaces
reactive programming
user interfaces
reactive programming
V
vals,
see also variables
abstract
annotating
as fields
conditional initialization of
defining
lazy
preferring over vars
referencing mutable objects
"val" on class parameters
Value class
value classes
value method
on trait Future
value parameterization
ValueChanged class
values method
on class Enumeration
on
Map traits
valuesIterator method
on Map traits
van Rossum, Guido
vararg matching
variable patterns
variable-binding patterns
variable-length arguments, or "varargs",
see repeated parameters
variables
bound
captured by closures
defining
using patterns
fields
final (Java),
see vals
free
instance
local
multiple definitions of
reassignable,
see also vars
scope
shadowing
variance
annotations
compiler checking of
declaration-site
use-site
vars,
see also variables
abstract
and mutable objects
annotating
as fields
defining
on class parameters
programming without
Vector class
verifiable properties
view method
on
Traversable traits
viewportView property
on class ScrollPane
views
virtual classes
volatile
annotation
W
Wall, Larry
warnings,
see compiler warnings
weak hash maps
while loops
as imperative style
wildcard patterns
wildcard types
wildcard types (Java)
Wirth, Niklaus
with keyword
withFilter method
on trait Future
on trait Iterator
on Traversable traits
translating for expressions to invocations of
WrappedString class
X
XML
attributes
character encoding
configuration
files
configuration files
deserialization
elements
literals
pattern
matching
serialization
tags
text
using an at sign (@) to extract attributes
using curly braces ({})
in pattern matching
XPath
XML object
methods
loadFile
XML object
methods
save
XPath
Y
Yacc
yield keyword
in
for expressions
in for expressions
Z
zip method
on class List
on Iterable traits
on trait Iterator
on trait Future
zipAll method
on Iterable traits
on trait Iterator
zipped method
on tuples
zipWith method
on trait Future
zipWithIndex method
on class List
on Iterable traits
on trait Iterator
Other titles from Artima Press
Property-based testing allows you to express your tests in terms of functions called "properties" that describe your code's behavior, leaving the task of test case generation and evaluation to the testing tool. ScalaCheck: The Definitive Guide is the authoritative guide to ScalaCheck, a property-based testing tool for Scala. Written by the creator of ScalaCheck, this book will help you learn how to take advantage of this valuable complement to traditional testing techniques.
ScalaCheck: The Definitive Guide
by Rickard Nilsson
ISBN: 978-0-9815316-9-4
$24.95 paper book / $15.00 PDF eBook
Order it now at: http://www.artima.com/shop/scalacheck
Akka Concurrency is the authoritative guide to concurrent programming with Akka. Written as a practical guide, it will teach you not just the "what" and "how" of Akka, but also the "why." Akka isn't just a toolkit you can use to write your concurrent applications: it embodies a set of paradigms you can use to reason about those applications. This book will give you a whole new perspective on how you design, build, and think about concurrent applications on the JVM.
Akka Concurrency
by Derek Wyatt
ISBN: 978-0-9815316-6-3
$45.95 paper book / $26.95 PDF eBook
Order it now at: http://www.artima.com/shop/akka_concurrency