A note on the digital index A link in an index entry is displayed as the section title in which that entry appears. Because some sections have multiple index markers, it is not unusual for an entry to have several links to the same section. Clicking on any link will take you directly to the place in the text in which the marker appears.
Symbols ! (exclamation point) ! method, sending messages to Actors, A Taste of Concurrency , Syntactic Sugar , Sending Messages to Actors !! method, sending messages to Actors, Effective Actors != (not equal) method, The == and != Methods != (not equal) operator, Conditional Operators encoding in Java identifiers, Scala Names in Java Code operator precedence, Precedence Rules " " (quotation marks, double) enclosing string literals, String Literals escaping in character literals, Character Literals triples of double quotes, bounding multi-line string
literals, String Literals # (pound sign) encoding in Java identifiers, Scala Names in Java Code use in type projections, Reserved Words $ (dollar sign) in identifiers, Operator? Operator? % (percent sign) encoding in Java identifiers, Scala Names in Java Code operator precedence, Precedence Rules & (ampersand) && (and) operator, Conditional Operators encoding in Java identifiers, Scala Names in Java Code operator precedence, Precedence Rules ' ' (quotation marks, single) enclosing character literals, Character Literals in symbol literals, Symbol Literals ( ) (parentheses) capture groups in regular expressions, Matching on Regular Expressions in method invocations,
dropping, Operator? Operator? omitting for by-name function parameter, Call by Name, Call by Value omitting in method definitions, When Accessor Methods and Fields Are Indistinguishable: The
Uniform Access Principle omitting in method invocations, Methods Without Parentheses and Dots substituting curly braces for in method call, A Taste of Concurrency * (asterisk) multiplication operator, encoding in Java
identifiers, Scala Names in Java Code operator precedence, Precedence Rules zero or more repetitions in production rule, A Payroll External DSL + (plus sign) ++ method, appending to lists, Precedence Rules encoding in Java identifiers, Scala Names in Java Code operator precedence, Precedence Rules specifying at least one repetition in production
rule, A Payroll External DSL variance annotations, Variance Under Inheritance , Variance Under Inheritance - (minus sign) encoding in Java identifiers, Scala Names in Java Code operator precedence, Precedence Rules variance annotations, Variance Under Inheritance , Variance Under Inheritance -> (right arrow) operator, Tuples . (dot) infix operator notation, Infix Operator Notation omitting in method calls, Operator? Operator? , Methods Without Parentheses and Dots period-delimited path expressions, path.x / (slash) /* */ in multi-line comments, A Taste of Scala // in single-line comments, A Taste of Scala division operator, encoding in Java
identifiers, Scala Names in Java Code operator precedence, Precedence Rules : (colon) :: (constructor) method extracting head and tail of list, Matching on Sequences prepending to a list, Precedence Rules :: class, A Closer Look at Lists : (foldRight) and :/ (foldLeft), Folding and Reducing encoding in Java identifiers, Scala Names in Java Code methods ending in, right-associative
invocation, Precedence Rules operator precedence, Precedence Rules separator between identifiers and type
annotations, A Taste of Scala , Reserved Words ; (semicolon) ending production rule definitions, A Payroll External DSL ending statements in Scala code, Semicolons separators in for expression, Filtering < > (angle brackets) < (less than) operator, Conditional Operators encoding in Java identifiers, Scala Names in Java Code <% indicating view bound in type declaration, Reserved Words , Views and View Bounds <- (left-arrow) operator, generators, Reserved Words , A Dog-Simple Example , Generator Expressions <:, use in parameterized and abstract type
declarations, Reserved Words > (greater than) operator, Conditional Operators encoding in Java identifiers, Scala Names in Java Code >:, constraining allowed types in parameterized and
abstract type declarations, Reserved Words in method names, A Taste of Scala operator precedence, Precedence Rules = (equals sign) == (equals) method, The == and != Methods == (equals) operator, Conditional Operators , Case Classes => in function literals, Reserved Words assignment operator, Reserved Words encoding in Java identifiers, Scala Names in Java Code in method
definitions, A Taste of Scala , Method Declarations missing, Inferring Type Information operator precedence, Precedence Rules ? (question mark) encoding in Java identifiers, Scala Names in Java Code @ (at sign) encoding in Java identifiers, Scala Names in Java Code extracting value of XML attributes, Exploring XML marking annotations, Reserved Words [ ] (square brackets) enclosing optional items in parser grammar, A Payroll External DSL use with parameterized types, A Taste of Scala , Inferring Type Information , Abstract Types And Parameterized Types (backslash) in character escape
sequences, Character Literals encoding in Java identifiers, Scala Names in Java Code escaping double quotes in string literals, String Literals projection functions, Exploring XML and \ operators for document structures, Syntactic Sugar ^ (caret) encoding in Java identifiers, Scala Names in Java Code operator precedence, Precedence Rules _ (underscore) in identifiers, Operator? Operator? method chaining and function-literal shorthands, A Taste of Scala placeholder in imports, function literals, etc., A Taste of Scala , Reserved Words reserved word, Operator? Operator? wildcard character in Scala, A Taste of Concurrency , Importing Types and Their Members , A Simple Match `` (back quotes) in literals, Operator? Operator? { } (curly braces) enclosing class body, A Taste of Scala enclosing for expressions, Yielding in method
declarations, Method Declarations substituting for parentheses in method call, A Taste of Concurrency { indicating more code on next line, Semicolons | (vertical bar) encoding in Java identifiers, Scala Names in Java Code operator precedence, Precedence Rules or case in parser grammar, A Scala Implementation of the External DSL Grammar || (or) operator, Conditional Operators ~ (tilde) case class defined by Parsers trait, A Scala Implementation of the External DSL Grammar encoding in Java identifiers, Scala Names in Java Code ~, ~>, and <~ combinator operators, A Scala Implementation of the External DSL Grammar A abstract classes, A Taste of Concurrency abstract keyword, Stackable Traits abstract type members, Introducing Scala , Overriding Members of Classes and Traits overriding abstract methods, Overriding Abstract and Concrete Methods abstract types, Abstract Types And Parameterized Types , Understanding Abstract Types –Parameterized Types Versus Abstract Types combined with self-type annotations, Mixin Composition defined, Glossary overriding, Overriding Abstract Types –Overriding Abstract Types parameterized types versus, Parameterized Types Versus Abstract Types abstraction, Glossary access modifier keywords, Visibility Rules Actors, Introducing Scala , Actors –Effective Actors in abstract, Actors in Abstract Actor class, Actors in Scala Actor class and object, A Taste of Concurrency Actor model of concurrency, Glossary defined, Glossary effective use of, Effective Actors example, A Taste of Concurrency –A Taste of Concurrency example using sleeping barber problem, Actors in Depth –Actors in Depth factory method for creating, Actors in Scala mailbox, The Mailbox methods, listed, Effective Actors sending messages to, Sending Messages to Actors shortcut operators used with, Syntactic Sugar using with MINA NIO and Naggati library for SMTP
server, Events –Events actors.maxPoolSize system property, Events advice (in AOP), AspectJ alternative composition, A Payroll External DSL and operator (&&), Conditional Operators annotated types, Annotated Types , Annotated Types , Glossary Annotation class, Annotations Scala annotations derived from, Annotations annotations, Annotations –Annotations advantages and disadvantages of, Thoughts On Annotations and Enumerations available only in Scala version 2.8 or later, Annotations defined, Glossary nesting, Annotations Scala annotations derived from Annotation, Annotations Scala annotations derived from
StaticAnnotation, Annotations @scala.reflect.BeanProperty, JavaBean Properties , The Spring Framework anonymous classes creating, Traits As Mixins Ant, Scala plugin for, Build Tools Any class, Parent Classes != (not equal) method, The == and != Methods == (equals) method, The == and != Methods Any object, The Scala Type Hierarchy AnyRef class == (equals) method, The == and != Methods eq and ne methods, The ne and eq Methods AnyRef object, The Scala Type Hierarchy direct and indirect subtypes, The Scala Type Hierarchy reflection methods, Reflecting on Types AnyVal object, The Scala Type Hierarchy direct subtypes, The Scala Type Hierarchy AnyVal types, conversion to Java primitives, AnyVal Types and Java Primitives AOP (see aspect-oriented programming) Apache MINA, Events application design, Application Design –Recap and What’s Next annotations, Annotations –Annotations Design by Contract, Better Design with Design By Contract design patterns, Design Patterns –Dependency Injection in Scala: The Cake Pattern effective trait design, Effective Design of Traits –Effective Design of Traits enumerations versus case classes and pattern
matching, Thoughts On Annotations and Enumerations enumerations versus pattern matching, Enumerations Versus Pattern Matching –Enumerations Versus Pattern Matching exceptions and alternatives, Exceptions and the Alternatives nulls versus Options, Using Nulls Versus Options scalable abstractions, Scalable Abstractions applications, Glossary apply method, Apply –Apply for collections, Apply and UnapplySeq for Collections objects with, considered as functions, Function Types arity, Glossary Array class apply method, Apply sameElements method, Array Equality and the sameElements Method Array object, apply method overloaded for AnyVal and AnyRef
types, Upper Type Bounds ArrayBuffer object, Mapping arrays, comparing for equality, Array Equality and the sameElements Method arrow operator (<-), A Dog-Simple Example , Generator Expressions ArrowAssoc class, The Predef Object aspect-oriented programming (AOP), Introducing Traits , AspectJ defined, Glossary AspectJ library, AspectJ –AspectJ , Glossary AtomFeed class (example), A Real-World Example attributes, Class and Object Basics , Glossary auxiliary constructors, Constructors in Scala , Glossary B bang method (see ! (exclamation point), under Symbols) base classes, Parent Classes base type, Glossary BDD (Behavior-Driven Development), Domain-Specific Languages BDD syntax provided by ScalaTest, ScalaTest defined, Glossary specification exercising combined Button and Subject
types, Traits As Mixins Specs library, Specs –Specs BigDecimal class, Internal DSLs blogging system (example), A Real-World Example –A Real-World Example AtomFeed class, A Real-World Example boolean literals, Boolean Literals bound variables, Glossary break method, Generator Expressions build tools, Build Tools Buildr tool, Build Tools by-name parameters, Call by Name, Call by Value , Views and View Bounds defined, Glossary by-value parameters, Call by Name, Call by Value defined, Glossary C C# abstract methods, A Taste of Concurrency override keyword for concrete methods, A Taste of Concurrency this keyword, A Taste of Concurrency C++ multiple inheritance, Effective Design of Traits templates, Annotations C.super type, C.super C.this type, C.this Cake Pattern, Dependency Injection in Scala: The Cake Pattern –Dependency Injection in Scala: The Cake Pattern call site (see declaration site) call-by-name parameters, Function Types capture groups, defining in regular expressions, Matching on Regular Expressions case classes, Case Classes –Case Class Inheritance binary operations, Syntactic Sugar for Binary Operations copy method in Scala 2.8, The copy Method in Scala Version 2.8 defined, Glossary defining for pattern matching, Matching on Case Classes enumerations as alternative to, Enumerations Versus Pattern Matching enumerations versus, Thoughts On Annotations and Enumerations inheritance, Case Class Inheritance , The Visitor Pattern: A Better Alternative pattern matching on, Matching on Case Classes case clauses, binding nested variables in, Binding Nested Variables in Case Clauses case keyword, Glossary case class example, Case Classes case objects, Actors in Depth case statements pattern matching versus, A Simple Match cases in pattern matching, Matching on Tuples (and Guards) unreachable case, A Simple Match character literals, Character Literals characters operator characters, encoding in Java, Scala Names in Java Code used in identifiers, Operator? Operator? child types, Glossary class keyword, A Taste of Scala , Class and Object Basics classes abstract, A Taste of Concurrency , Abstract Types And Parameterized Types adding new methods to, Implicit Conversions basics of, Basic Object-Oriented Programming in
Scala declaration of classes as singletons, Classes and Objects: Where Are the Statics? defined, Glossary derived, overriding vals declared in parent
classes, Variable Declarations JDK and .NET, use in Scala, Installing Scala nested, Nested Classes overriding abstract and concrete fields in, Overriding Abstract and Concrete Fields in Classes overriding abstract and concrete methods, Overriding Abstract and Concrete Methods parent, Class and Object Basics sealed class hierarchies, Sealed Class Hierarchies –Sealed Class Hierarchies traits versus, Class or Trait? Upper class (example), A Taste of Scala ClassfileAnnotation class, Annotations Clickable trait (example), Stackable Traits clients, Glossary closures, Function Literals and Closures defined, Introducing Scala , Glossary CLR (Common Language Runtime), Scala running
on, Introducing Scala code examples in this book, Getting the Code Examples , For More Information code, organizing in files and namespaces, Organizing Code in Files and Namespaces codec for SMTP (example), Events collections apply and unapplySeq methods, Apply and UnapplySeq for Collections mutable and immutable, The Scala Type Hierarchy command-line tools, Command-Line Tools –The fsc Command-Line Tool information on, For More Information sbaz, The sbaz Command-Line Tool scala, The scala Command-Line Tool –Limitations of scala versus scalac scalac, scalac Command-Line Tool scaladoc, The scaladoc Command-Line Tool scalap, javap, and jad, The scalap, javap, and jad Command-Line Tools comments, A Taste of Scala , Glossary companion classes, Companion Objects defined, Glossary companion objects, Companion Objects –Companion Objects and Java Static Methods apply and unapplySeq methods for collections, Apply and UnapplySeq for Collections apply method, Apply –Apply conversion methods defined in, Implicit Conversions creation for case classes, Case Classes defined, Glossary Java static methods and, Companion Objects and Java Static Methods Map and Set, The Predef Object methods defined in, visibility to Java code, Using Scala Functions in Java Pair object for Pair class, The Predef Object unapply method, Unapply –Unapply compiled, command-line tool, converting script to, A Taste of Scala compiler (see scalac compiler) compiling versus interpreting, A Taste of Scala component model, functional programming and, Recap: Functional Component Abstractions components defined, Scalable Abstractions , Glossary fine-grained visibility rules in Scala, Fine-Grained Visibility Rules implementing as traits, Dependency Injection in Scala: The Cake Pattern compound types, Compound Types defined, Glossary comprehensions, Scala for Comprehensions concrete types, Glossary concurrency, A Taste of Concurrency –A Taste of Concurrency Actor model of, Glossary event-based, Glossary Java and, If You Are a Java Programmer… problems of shared, synchronized state, The Problems of Shared, Synchronized State traditional, using threading and events, Traditional Concurrency in Scala: Threading and Events –Events events, Events –Events one-off threads, One-Off Threads using java.util.concurrent, Using java.util.concurrent using Actors, Actors –Effective Actors Actors in abstract, Actors in Abstract Actors in Scala, Actors in Scala –Effective Actors conditional operators, Conditional Operators Console.println( ) method, A Taste of Scala constant identifiers, Operator? Operator? constants default argument values, Method Default and Named Arguments (Scala Version 2.8) defining, Classes and Objects: Where Are the Statics? constructors, A Taste of Concurrency , Constructors in Scala –Calling Parent Class Constructors case class, Case Classes constraints on, advantages and disadvantage of, Constructors in Scala parent class constructors, calling, Calling Parent Class Constructors context-free grammars, External DSLs with Parser Combinators , Glossary contract, Variance Under Inheritance defined, Glossary contractual constraints in Design by Contract, Better Design with Design By Contract contravariance or contravariant, Glossary contravariant subclassing, Variance Under Inheritance covariance or covariant, Glossary covariant specialization, Self-Type Annotations and Abstract Type Members covariant subclassing, Variance Under Inheritance @cps (continual passing style)
annotation, Annotations cross-cutting concerns, Glossary cross-platform installer (lzPack), Installing Scala curried functions, Currying , Function Types currying, Glossary D data types, The Scala Type System –Recap and What’s Next abstract, Abstract Types And Parameterized Types , Understanding Abstract Types parameterized types versus, Parameterized Types Versus Abstract Types AnyVal types, conversion to Java primitives, AnyVal Types and Java Primitives defined, Glossary documentation for Scala type system, Recap and What’s Next existential types, Existential Types importing types and their members, Importing Types and Their Members inferring type information, Inferring Type Information –Inferring Type Information infinite data structures and lazy vals, Infinite Data Structures and Laziness Nothing and Null, Nothing and Null parameterized types, Abstract Types And Parameterized Types , Understanding Parameterized Types path-dependent types, Path-Dependent Types pattern matching on type, Matching on Type reflection, Reflecting on Types Scala’s sophisticated type system, Introducing Scala self-type annotations, Self-Type Annotations –Self-Type Annotations static versus dynamic typing, If You Are a Ruby, Python, etc. Programmer… structural types, Traits As Mixins , Structural Types type bounds, Type Bounds –Views and View Bounds type hierarchy in Scala, The Scala Type Hierarchy value types, Value Types –Self-Type Annotations variance under inheritance, Variance Under Inheritance variance in Scala versus Java, Variance In Scala Versus Java –Variance In Scala Versus Java variance of mutable types, Variance of Mutable Types decimal integer literals, Integer Literals declaration site, Variance Under Inheritance , Glossary declarations annotations in, Annotations –Annotations order of declaration, traits and, Stackable Traits visibility modifiers in, Visibility Rules declarative composition of traits, Stackable Traits declarative programming, Glossary decompilers (scalap, javap, and jad), The scalap, javap, and jad Command-Line Tools deep matching, Matching on Case Classes def keyword, A Taste of Scala , Method Declarations default argument value, Glossary definitions, method, Method Declarations dependency injection (DI) defined, Glossary Spring Framework, The Spring Framework using Cake Pattern, Dependency Injection in Scala: The Cake Pattern –Dependency Injection in Scala: The Cake Pattern derived types, Glossary access to members of parent types, Visibility Rules Design by Contract, Variance Under Inheritance , Better Design with Design By Contract BankAccountSpec object (example), Better Design with Design By Contract defined, Glossary design patterns, Design Patterns –Dependency Injection in Scala: The Cake Pattern , Glossary alternative to Visitor Pattern, The Visitor Pattern: A Better Alternative –Dependency Injection in Scala: The Cake Pattern dependency injection (DI) implementation, Cake
Pattern, Dependency Injection in Scala: The Cake Pattern –Dependency Injection in Scala: The Cake Pattern diamond of death (problem with multiple
inheritance), Effective Design of Traits do-while loops, Scala do-while Loops documentation Scala tools and APIs, For More Information Scala type system, Recap and What’s Next DSLs (Domain-Specific Languages), Domain-Specific Languages , Domain-Specific Languages in Scala –Recap and What’s Next benefits and drawbacks of, Domain-Specific Languages in Scala defined, Glossary external DSLs with parser combinators, External DSLs with Parser Combinators –Generating Paychecks with the External DSL generating paychecks with external DSL, Generating Paychecks with the External DSL –Generating Paychecks with the External DSL parser combinators, About Parser Combinators payroll external DSL, A Payroll External DSL –A Payroll External DSL Scala implementation of external DSL grammar, A Scala Implementation of the External DSL Grammar –A Scala Implementation of the External DSL Grammar internal DSL for payroll application (example), Internal DSLs –Internal DSLs: Final Thoughts apply methods, Apply Methods implicit conversions and user-defined types, Implicit Conversions and User-Defined Types infix operator notation, Infix Operator Notation payroll API, Internal DSLs –A Payroll Internal DSL payroll internal DSL, A Payroll Internal DSL payroll rules DSL implementation, Payroll Rules DSL Implementation –Payroll Rules DSL Implementation internal versus external, Internal Versus External DSLs: Final Thoughts duck typing, Structural Types defined, Glossary dynamic typing, Glossary versus static typing, If You Are a Ruby, Python, etc. Programmer… dynamically typed languages, If You Are a Ruby, Python, etc. Programmer… E eager matching, A Simple Match EBNF (Extended Backus-Naur Form) grammar notation, External DSLs with Parser Combinators external payroll DSL grammar, A Payroll External DSL Eclipse IDE developing Scala applications, Developing Scala applications installing Scala plugin, Eclipse Eiffel language, Better Design with Design By Contract Either object, The Scala Type Hierarchy else clause (if statements), Scala if Statements Emacs editor, Text Editors encapsulation defined, Glossary visibility rules and, Visibility Rules Ensuring class, Better Design with Design By Contract enumerated types, Enumerations Enumeration class, Enumerations Enumeration.Value class, Enumerations Versus Pattern Matching enumerations, Enumerations , Enumerations Versus Pattern Matching –Enumerations Versus Pattern Matching advantages and disadvantages of, Thoughts On Annotations and Enumerations case classes and pattern matching versus, Thoughts On Annotations and Enumerations HttpMethod object (example), Enumerations Versus Pattern Matching –Enumerations Versus Pattern Matching scala.Enumeration class, Enumerations Versus Pattern Matching eq method (AnyRef), The ne and eq Methods equality of objects, Equality of Objects equals method, The equals Method case class comparisons, Case Class Inheritance equals operator (==), Conditional Operators events, Glossary using for concurrency, Events –Events , Glossary exception handling, pattern matching using try, catch, and
finally clauses, Using try, catch, and finally Clauses exceptions @throws annotation and, Annotations @unchecked annotation and, Annotations and alternatives to, Exceptions and the Alternatives throwing, Using try, catch, and finally Clauses executing a script, A Taste of Scala existential types, Views and View Bounds , Existential Types defined, Glossary examples of, Existential Types expectations, Specs exponentials with floating-point literals, Floating-Point Literals expressions for expression, Scala for Comprehensions if statements as, Scala if Statements extends keyword, Traits As Mixins , Parent Classes external DSLs, Domain-Specific Languages in Scala , External DSLs with Parser Combinators (see also DSLs) internal DSLs versus, Internal Versus External DSLs: Final Thoughts extractors, Glossary translating regular expression capture groups
to, Matching on Regular Expressions unapply methods, Unapply use in pattern matching case statements, Case Classes F factory methods, apply method as, Apply family polymorphism, Self-Type Annotations and Abstract Type Members Fibonacci sequence, calculating, Infinite Data Structures and Laziness fields, Class and Object Basics comparison to Java class-level, Classes and Objects: Where Are the Statics? defined, Glossary indistinguishable from accessor methods,
overriding, When Accessor Methods and Fields Are Indistinguishable: The
Uniform Access Principle –When Accessor Methods and Fields Are Indistinguishable: The
Uniform Access Principle mutable, A Taste of Concurrency order of initialization, using lazy vals, Lazy Vals overriding abstract and concrete fields, Overriding Abstract and Concrete Fields overriding abstract and concrete fields in
classes, Overriding Abstract and Concrete Fields in Classes overriding abstract and concrete fields in
traits, Overriding Abstract and Concrete Fields in Traits –Overriding Abstract and Concrete Fields in Traits referencing object field, Classes and Objects: Where Are the Statics? visibility and access to, Visibility Rules filtering in for expressions, Filtering in functional programming, Filtering final declarations, attempting to override, Attempting to Override final Declarations final keyword, Glossary finishing problem (in DSL design), Internal DSLs: Final Thoughts first class, Glossary floating-point literals, Floating-Point Literals fluent interface, Payroll Rules DSL Implementation folding data structures, Folding and Reducing –Folding and Reducing for comprehensions, Scala for Comprehensions –Expanded Scope expanded variable scope, Expanded Scope filters in, Filtering simple example, A Dog-Simple Example using Options with, Options and for Comprehensions yielding collections, Yielding yielding successive blocks of dynamically formatted
XML, A Real-World Example foreach method, Traits As Mixins traversal operations in functional
programming, Traversal formal parameters, Glossary FP (see functional programming) free variables, Glossary fsc (fast scala compiler) tool, The fsc Command-Line Tool function literals, Traits As Mixins closures and, Function Literals and Closures defined, A Taste of Scala , Glossary passing to foreach, A Taste of Scala passing to method for pattern matching, A Taste of Concurrency function types, Function Types defined, Glossary Function.curried method, Currying Functional Java project, ScalaCheck functional programming, Functional Programming in Scala –Recap: Functional Component Abstractions , Glossary call by name and call by value, Call by Name, Call by Value component model and, Recap: Functional Component Abstractions currying, Currying data structures, Functional Data Structures lists, Lists in Functional Programming maps, Maps in Functional Programming definition of, What Is Functional Programming? filtering operations, Filtering folding and reducing operations, Folding and Reducing –Folding and Reducing functions in mathematics, Functions in Mathematics implicit conversions, Implicits implicit function parameters, Implicit Function Parameters implicits, caution with, Final Thoughts on Implicits lazy vals, Lazy Vals mapping operations, Mapping mixed paradigm in Scala, Introducing Scala Options object, Functional Options partial functions, Partial Functions pattern matching, Pattern Matching recursion, Recursion in Scala, Functional Programming in Scala –Purity Inside Versus Outside function literals and closures, Function Literals and Closures tail calls and tail-call optimization, Tail Calls and Tail-Call Optimization traversal of data structures, Traversal variables, immutable values of, Variables that Aren’t FunctionN object, The Scala Type Hierarchy defining traits for, Function Types variance under inheritance, Variance Under Inheritance functions, Functional Programming in Scala (see also functional programming) defined, Glossary higher order, Functions in Mathematics , Glossary overloaded, Glossary Scala, using in Java, Using Scala Functions in Java futures, Effective Actors G Gang of Four (GOF) patterns, Design Patterns generator expressions, Generator Expressions generators <- (left-arrow) operator, A Dog-Simple Example defined, Glossary in for
comprehensions, Options and for Comprehensions generics, Introducing Scala , Java and Scala Generics –Java and Scala Generics defined, Glossary Java, Abstract Types And Parameterized Types using from Scala, Java and Scala Generics Scala, using from Java, Java and Scala Generics variance under inheritance, differences between Java and
Scala, Variance Under Inheritance grammars context-free, Glossary EBNF notation for external payroll DSL
grammar, A Payroll External DSL parsing expression grammars (PEGs), Glossary guards, pattern matching on, Matching on Tuples (and Guards) I I/O (input/output) automatic importation of methods by Scala, A Taste of Scala NIO (non-blocking I/O), Events identifiers, characters allowed in, Operator? Operator? IDEs (integrated development environments), Integration with IDEs –Text Editors Eclipse developing Scala applications, Developing Scala applications installing Scala plugin, Eclipse IntelliJ developing Scala applications, Developing Scala applications installing Scala plugins, IntelliJ NetBeans developing Scala applications, Developing Scala applications installing Scala plugins, NetBeans text editors, Text Editors if statements, Scala if Statements immutable values, Glossary immutable variables, Introducing Scala declaring, Variable Declarations imperative languages, A Taste of Concurrency imperative programming, Glossary implicit arguments, Glossary implicit conversions caution with, Final Thoughts on Implicits defined, Glossary defining custom object and conversion method, Implicit Conversions in functional
programming, Implicits in internal DSL payroll implementation, Implicit Conversions and User-Defined Types Int into RichInt, Generator Expressions Predef.any2ArrowAssoc method, The Predef Object rules for compiler to find and use conversion
methods, Implicit Conversions implicit function parameters, Implicit Function Parameters caution with, Final Thoughts on Implicits implicit keyword, Implicits defined, Glossary implicit typing, Glossary import statements, A Taste of Concurrency importing Java types and their members, Importing Types and Their Members relative path used in, Imports are Relative infinite data structures, Glossary laziness and, Infinite Data Structures and Laziness using lazy vals to manage, Lazy Vals infix notation, Operator? Operator? defined, Glossary infix operator notation, Infix Operator Notation infix types, Infix Types , Glossary inheritance case class, Case Class Inheritance defined, Glossary definition, Class or Trait? linearization of object hierarchy, Linearization of an Object’s Hierarchy –Linearization of an Object’s Hierarchy multiple, problems with, Effective Design of Traits single inheritance plus traits in Scala, Effective Design of Traits variance under, Variance Under Inheritance –Implementation Notes instance, Class and Object Basics , Glossary instantiate, Glossary integer literals, Integer Literals IntelliJ IDEA developing Scala applications, Installing the Scala plugins installing Scala plugins, IntelliJ interactive mode, scala command, A Taste of Scala @interface keyword
(Java), Annotations internal DSLs, Domain-Specific Languages in Scala , Internal DSLs: Final Thoughts (see also DSLs) external DSLs versus, Internal Versus External DSLs: Final Thoughts interned strings, Symbol Literals interpreter, starting, A Taste of Scala interpreting versus compiling, A Taste of Scala invariance and invariant, Glossary invariant subclassing, Variance Under Inheritance invariants, Better Design with Design By Contract inversion of control (IoC), Dependency Injection in Scala: The Cake Pattern , Glossary IOHandlerActorAdapter object, Events Iterable object, Traversal filtering methods, Filtering fold and reduce methods, Folding and Reducing map method, Mapping Iterator Pattern, Design Patterns J jad tool, The scalap, javap, and jad Command-Line Tools Java, If You Are a Java Programmer… annotations, Annotations aspect-oriented programming, AspectJ, Introducing Traits DI (dependency injection), Dependency Injection in Scala: The Cake Pattern importation of data types into Scala, Importing Types and Their Members interfacing with type system, using existential
types, Existential Types invoking method name identical to Scala reserved
word, Operator? Operator? JDK (Java Development Kit), Introducing Scala JVM (Java Virtual Machine), If You Are a Java Programmer… reflection methods, Reflecting on Types libraries, interoperability with Scala, Java Library Interoperability –Hadoop AspectJ, AspectJ –AspectJ Hadoop, Hadoop Spring Framework, The Spring Framework Terracotta, Terracotta package concept for namespaces, Organizing Code in Files and Namespaces regular expressions, Matching on Regular Expressions Scala interoperability with, Java Interoperability –Scala Names in Java Code AnyVal types and Java primitives, AnyVal Types and Java Primitives Java and Scala generics, Java and Scala Generics JavaBean properties, JavaBean Properties Scala names in Java code, Scala Names in Java Code using Scala functions in Java, Using Scala Functions in Java static methods, companion objects and, Companion Objects and Java Static Methods –Companion Objects and Java Static Methods static typing, If You Are a Ruby, Python, etc. Programmer… variance, Variance In Scala Versus Java –Variance In Scala Versus Java java command, scalac Command-Line Tool java.io.IOException class, Annotations java.lang.String class, Implicit Conversions java.nio package, Events java.util.concurrent package, Using java.util.concurrent JavaBeans conventions for, JavaBean Properties , The Spring Framework vetoable events, Stackable Traits javac compiler, Introducing Scala Javadoc-style @return annotation, Generating Paychecks with the External DSL javap tool, The scalap, javap, and jad Command-Line Tools JavaRebel tool, JavaRebel JavaTokenParsers, A Scala Implementation of the External DSL Grammar JDK (Java Development Kit), Introducing Scala join points, AspectJ JUnit, Traits As Mixins running specifications, Specs JVM (Java Virtual Machine), If You Are a Java Programmer… JVM version of Scala, Introducing Scala installing, Installing Scala L lazy evaluation, infinite data structures and, Infinite Data Structures and Laziness lazy values, Overriding Abstract and Concrete Fields in Traits , Lazy Vals Post class (example), A Real-World Example lazy, defined, Glossary left-associative method invocations, Precedence Rules libraries Java library interoperability, Java Library Interoperability –Hadoop AspectJ, AspectJ –AspectJ Hadoop, Hadoop Spring Framework, The Spring Framework Terracotta, Terracotta miscellaneous smaller Scala libraries, Miscellaneous Smaller Libraries notable Scala libraries, Other Notable Scala Libraries and Tools Lift web framework, Lift linearization of object hierarchy, Linearization of an Object’s Hierarchy –Linearization of an Object’s Hierarchy , C.super , Glossary algorithm for reference types, Linearization of an Object’s Hierarchy hand calculation for C2 (example), Linearization of an Object’s Hierarchy LinkedList class that uses Nodes (example), Views and View Bounds Liskov Substitution Principle, Class or Trait? List class apply and unapplySeq methods, Apply and UnapplySeq for Collections declaration, Abstract Types And Parameterized Types Nil case object, Nothing and Null Scala implementation, A Closer Look at Lists –A Closer Look at Lists List object apply method, parameterized, Parameterized Methods folding, Folding and Reducing lists in functional programming, Lists in Functional Programming literals, Literals –Symbol Literals boolean, Boolean Literals character, Character Literals defined, Glossary floating-point, Floating-Point Literals integer, Integer Literals string, String Literals symbol, Symbol Literals load-time weaving, AspectJ loops do-while, Scala do-while Loops for loops or comprehensions, Scala for Comprehensions –Expanded Scope generator expressions in, Generator Expressions looping through and matching XML, Looping and Matching XML trampoline, Trampoline for Tail Calls while, Scala while Loops lower type bounds, Lower Type Bounds , Understanding Abstract Types M Mac OS X installing Scala, Installing Scala TextMate editor, Text Editors mailbox for Actors, The Mailbox , Glossary main method, A Taste of Scala , Glossary Manifests, Manifests Map companion object, The Predef Object Map values, The Predef Object Map.apply method, The Predef Object , Mapping MapReduce, Hadoop , Glossary maps in functional programming, Maps in Functional Programming MatchError object, Sealed Class Hierarchies mathematics, functions in, Functions in Mathematics Maven build tool, Build Tools members, Class and Object Basics , Glossary importing, Importing Types and Their Members memoization, Purity Inside Versus Outside , Glossary support by packrat parsers, Internal Versus External DSLs: Final Thoughts messages, Glossary metadata, Annotations (see also annotations) adding to declarations, Annotations default values and, Annotations metaprogramming, The Seductions of Scala MetaScala library, MetaScala method chaining, Infix Operator Notation methods, Class and Object Basics abstract types as arguments, Parameterized Types Versus Abstract Types adding new methods to classes, Implicit Conversions class-level, Classes and Objects: Where Are the Statics? declarations, Method Declarations –Nesting Method Definitions default and named arguments, Method Default and Named Arguments (Scala Version 2.8) nesting method definitions, Nesting Method Definitions defined, Glossary defining, A Taste of Scala Java static methods and companion objects, Companion Objects and Java Static Methods –Companion Objects and Java Static Methods , Using Scala Functions in Java operators as, Operator? Operator? infix notation, Operator? Operator? overriding, Overriding Abstract and Concrete Methods overriding accessor methods indistinguishable from
fields, When Accessor Methods and Fields Are Indistinguishable: The
Uniform Access Principle –When Accessor Methods and Fields Are Indistinguishable: The
Uniform Access Principle parameterized, Parameterized Methods without parentheses and
dots, Methods Without Parentheses and Dots operator precedence, Precedence Rules referencing object method, Classes and Objects: Where Are the Statics? Meyer, Bertrand, Better Design with Design By Contract MINA (Apache), Events events provided by, Events mixin composition, Introducing Scala , Mixin Composition , Effective Design of Traits using traits, Introducing Scala mixins, Introducing Traits defined, Glossary invasive, Effective Design of Traits traits as, Traits As Mixins –Traits As Mixins modules components and, Scalable Abstractions contract of, Better Design with Design By Contract multiple inheritance, Glossary mutable fields, A Taste of Concurrency mutable values, Glossary N Naggati library, Events named arguments, Method Default and Named Arguments (Scala Version 2.8) , Glossary namespaces, Organizing Code in Files and Namespaces relationship to Scala’s nested package syntax, Organizing Code in Files and Namespaces ne method (AnyRef), The ne and eq Methods nested classes, Nested Classes .NET invoking method name identical to Scala reserved
word, Operator? Operator? regular expressions, Matching on Regular Expressions .NET version of
Scala, Introducing Scala NetBeans developing Scala applications, Developing Scala applications installing Scala plugins, NetBeans new operator, A Taste of Scala Nil case object, Nothing and Null NIO (non-blocking I/O), Events NioSocketAcceptor object, Events NodeSeq class, and \ methods, Syntactic Sugar NodeSeq object, Reading XML None class, Option, Some, and None: Avoiding nulls nonterminals, A Payroll External DSL , Glossary Nothing type, Variance In Scala Versus Java , Nothing and Null Null object, Nothing and Null nulls avoiding using Option, Some, and None classes, Option, Some, and None: Avoiding nulls –Option, Some, and None: Avoiding nulls Options versus, Using Nulls Versus Options O object system (Scala), The Predef Object –Recap and What’s Next classes and objects, Classes and Objects: Where Are the Statics? package objects, Package Objects linearization of object hierarchy, Linearization of an Object’s Hierarchy –Linearization of an Object’s Hierarchy Predef object, The Predef Object sealed class hierarchies, Sealed Class Hierarchies –Sealed Class Hierarchies type hierarchy, The Scala Type Hierarchy object-oriented programming (OOP), Basic Object-Oriented Programming in
Scala case classes, Case Classes –Case Class Inheritance classes and objects, basics of, Basic Object-Oriented Programming in
Scala companion objects, Companion Objects –Companion Objects and Java Static Methods constructors, Constructors in Scala –Calling Parent Class Constructors defined, Glossary equality of objects, Equality of Objects mixed paradigm in Scala, Introducing Scala nested classes, Nested Classes overriding members of classes and traits, Advanced Object-Oriented Programming In Scala –When Accessor Methods and Fields Are Indistinguishable: The
Uniform Access Principle parent classes, Class and Object Basics reusable software components and, Recap: Functional Component Abstractions visibility rules, Visibility Rules –Final Thoughts on Visibility objects basics of, Basic Object-Oriented Programming in
Scala deep matching on contents, Matching on Case Classes defined, Glossary instantiation in Scala, Classes and Objects: Where Are the Statics? in Scala, Introducing Scala versus class-level members, A Taste of Scala ObservableClicks trait (example), Stackable Traits working with VetoableClicks trait (example), Stackable Traits Observer Pattern, Traits As Mixins , Design Patterns trait implementing, Traits As Mixins octal integer literals, Integer Literals Odersky, Martin, Introducing Scala , Introducing Scala Open-Closed Principle (OCP), Sealed Class Hierarchies violation by Visitor Pattern, The Visitor Pattern: A Better Alternative operator characters, Operator? Operator? defined, Glossary encoding in Java identifiers, Scala Names in Java Code in identifiers, Operator? Operator? operator notation, Glossary infix operator notation, Operator? Operator? , Infix Operator Notation operator overloading, Glossary operator precedence, Precedence Rules operators, Operator? Operator? conditional, Conditional Operators Option class, Option, Some, and None: Avoiding nulls –Option, Some, and None: Avoiding nulls alternatives to exceptions, Exceptions and the Alternatives functional operations on, Functional Options nulls versus, Using Nulls Versus Options using with for comprehensions, Options and for Comprehensions or operator (||), Conditional Operators overloaded functions, Glossary overloaded methods, Class and Object Basics explicit return type requirement, Inferring Type Information override keyword, A Taste of Concurrency , Traits As Mixins , Overriding Members of Classes and Traits overriding class and trait members, Overriding Members of Classes and Traits –When Accessor Methods and Fields Are Indistinguishable: The
Uniform Access Principle abstract and concrete fields, Overriding Abstract and Concrete Fields in classes, Overriding Abstract and Concrete Fields in Classes in traits, Overriding Abstract and Concrete Fields in Traits –Overriding Abstract and Concrete Fields in Traits abstract and concrete methods, Overriding Abstract and Concrete Methods abstract types, Overriding Abstract and Concrete Fields in Classes –Overriding Abstract Types accessor methods indistinguishable from
fields, When Accessor Methods and Fields Are Indistinguishable: The
Uniform Access Principle –When Accessor Methods and Fields Are Indistinguishable: The
Uniform Access Principle final declarations, Attempting to Override final Declarations P package objects, Package Objects , Glossary packages, Organizing Code in Files and Namespaces defining using nested package syntax in Scala, Organizing Code in Files and Namespaces root package for Scala library classes, Organizing Code in Files and Namespaces packrat parsers, Internal Versus External DSLs: Final Thoughts , Glossary Pair class, The Predef Object apply method, Apply Pair object, The Predef Object parameterized methods, Parameterized Methods parameterized types, A Taste of Scala , Abstract Types And Parameterized Types , Understanding Parameterized Types abstract types versus, Parameterized Types Versus Abstract Types defined, Glossary Manifests, Manifests parameterized methods, Parameterized Methods value types created from, Parameterized Types parameters constructor, initialization of vals and vars, Variable Declarations implicit function parameters, Implicit Function Parameters order of, named arguments and, Method Default and Named Arguments (Scala Version 2.8) required return type annotations, Inferring Type Information parent classes, Parent Classes , Glossary parser combinators, external DSLs with, External DSLs with Parser Combinators –Generating Paychecks with the External DSL generating paychecks with
PayrollParserCombinators, Generating Paychecks with the External DSL –Generating Paychecks with the External DSL payroll external DSL, A Payroll External DSL –A Payroll External DSL Scala implementation of external DSL grammar, A Scala Implementation of the External DSL Grammar –A Scala Implementation of the External DSL Grammar Parsers object, A Scala Implementation of the External DSL Grammar documentation of composition operators, A Payroll External DSL ~ case class, A Scala Implementation of the External DSL Grammar parsing expression grammars (PEGs), Internal Versus External DSLs: Final Thoughts , Glossary partial application, Glossary partial functions, Partial Functions , Glossary path-dependent types, Path-Dependent Types , Glossary C.super, C.super C.this, C.this p.Success case class (example), A Scala Implementation of the External DSL Grammar period-delimited path expressions, path.x pattern matching, A Taste of Concurrency , Pattern Matching –Concluding Remarks on Pattern Matching binding nested variables in case clauses, Binding Nested Variables in Case Clauses on case classes, Matching on Case Classes defined, Glossary on enumerations, Enumerations Versus Pattern Matching extractors in case statements, Case Classes in functional
programming, Pattern Matching matching on tuples and guards, Matching on Tuples (and Guards) polymorphism versus, A Taste of Concurrency on regular
expressions, Matching on Regular Expressions on sequences, Matching on Sequences simple match of boolean values, A Simple Match on type, Matching on Type using on XML structures, Looping and Matching XML using try, catch, and finally clauses, Using try, catch, and finally Clauses using with case classes, enumerations versus, Thoughts On Annotations and Enumerations variables in matches, Variables in Matches pattern matching identifiers, Operator? Operator? payroll external DSL (example), A Payroll External DSL –A Payroll External DSL payroll internal DSL (example), A Payroll Internal DSL PEGs (parsing expression grammars), Internal Versus External DSLs: Final Thoughts , Glossary performance, Introducing Scala Pimp My Library design pattern, Implicit Conversions , Glossary plain identifiers, Operator? Operator? pointcuts, AspectJ polymorphism family polymorphism, Self-Type Annotations and Abstract Type Members pattern matching versus, A Taste of Concurrency , Concluding Remarks on Pattern Matching , Pattern Matching postconditions, Better Design with Design By Contract , Glossary postfix notation, Operator? Operator? , Glossary @Pre annotation, Annotations pre-initialized fields, Overriding Abstract and Concrete Fields in Traits precedence, operator, Precedence Rules preconditions, Better Design with Design By Contract , Glossary Predef object, The Predef Object any2ArrowAssoc method, The Predef Object declaring types and exceptions, The Predef Object documentation, The Predef Object implicit conversion methods for value types, The Scala Type Hierarchy items imported or defined by, The Predef Object require and assume methods, using for contract
enforcement, Better Design with Design By Contract stringWrapper method, Implicit Conversions primary constructor, Constructors in Scala , Glossary primitive data types, Glossary instances of value types corresponding to, Class and Object Basics Java, conversion of AnyVal types to, AnyVal Types and Java Primitives println function, A Taste of Scala , A Taste of Scala partially applied (example), Partial Functions private keyword, Constructors in Scala , Visibility Rules private visibility, Private Visibility scoped, Scoped Private and Protected Visibility –Scoped Private and Protected Visibility production, Glossary production rules, A Payroll External DSL projection functions, Exploring XML protected keyword, Visibility Rules protected visibility, Protected Visibility scoped, Scoped Private and Protected Visibility –Scoped Private and Protected Visibility public visibility, Public Visibility pure (side-effect-free functions), Glossary R Range object, Infinite Data Structures and Laziness Range.Inclusive class, Generator Expressions raw strings in regular expression pattern
matching, Matching on Regular Expressions recursion, Nesting Method Definitions , Glossary explicit return type annotation, Inferring Type Information , Inferring Type Information in functional
programming, Recursion tail-call, Tail Calls and Tail-Call Optimization foldLeft and reduceLeft, Folding and Reducing reducing data structures, Folding and Reducing –Folding and Reducing Reductio tool, ScalaCheck reference types, Class and Object Basics , Glossary linearization algorithm for, Linearization of an Object’s Hierarchy , Linearization of an Object’s Hierarchy listed, The Scala Type Hierarchy parent of, AnyRef, The Scala Type Hierarchy testing equality, The ne and eq Methods referential transparency, Glossary refinement in compound type declarations, Compound Types defined, Glossary reflection, Reflecting on Types Regex class, Matching on Regular Expressions regular expressions matching on, Matching on Regular Expressions use in parsing, A Scala Implementation of the External DSL Grammar reified types, Glossary relative imports, Imports are Relative REPL (Read, Evaluate, Print, Loop), Glossary Request case class, Events requirements specification, Specs reserved words listing of reserved words in Scala, Reserved Words not allowed in identifiers, Operator? Operator? @Retention annotation, Annotations @return annotation, Generating Paychecks with the External DSL return keyword, A Taste of Scala , Inferring Type Information return type for methods, Inferring Type Information –Inferring Type Information required explicit declarations of, Inferring Type Information using Option, Some, and None types, Option, Some, and None: Avoiding nulls RichInt class, Generator Expressions RichString class, Implicit Conversions right-associative method invocations, Precedence Rules Ruby dynamic typing, If You Are a Ruby, Python, etc. Programmer… exceptions, Exceptions and the Alternatives method resolution in, Structural Types S sbaz tool, For More Information , The sbaz Command-Line Tool installing ScalaCheck, ScalaCheck SBT (simple build tool), Build Tools Scala benefits of, The Seductions of Scala code examples, A Taste of Scala –A Taste of Scala combining with other languages, The Seductions of Scala installing, Installing Scala introduction to, Introducing Scala official website, Installing Scala resources for more information, For More Information scala command, For More Information , A Taste of Scala , The scala Command-Line Tool –Limitations of scala versus scalac -cp option, A Taste of Scala , The scala Command-Line Tool commands available in scala interactive mode, The scala Command-Line Tool documentation, The scala Command-Line Tool interactive mode, A Taste of Scala invoking scripts, The scala Command-Line Tool limitations of, versus scalac, Limitations of scala versus scalac options, The scala Command-Line Tool running in interpreted mode, The scala Command-Line Tool script or object specified for, The scala Command-Line Tool scala-tool-support package, Text Editors scala.actors.Actor class, Actors in Scala @scala.reflect.BeanProperty
annotation, JavaBean Properties , The Spring Framework scalability, Scala support for, Introducing Scala scalable abstractions (see components) scalable language (Scala), Introducing Scala scalac compiler, For More Information , scalac Command-Line Tool -X options, scalac Command-Line Tool -Xscript option, Limitations of scala versus scalac command options, scalac Command-Line Tool compiling code into JVM .class file, A Taste of Scala plugin architecture, scalac Command-Line Tool scala command versus, Limitations of scala versus scalac ScalaCheck, ScalaCheck scaladoc tool, For More Information , The scaladoc Command-Line Tool Scaladocs, Glossary ScalaObject class, The Scala Type Hierarchy $tag method, The scalap, javap, and jad Command-Line Tools , Glossary scalap tool, The scalap, javap, and jad Command-Line Tools ScalaTest, ScalaTest Scalax library, Scalax Scalaz library, Scalaz scope defined, Glossary expanded variable scope in for comprehensions, Expanded Scope package objects, Package Objects of private and protected
visibility, Scoped Private and Protected Visibility –Scoped Private and Protected Visibility scripting languages, popularity of, If You Are a Java Programmer… sealed class hierarchies, Sealed Class Hierarchies –Sealed Class Hierarchies sealed keyword, Glossary self types, Introducing Scala self-type annotations, Self-Type Annotations –Self-Type Annotations and abstract type members, Mixin Composition defined, Glossary TwitterClientComponent (example), Dependency Injection in Scala: The Cake Pattern Seq class, first and firstOption methods, Exceptions and the Alternatives sequences matching on, Matching on Sequences Range.Inclusive class, Generator Expressions sequential composition, A Payroll External DSL combinator operators, A Scala Implementation of the External DSL Grammar @serialVersionUID
annotation, Annotations Set companion object, The Predef Object Set values, The Predef Object sets in functional programming, Sets in Functional Programming short-circuiting operators (&& and ||), Conditional Operators side-effect-free, Glossary signature, Class and Object Basics , Glossary single inheritance, Glossary Single Responsibility Principle, Introducing Traits singleton objects, A Taste of Scala , Companion Objects and Java Static Methods eliminating need for Singleton Pattern, Design Patterns methods defined in companion objects, Using Scala Functions in Java singleton types, Singleton Types , Glossary singletons, Glossary Scala classes declared as, Classes and Objects: Where Are the Statics? sleeping barber problem (demonstrating Actors), Actors in Depth –Actors in Depth SMTP mail server (example), Events –Events codec for SMTP, Events conversation with server, Events setup, Events SmtpHandler class, Events Some class, Option, Some, and None: Avoiding nulls @specialized
annotation, Annotations Specs library, Domain-Specific Languages , Specs –Specs using for BDD specification exercising combined Button
and Subject types, Traits As Mixins Spring Framework, The Spring Framework stable types, Glossary state, Glossary static members, Scala and, Classes and Objects: Where Are the Statics? static typing, Glossary versus dynamic typing, If You Are a Ruby, Python, etc. Programmer… StaticAnnotation class, Annotations annotations derived from, Annotations Stream class, Infinite Data Structures and Laziness strict, Glossary String class, Implicit Conversions implicit conversion to RichString, Implicit Conversions string literals, String Literals strong versus weak typing, If You Are a Ruby, Python, etc. Programmer… structural types, Traits As Mixins , Structural Types defined, Glossary subtypes, Glossary , Glossary super keyword, Overriding Abstract and Concrete Methods supertype, Glossary @switch annotation, Annotations symbol literals, Symbol Literals symbols, Apply and UnapplySeq for Collections defined, Glossary in method names and other
identifiers, Operator? Operator? T $tag method (ScalaObject), The scalap, javap, and jad Command-Line Tools , Glossary tail calls, Tail Calls and Tail-Call Optimization @tailRec annotation and, Annotations foldLeft and reduceLeft operations, Folding and Reducing trampoline for, Trampoline for Tail Calls tail-call recursion, Glossary @tailRec annotation, Annotations TDD (Test-Driven Development), Traits As Mixins , Test-Driven Development in Scala –ScalaCheck defined, Glossary Design by Contract and, Better Design with Design By Contract ScalaCheck tool, ScalaCheck ScalaTest tool, ScalaTest Specs library, Specs –Specs terminals, A Payroll External DSL , Glossary Terracotta library, Terracotta test double, Glossary text editors, Text Editors TextMate editor, Text Editors this keyword, A Taste of Concurrency , Class and Object Basics self versus, in self-type annotations, Self-Type Annotations and Abstract Type Members self-type annotations, Self-Type Annotations super versus, Overriding Abstract and Concrete Methods threading in Scala, Traditional Concurrency in Scala: Threading and Events one-off threads, One-Off Threads using java.util.concurrent, Using java.util.concurrent @throws annotation, Annotations trait keyword, Traits As Mixins traits, Introducing Scala , Introducing Traits –Recap and What’s Next aspects versus, AspectJ constructing, Constructing Traits class or trait, Class or Trait? initializing values in traits, Constructing Traits defined, Glossary effective design of, Effective Design of Traits –Effective Design of Traits functions as instances of, Function Types implementing components with, Dependency Injection in Scala: The Cake Pattern as mixins, Traits As Mixins –Traits As Mixins vetoing click events, Stackable Traits overriding accessor methods indistinguishable from
fields, When Accessor Methods and Fields Are Indistinguishable: The
Uniform Access Principle overriding members of abstract and concrete fields, Overriding Abstract and Concrete Fields in Traits –Overriding Abstract and Concrete Fields in Traits promotion of mixin composition, Mixin Composition stacking, Stackable Traits trampolines, Trampoline for Tail Calls , Glossary try, catch, and finally clauses, Using try, catch, and finally Clauses tuples, Tuples defined, Glossary pattern matching on, Matching on Tuples (and Guards) value type, syntax for, Tuples ways to create two-item tuple, The Predef Object Twitter client, component model for (example), Dependency Injection in Scala: The Cake Pattern –Dependency Injection in Scala: The Cake Pattern type alias, Enumerations type annotations, A Taste of Scala defined, Glossary required explicit type annotations, Inferring Type Information self-type annotations, Self-Type Annotations –Self-Type Annotations type bounds, Variance In Scala Versus Java , Type Bounds –Views and View Bounds defined, Glossary List class, Scala implementation, A Closer Look at Lists –A Closer Look at Lists lower, Lower Type Bounds upper, Upper Type Bounds using in abstract type declarations, Understanding Abstract Types views and view bounds, Views and View Bounds type constructors, Glossary type designators, Type Designators , Glossary type erasure, Class and Object Basics defined, Glossary getClass method on JVM, Reflecting on Types type inference, Inferring Type Information –Inferring Type Information , Glossary type projections, Type Projections , Glossary type system, If You Are a Ruby, Python, etc. Programmer… , The Scala Type System (see also data types) Scala, Introducing Scala type variance, Variance Under Inheritance , Glossary (see also variance under inheritance) type variance annotations, Glossary types, The Scala Type System (see also data types) defined, Glossary typing, If You Are a Ruby, Python, etc. Programmer… V val keyword, A Taste of Scala in declaration of read-only
variable, A Taste of Scala using in declaration of immutable variable, Variable Declarations vals, lazy (see lazy values) Value class, Enumerations Versus Pattern Matching Value object, Glossary value types, Class and Object Basics , Value Types defined, Glossary function types, Function Types implicit conversions by Predef object methods, The Scala Type Hierarchy infix types, Infix Types listed, The Scala Type Hierarchy parameterized types, Parameterized Types singleton types, Singleton Types tuples, Tuples type designators, Type Designators type projections, Type Projections use in type bounds expressions, Understanding Abstract Types Value.toString method, Enumerations values, Glossary var keyword, A Taste of Concurrency variable identifiers, Operator? Operator? variable-length argument lists, A Taste of Scala , The Predef Object variables binding nested variables in case clauses, Binding Nested Variables in Case Clauses declarations, Variable Declarations defined, Glossary expanded scope in for expressions, Expanded Scope immutable values in functional programming, Variables that Aren’t in matches, Variables in Matches mutable and immutable, Introducing Scala in static and
dynamic typing, If You Are a Ruby, Python, etc. Programmer… variance annotations, Understanding Parameterized Types summary of, Variance Under Inheritance variance under inheritance, Variance Under Inheritance abstract versus parameterized types, Parameterized Types Versus Abstract Types variance in Scala versus Java, Variance In Scala Versus Java –Variance In Scala Versus Java variance of mutable types, Variance of Mutable Types versions, Scala, Installing Scala VetoableClicks trait (example), Stackable Traits view bounds, Views and View Bounds –Views and View Bounds , Glossary implementing LinkedList class that uses Nodes, Views and View Bounds views, Implicit Conversions , Views and View Bounds –Views and View Bounds , Glossary Vim editor, Text Editors visibility, Visibility Rules –Final Thoughts on Visibility , Glossary fine-grained visibility rules in Scala, Fine-Grained Visibility Rules private, Private Visibility protected, Protected Visibility public, Public Visibility scoped private and protected visibility, Scoped Private and Protected Visibility –Scoped Private and Protected Visibility summary of visibility scopes, Visibility Rules Visitor Pattern, alternative to, The Visitor Pattern: A Better Alternative –Dependency Injection in Scala: The Cake Pattern W weak versus strong typing, If You Are a Ruby, Python, etc. Programmer… weaving, load-time, AspectJ web application frameworks, Lift web page for this book, How to Contact Us code examples, Getting the Code Examples , For More Information while loops, Scala while Loops implementing using by-name parameters and
currying, Call by Name, Call by Value with keyword, Traits As Mixins wrapper classes in Scala, Implicit Conversions Rich wrapper classes defined in scala.runtime
package, Implicit Conversions
..................Content has been hidden....................
You can't read the all page of ebook, please click
here login for view all page.