Symbols
! (invert)
on class Boolean
+ method
on Sets
on Strings (concat)
++ (concat) in Scala collections library
+: (prepend) in Scala collections library
+= method (append)
on class StringBuilder
on Sets
-print
in compiler options
-Xcheckinit
in compiler options
-Xfatal-warnings
in compiler options
-Xprint:
in compiler options
erasure
parser
-Ywarn-dead-code
in compiler options
== (equals)
method on class Any
## method
hashCode, null-safe version
on class Any
_ (underscore)
used to initialize a field to its default value
A
abstract case classes
abstract fields
abstract types
abstract val
accepting wider types
getOrElse method
on class Option
orElse method
on class Option
recover method
on class Future
on class Try
accessor
ambiguous references
anonymous class types
function types
anonymous classes
anonymous functions
constructing
implicit parameters
implicit resolution
omitting parentheses
parameter lists
passed directly
passed in block expressions
anonymous subclasses
Any class
in Scala class hierarchy diagram
methods
equals
hashCode
AnyRef class
in case classes overrides
in default initial values
in Scala class hierarchy diagram
AnyVal class
in Scala class hierarchy diagram
append method
alias
apply methods
function types
implicit
argument declaration
argument order
overriding methods
arguments
positional
Array class
in Scala collections library
assignments
multiple-variable
auto-tupling
compiler flags
auxiliary constructor
B
base classes
concrete definition of method, in
best practices
block expressions
curly braces
Boolean class
in default initial values
boxing, of value types
Buffer trait
in Scala collections library
by-name parameters
by-value parameters
Byte class
in default initial values
C
case classes
abstract
declaration
explanation
explicit implementations of methods, in
extending
generated hashCode method, switched off
generated implementations
equals method and hashCode method
implicit overrides
method definition, in
pattern matching
replacing factory method
chaining operations
Char class
in default initial values
class construction
class constructor
class definition
class hierarchy diagram
for Scala
class initialization sequence
class
MatchIterator
in class Regex
methods
matchData
class members
in scope
class
Regex
iterators
class MatchIterator
methods
findAllIn
closure variables capturing
closures
collections
imperative operations on
using for loops
using foreach method
method names vs. operators
tuples
view method
on trait Map
companion objects
compare method
on NaN
compiler
performance
compiler errors
_ must follow method; cannot follow Unit ...
ambiguous implicit values: ...
ambiguous reference to overloaded definition, ...
could not find implicit value for parameter ...
Int does not take parameters ...
missing arguments for method ...; follow this method with `_' if you want to treat it as a partially applied function
not enough arguments for method ...: ...
not found: value ...
overloaded method value ...
recursive value ...needs type ...
return outside method definition ...
stable identifier required, but ...found
too many arguments for method ...
type mismatch; ...
Note that implicit conversions are not applicable because they are ambiguous
type Null cannot be used in a type pattern or isInstanceOf test
unreachable code ...
compiler inlining
compiler options
-print
-Xcheckinit
-Xfatal-warnings
-Xprint:
erasure
parser
-Yno-adapted-args
-Ywarn-adapted-args
-Ywarn-dead-code
compiler warnings
a pure expression does nothing in statement position; you may be omitting necessary parentheses
Adapting argument list by ...: ...
dead code following this construct ...
Reference to uninitialized value ...
value ...does nothing other than call itself recursively
concise code
constant values
pattern matching
stable identifiers
uppercase variable names
vals
constructors
arguments
auxiliary
body
parameters
primary
no-arg
statements, order of
superclass
trait
control flow
nested functions
control structures
convenience methods
toSet
curly braces
block expressions
early field definitions
parentheses, instead of
curried definitions
curried functions
curried invocations
curried parameters
currying
cyclic definitions
cyclic dependencies
cyclic references
D
data structures
immutable
debugging statement
declaration order
default arguments
at runtime
invoking default methods
with named parameters
default implicits
default initial values
default methods
default parameter values
default values
mutable
uninitialized
deferring
evaluations
desugar
for comprehensions
for loop
generators
guards
map
Double class
in default initial values
E
eager evaluations
eager vals
early field definitions
curly braces
early initializers
elegant approach
using lazy vals
elegant syntax
empty argument list
endless loop
equals method
behavior unaffected
compiler-generated overridden implementation
contract with
hashCode method
generated implementation
hashCode method, coherence between
on class Any
on class
Any
structural equality with hashCode method
eta expansion
anonymous function value
avoiding
evaluations
deferring
exception handling
expected types
explicit argument
explicit implementations
methods
in case classes
extractors
F
factory methods
field accessors
fields
pre-initialized
FilterMonadic trait
methods
flatMap
map
withFilter
final modifier
findAllMatchIn method
in class Regex
flatMap method
on trait
FilterMonadic
Float class
in default initial values
fold method
on class List
on trait Iterable
on trait GenTraversableOnce
foldLeft method
on trait Iterable
on trait
Range
for comprehensions
desugaring
for expressions
desugaring
initializing matcher
for loop
desugaring
force method
on view
foreach method
initializing matcher
invocation
on result of map invocation
on collections, tuples
free variables
function body
function definition
function invocation
function literals
function objects
function parameters
function types
anonymous class types
apply methods
shorthands
function values
functional constructs
functional primitives
functional programming
immutability
functionality
general
reusable
functions
eta-expanded
functions values
G
generators
desugaring
pattern matching
in for comprehensions
generic functions
generic types
GenTraversableOnce trait
methods
fold
getOrElse method
on class Option
accepting wider types
return type
good practices
H
hashCode method
## null-safe version, in Scala
behavior unaffected
compiler-generated
contract with
equals method
equals method, coherence between
generated implementation
generated, switched off
on class
Any 10 11 12 13 14 15
default implementation
structural equality with equals method
super
HashSet class
in Scala collections library
helper methods
I
if-
else expressions
nested
immutability
implementation specific
implementations
explicit
implicit
ambiguous
conversion
defs
function vals
values
declaration
initialization
implicit classes
implicit conversions
type
implicit evidence
implicit overrides
case classes
implicit parameters
anonymous functions
resolution
resolving
implicit resolution
implicit, default
any2stringadd
augmentString
Ordering trait
on class Double
implicitly method
on object Predef
implicits
empty argument list
inferred return type
wider
inheritance
initial value
initialization order
initialization statements
executed
Int class
in default initial values
intermediate types
isInstanceOf method
on runtime types
Iterable interface
in Java collections library
Iterable trait
in Scala collections library
methods
fold
foldLeft
map
size
sum
toSeq
iteration order
on trait SortedSet
iterators
for expressions
initializing matcher
foreach method
initializing matcher
in class
Regex
class MatchIterator
J
Java interoperability
java.lang.Object
passed to println
L
lambda functions
return statements
language specification
features, undocumented
gotchas
lazy evaluation
lazy initialization
lazy map
overhead
lazy vals
10 11 12 13
elegant approach
evaluation of
initialization of
no benefit
recomputation of
reinitialization of
thrown exception during initialization
List class
in Scala collections library
methods
fold
map
size
Long class
in default initial values
lowercase variable names
backticks, enclosing in
constant values
stable identifiers
variable patterns
lt method
on NaN
on trait Ordering
used by stableSort method
M
map
desugaring
map method
initializing matcher
on class
List
on trait
Iterable
on trait Set
on trait
FilterMonadic
on trait
Seq 10
map view
mapValues method
on class Map
matchData method
in class MatchIterator
member declarations
metagrobologists,
see About the Authors
method arguments
naming
method overloading
method parameters
defining
methods
arguments
compiler-generated
parameterless
side-effecting
signature
multiple parameter lists
defining default argument values
implicit parameters
non-implicit parameters
partially applied functions
type inference
using curly braces
multiple-variable assignments
pattern matching
mutable objects
mutable states
N
named arguments
with default arguments
NaN (not a number)
in sorting algorithms
nested anonymous functions
nested functions
control flow
return statements
non-deterministic
Nothing type
in Scala class hierarchy diagram
Null special type
in Scala class hierarchy diagram
compatibility with Java
null values
in default initial values
nullary methods
number literals
Numeric trait
numeric types
O
object allocation
avoiding
Object class
in Scala class hierarchy diagram
object members
in scope
object-oriented programming
one-liners
Option factory
ordering
ascending value
iteration
on trait SortedSet
lexicographically
on class
Double
inconsistent
on NaN
orElse method
on class
Option
accepting wider types
overloading
alternatives
methods
multiple signatures
resolution
first stage
second stage
shape-based
two-stage algorithm
type-based
overriding behavior of
defs
overriding behavior of
vals
overriding methods
argument order
P
parameter evaluation
parameter lists
empty
parameterless methods
parameters
by-name
by-value
defining
implicit
resolution
resolving
multi-parameter lists
parent class
explicit implementations of methods, inherited from
parent trait
explicit implementations of methods, from
partial application
partially applied functions
pattern definition
pattern guards
desugaring
pattern matching
checking for null
generators
in for comprehensions
on case classes
stable identifiers
unreachable code
placeholder syntax
using underscore character
polymorphic resolution
positional arguments
pre-initialized fields
precedence
during implicit search
Iterable object
methods
implicitly
primary constructor
pure functions
R
Range trait
in Scala collections library
methods
foldLeft
recover method
on class
Future
accepting wider types
on class
Try
accepting wider types
recursive computations
recursive definitions
avoiding
refactoring
cautions
reference equality
referentially transparent
regular expressions
utility functions
class Regex
return expressions
code following, ignored
return keyword
return statements
avoiding
enclosing scope
explicit
performance optimization
in function body
in lambda functions
in methods
in nested functions
multiple
unreachable code
return value
of method
return values
of method
runtime error
scala.MatchError: ...
runtime exceptions
Java
IllegalStateException: No match available ...
IndexOutOfBoundsException: ...
NullPointerException: ...
StackOverflowError: ...
StringIndexOutOfBoundsException: ...
Java.NullPointerException
Scala
MatchError: ...
NonLocalReturnControl: ...
UninitializedFieldError: ...
runtime type
S
Scala collections library
methods
concat
prepend
toSet
Scala language
best practices
class hierarchy diagram
features
auto-tupling
curly braces
good practices
strengths
interoperability with Java
Scala style
idiomatic
immutability
Scala's
null-safe versions
== (equals)
## (hashCode)
LowPriorityImplicits class
Scaladoc
self-references
avoiding
in variable definitions
Seq trait
in Scala collections library
methods
map 10
Set trait
in Scala collections library
methods
map
size
Short class
in default initial values
side effects
class MatchIterator in class Regex
singleton
size method
on class List
on trait
Iterable
on trait Set
SortedSet trait
iteration order
determined by elements
sorting
on NaN
sorting algorithms
mirroring
compareTo method
on class Double, in Java
NaN, handling of
stableSort method
stable identifiers
constant values
lowercase variable names
pattern matching
variable assignment
stableSort method
implementation of
on NaN
using lt method
stack overflow
static overloading
strict evaluation
strict
vals
structural equality
equals method and hashCode method
generated
subclass
sum method
on trait
Iterable
superclass
superclass constructor
T
target methods
template, definition of
temporary vals
thread safety
"to reach the unreachable star",
see unreachable code
toInt method
toSeq method
on trait Iterable
trait constructor
transformations
Scala Collections, features of
iteration order, determined by elements
map
preserving type
tuples
type aliases
type ascriptions
type bindings
type bounds
type checking
type constraints
type conversions
implicit
type declarations
type erasure
type inference
type mismatch
type parameters
type requirements
type signature
typeclass pattern
U
unary method (!)
on class Boolean
unboxing, of value types
by compiler using
unboxToBoolean method
on class BoxesRunTime
underscore character
as placeholder syntax
as wildcard symbol
underscore symbol
Uniform Access Principle
uninitialized fields
uninitialized values
uninitialized variables
uniqueness constraint
in
Set trait
in Scala collections library
Unit class
in default initial values
unit tests
default branch, of code path
uppercase variable names
constants
V
value classes
object allocation, avoiding
value conversions
value definition
value discarding
variable assignment
pattern matching
stable identifiers
variable initialization
variable names
lowercase
uppercase
variable patterns
lowercase variable names
Vector class
in Scala collections library
view
W
wildcard symbol
using underscore character
withDefault method
on class Map
withDefaultValue method
on class Map
withFilter method
on trait
FilterMonadic
Z
zipped method
on class List