! (message send)
on trait
Actor
! (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
| (alternative composition)
parser combinator
| (alternative composition)
parser
combinator
| (bitwise-or)
on integral types
|| (logical-or)
on class Boolean
| (union)
on Set traits
' (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
— (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
-> (map to)
in
implicit conversion
/ (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
< (less than)
on numeric types
<- (in)
in for expressions
<: (upper bound)
<< (shift left)
on integral types
<= (less than or equal to)
on numeric types
<% (view bound)
= (variable assignment)
== (equals)
in set membership
== (equals)
in Scala versus Java
in-depth treatment
method on
Any
quick introduction
=== (triple equals)
in ScalaTest suites
=> (right arrow, or ``rocket'')
in function literals
in import statements
in self types
in match alternatives
in this aliasing
> (greater than)
on numeric types
>: (lower bound)
>= (greater than or equal to)
on numeric types
>> (shift right)
on integral types
>>> (unsigned shift right)
on integral types
# (pound sign)
in inner class type names
% (remainder)
on numeric types
& (bitwise-and)
on integral types
& (intersect)
on
Set traits
&& (logical-and)
on class Boolean
&~ (diff)
on Set traits
_ (underscore)
in curried functions
in existential types
in function literals
in identifiers
in import statements
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
{} (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
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)
! (message send)
actor
act
loop
react
receiveWithin
receive
start
actors
add method
on trait mutable.Set
addString method
on class List
on trait Iterator
on Traversable traits
Aho, Alfred
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
annotations
and reflection
applied to expressions
arguments to
@BeanProperty
@deprecated
in meta-programming
in testing
Java-specific
@native
nested
@serializable
@SerialVersionUID
standard
syntax of
@tailrec
@Test
in JUnit 4
in TestNG
@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
application
function to arguments
partial function
Application trait
applications, Scala
apply method
called with parentheses
in extractors
on
Array
class
object
on
List
class
object
on
Map
objects
traits
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 []
cloning
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
asynchronous messages
attributes
XML
automatic
boxing
conversion,
see implicit conversion
imports
auxiliary constructors
backtracking
base classes,
see superclasses
BDD,
see behavior-driven development
BeanProperty annotation
BeanProperty annotation
Beck, Kent
behavior-driven
development
Beust, Cedric
BigInt class
BigInteger class
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
language
parser generators
C language
C++ language
C# language
enumerations
properties
static extension methods
Callahan, Harry
camel casing
CanBuildFrom trait
capitalization, of identifiers
capitalize method
on class Int (via RichInt)
case
classes
case classes
and actors
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 lists
for maps
for Scala
for sets
class manifest
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
inner,
see inner classes
nesting of
private
sealed
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 Iterator
on Traversable traits
collections
api
architecture
conversion between Java and Scala
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
warnings
non variable type-argument ...in type pattern is unchecked since it is eliminated
by erasure
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
there
were unchecked warnings; re-run with -unchecked for details
Compilers: Principles, Techniques, and Tools (Aho, et. al.)
compiling
Scala and Java together
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
shared data and locks
shared-nothing
ConcurrentHashMap class
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 bound
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
data
structures
fully persistent
semi-structured
deadlock
deafTo method
on Reactor
declarations, versus definitions
decrementing
with
-= 1, not
—,
see incrementing
def keyword
annotating
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
Dirty Harry
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
embedded in Scala
in Smalltalk and Lisp
parser combinators as an internal DSL
rich wrappers and
internal versus external DSLs
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
Eastwood, Clint
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 thread creation and switching
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
=== (triple equals) method
in ScalaTest suites
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
and actors
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
example code, for book
downloading
license of
exception
handling
and checked exceptions
exception handling
existential types
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# language
factory
objects
factory methods
Failure class
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 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 Iterator
on Traversable traits
translating for expressions to invocations of
flatten method
on class
List
on class List
Flex
Float class
floating-point literals
floatingPointNumber method
in trait
JavaTokenParsers
fold
left
right
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 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 class Array
on class
List
on Traversable traits
overriding
translating for expressions to invocations of
formatted method
on
Any (via StringAdd)
formatting strings
forSome keyword
Fortran language
Fowler, Martin
free variables
fsc (fast Scala compiler)
fully qualified names
function
literals
underscores in
function literals
and closures
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
Gamma,
Erich
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
Goetz, Brian
Gosling, James
graphical user
interfaces,
see user interfaces
Groovy language
groupBy method
on Traversable traits
grouped method
on Iterable traits
on trait Iterator
``Growing a language'' (Steele)
GUI programming,
see user
interfaces
Guice
Haller,
Philipp
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_2ed
higher-order
functions
higher-order methods
on class
List
identifiers
alphanumeric
capitalization conventions for
literal (with back ticks)
mixed
operator
identity
function, for implicit conversions
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 conversion
a word of caution
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
interpreter
intersect method
on Seq traits
on Set traits
invoking a superclass constructor
is-a relationships
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)
Java
language
ANTLR
concurrency utilities
exception handling
Swing framework
wildcards
javac
Java Concurrency in Practice (Goetz)
Java language
bytecodes
collections
compiling with Scala
concurrency
utilities
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
Jenson, Steve
JFlex
JNI
Joy, Bill
JSON
JUnit
Kay, Alan
keys method
on
Map traits
keySet method
on
Map traits
keysIterator method
on Map traits
keywords, using as identifiers
Label class
LALR(1) parsers
lambda calculus
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
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
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
magic numbers
main method
of GUI applications
of Scala applications
MainFrame class
attributes
contents
title
manifests
map
members
map method
on class
List
on trait Iterator
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 concurrency
and equals
of collections
of object state
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
notify method
on AnyRef
notifyAll method
on AnyRef
Null class
in Scala class hierarchy diagram
null value
in equals methods
using Option instead for optional values
NullPointerException, preventing
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
safe publication of
serializing
singleton,
see singleton objects
standalone
stateful (mutable)
OCaml language
on-demand import
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
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
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
and
actors
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 existentials
in function literals
PLT-Scheme language
pointers,
see references
Pollak, David
polymorphism
and type inference
pop method
on
class Stack
Popescu, Alexandru
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
product method
on trait Iterator
on Traversable traits
programming
style
imperative
modular
programming in the large
programming in the small
programming style
functional
projections
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
Queue
class
r method
on class
String (via StringOps)
range method
on object
List
on object List
on Seq objects
ranges, of basic types
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
recursion,
see recursion
in
combinator parsers
tail
optimization
using ListBuffer to prevent stack overflow
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 method
on trait
RegexParsers
Regex class
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
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
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
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 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)
++= (add elements to)
++ (add elements)
+= (add element to)
—= (remove elements from)
— (remove elements)
-= (remove element from)
- (remove element)
&~ (diff)
& (intersect)
+ (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
shared-nothing message passing
shell, Scala interpreter
shift operations (
<<,
>>,
>>>)
on integral types
short circuiting, of logical operations
Short class
side effects
minimizing
SimpleGUIApplication
class
Simula language
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
specs
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 the react method on actors
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
String class
methods
r (via StringOps)
stripMargin (via StringOps)
StringBuilder class
stringLiteral method
in trait JavaTokenParsers
StringOps class,
see also String class
stringPrefix method
on Traversable traits
strings
formatting
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
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
synchronized method
on AnyRef
SynchronizedMap trait
SynchronizedSet trait
syntactical analysis
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
in TestNG
test suites
testing
integration
unit
with mock objects
with singletons
TestNG
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
Thread class
thread safety
threads, and actors
throw expressions
throws annotation
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 SimpleGUIApplication
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
traits,
see also mixin composition
and
abstract parameters
and Java interfaces
annotating
generic
implementation
initializing
linearization of
mixing in
transformers
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
TreeMap class
TreeSet class
trimEnd method
on trait Buffer
trimStart method
on trait Buffer
true value
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 type patterns (preferred style)
type-driven
design
typed patterns
types
abstract
bottom
erasure
existential
generic
ground
in for expressions
integral
numeric
path-dependent
primitive
refinement
result
return
runtime
self
singleton
static
structural
typing
dynamic
static
target
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
as return type of a method
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
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 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
verifiable properties
view bounds
view method
on
Traversable traits
viewportView property
on class ScrollPane
views
volatile
annotation
wait method
on AnyRef
Wall, Larry
warnings,
see compiler warnings
weak hash maps
while loops
as imperative style
wildcard patterns
wildcard types (Java)
Wirth, Niklaus
with keyword
withFilter method
on trait Iterator
on Traversable traits
translating for expressions to invocations of
WrappedString class
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
Yacc
yield keyword
in
for expressions
in for expressions
zip method
on class List
on Iterable traits
on trait Iterator
zipAll method
on Iterable traits
on trait Iterator
zipped method
on tuples
zipWithIndex method
on class List
on Iterable traits
on trait Iterator
Scala Solutions (scalasolutions.com)
Scala Training, Products, and Consulting
The coauthor of this book, Martin Odersky, founded Scala Solutions to provide
the Scala community with a source of quality Scala training, consulting, and
development tools. If you or your colleagues need training or other services
then check out the Scala Solutions website. Scala Solutions and its partners
provide regular Scala training courses that are available locally in many
countries.
For commercial organizations, Scala Solutions provides a certified source of
stable Scala versions, migration utilities and the consulting services they
need to take advantage of all the new Scala features as new versions are
released or assist you maintaining the stability of deployed applications.
Scala Solutions has unrivalled expertise in the field of professional Scala
development and they, like you, enjoy programming in Scala.
Escalate Software (escalatesoft.com)
Scala Training and Consulting
Escalate Software provides professional training and consulting services for teams using the Scala programming language.
Co-founded by Bill Venners (coauthor of this book) and Dick Wall, Escalate Software offers custom corporate training
in addition to regular open-enrollment training courses from novice to expert content.
In addition, Escalate Software can help your business get started and succeed with Scala through its "kickstart" program, which helps you get skills and infrastructure in place for your build, development, and deployment. Kickstart is designed to help you deliver results quickly.
For Escalate Software, providing Scala training and consulting services is a lot more than just a job, it is a calling. In addition to helping you achieve your goals quickly, Escalate Software also aims to enrich, expand, and help sustain the use of Scala and the growth of the Scala community, maintaining strong ties and cooperation with the rest of the community.
Dive deeper into Scala's actors model
with this new book from Artima Press:
Actors in Scala is the authoritative guide to programming with the actors framework of Scala's standard library, co-written by the creator and lead maintainer, Philipp Haller. The book provides a comprehensive introduction to the actor model of concurrency and shows how Scala's actors enable you to build efficient, scalable, and robust concurrent software for the JVM.
Actors in Scala: Concurrent programming for the multi-core era
by Philipp Haller and Frank Sommers
ISBN: 978-0-9815316-5-6
$36.95 paper book / $23.00 PDF eBook
Other titles from Artima Press
Hiring software professionals is difficult, but few books exist on this specific topic. Agile Hiring presents a fresh approach that is tested by fire: developed by the author in over twenty years of experience hiring software professionals at both small companies and large. Drawing on principles from the "agile" software movement, this book offers a different way to think about hiring. This book provides principles and techniques that will help you hire the best software professionals.
Agile Hiring: Transform how you hire software professionals
by Sean Landis
ISBN: 978-0-9815316-3-2
$29.95 paper book / $20.00 PDF eBook
Order it now at: http://www.artima.com/shop/agile_hiring
Flex 4 Fun is the authoritative guide to graphics and animation in Flex 4: the fun stuff! The book is filled with insightful tips on user interface programming and includes nearly seventy example programs written expressly for the book. Written by Chet Haase, an engineer on the Flex SDK team at Adobe during the development of Flex 4 and coauthor of Filthy Rich Clients, this book will teach you the graphical and animation side of Flex 4 that enable better user experiences.
Flex 4 Fun: Graphics and animation for better user interfaces
by Chet Haase
ISBN: 978-0-9815316-2-5
$36.95 paper book / $23.00 PDF eBook
Order it now at: http://www.artima.com/shop/flex_4_fun