Index
Symbols
- ! (exclamation point) method, A Taste of Concurrency
- # (pound sign), Reserved Words
- $ (dollar sign) placeholder, Reserved Words
- $ command, Using SBT
- & (ampersand), Reserved Words
- ' (quotation marks, single)
- ( ) (parentheses)
- * (asterisk)
- + (plus sign)
- - (minus sign)
- / (slash), A Taste of Scala
- : (colon)
- ; (semicolons)
- < (left arrow)
- <> (angle brackets), Abstract Types Versus Parameterized Types
- = (equals sign)
- == (equals sign), Conditional Operators
- @ (at sign), Reserved Words
- @specialized, Specialization for Value Types-Specialization for Value Types
- [] (square brackets), Abstract Types Versus Parameterized Types
- _ (underscore)
- {} (curly braces)
A
- Abstract Factory patterns, Creational Patterns
- abstract keyword, Reserved Words, Traits as Mixins, Stackable Traits
- abstract types, Why Scala?, Abstract Types Versus Parameterized Types-Abstract Types Versus Parameterized Types, Understanding Abstract Types-Comparing Abstract Types and Parameterized Types
- ActiveRecord, A Motivating Example: ActiveRecord in Ruby on Rails-A Motivating Example: ActiveRecord in Ruby on Rails
- Actor Model of Concurrency, A Taste of Concurrency-A Taste of Concurrency
- actors
- ad hoc polymorphism, Type Class Pattern
- Adapter pattern, Structural Patterns
- Akka model, A Taste of Concurrency-Recap and What’s Next, Akka: Actors for Scala-Actors: Final Thoughts
- Algebird, A List of Scala-Based Data Tools
- algebraic data types, Algebraic Data Types-Final Thought on Algebraic Data Types
- all-for-one strategy, Akka: Actors for Scala
- annotations, Annotations-Annotations
- anonymous functions, Anonymous Functions, Lambdas, and Closures-Methods as Functions
- anonymous inner class, Type Refinements
- Ant, Other Build Tools
- application design, Application Design-The Parthenon Architecture
- application resource manager example, Call by Name, Call by Value-Call by Name, Call by Value
- Applicative, The Monad Category
- argument lists, A Taste of Scala, Methods with Multiple Argument Lists-Methods with Multiple Argument Lists
- Arrow, The Importance of Monad
- assertion methods, Validating Input
- ASTs (abstract syntax trees), Macros-A Macro Example: Enforcing Invariants
B
- back-quote literals, Operator Overloading?
- Big Data, Scala for Big Data-Recap and What’s Next
- binding variables, More on Binding Variables in case Clauses
- Boolean literals, Boolean Literals
- bottom types, Much Ado About Nothing (and Null)
- Bridge pattern, Structural Patterns
- build tools, Build Tools-Other Build Tools
- Builder, Builder-Builder
- Builder pattern, Creational Patterns
- by-name parameters, Call by Name, Call by Value-Call by Name, Call by Value
- by-value parameters, Call by Name, Call by Value-Call by Name, Call by Value
C
- C.super, C.super-path.x
- C.this, C.this
- cake pattern, Self-Type Annotations, Traits as Modules-Traits as Modules
- call-by-name parameters, Call by Name, Call by Value-Call by Name, Call by Value
- call-by-value parameters, Call by Name, Call by Value-Call by Name, Call by Value
- CanBuildFrom, CanBuildFrom-CanBuildFrom
- Cascading, Improving MapReduce with Scala, Improving MapReduce with Scala-Improving MapReduce with Scala
- case classes, A Taste of Concurrency-A Taste of Concurrency, Matching on case Classes-unapplySeq Method, Products, Case Classes, and Tuples-Products, Case Classes, and Tuples
- case clauses, Values, Variables, and Types in Matches, Guards in case Clauses
- case keyword, Reserved Words
- catch clauses, Using try, catch, and finally Clauses
- catch keyword, Reserved Words
- category theory, Category Theory-The Importance of Monad
- Chain of Responsibility pattern, Behavioral Patterns
- character literals, Character Literals
- characters allowed in identifiers, Operator Overloading?
- child types, Value Classes
- class
- class keyword, A Taste of Scala, Reserved Words
- Class Tags, Class Tags, Type Tags, and Manifests-Class Tags, Type Tags, and Manifests
- classes
- closures, Anonymous Functions, Lambdas, and Closures-Anonymous Functions, Lambdas, and Closures
- code
- collections library, The Scala Collections Library-Recap and What’s Next
- choosing a collection, Choosing a Collection-Choosing a Collection
- collection.concurrent Package, The collection.concurrent Package
- collection.convert Package, The collection.convert Package
- collection.generic Package, The collection.generic Package
- collection.immutable Package, The collection.immutable Package-The collection.immutable Package
- design idioms
- like traits, Like Traits-Like Traits
- scala.collection Package, The scala.collection Package-The scala.collection Package
- scala.collection.immutable Package, The scala.collection.mutable Package-The scala.collection.parallel Package
- scala.collection.parallel Package, The scala.collection.parallel Package
- specialization for value types, Specialization for Value Types-Miniboxing
- combinators, Variables That Aren’t, Functional Data Structures, Combinators: Software’s Best Component Abstractions-Combinators: Software’s Best Component Abstractions, Either: A Logical Extension to Option, External DSLs with Parser Combinators-A Payroll External DSL
- Command pattern, Behavioral Patterns
- command-line tools, Command-Line Tools-The fsc Command-Line Tool
- companion object, A Taste of Concurrency-A Taste of Concurrency, unapply Method
- companions, Class and Object Basics
- composable mixins, What About Java 8?
- Composite pattern, Structural Patterns
- compound types, Compound Types-Type Refinements
- comprehensions, Scala for Comprehensions, Other Uses of Pattern Matching
- (see also for comprehensions; loops)
- concurrency
- conditional operators, Conditional Operators
- console command, Using SBT
- constructors, Constructors in Scala
- containers (see for comprehensions)
- context bounds, Context Bounds
- contracts, Better Design with Design by Contract
- contravariance, Parameterized Types: Variance Under Inheritance-Functions Under the Hood, Lower Type Bounds, Higher-Kinded Types
- covariance, Parameterized Types: Variance Under Inheritance, Lower Type Bounds
- covariant specialization, Abstract Types Versus Parameterized Types
- covariant typing, Abstract Types Versus Parameterized Types
- currying, Currying and Other Transformations on Functions-Currying and Other Transformations on Functions
D
- data tools, Scala-based, A List of Scala-Based Data Tools-A List of Scala-Based Data Tools
- declarations, Method Declarations
- decompilers, The scalap and javap Command-Line Tools
- Decorator pattern, Structural Patterns
- deep matching, Matching on case Classes-unapplySeq Method
- def keyword, A Taste of Scala, Reserved Words
- default methods, Interfaces in Java 8
- defender methods, Interfaces in Java 8
- definitions, method, Method Declarations
- (see also method declarations)
- dependent method types, Dependent Method Types-Dependent Method Types
- dependent typing, Wrapping Up and Looking Ahead
- derived types, Value Classes
- Design by Contract, Better Design with Design by Contract-Better Design with Design by Contract
- design patterns, Design Patterns-Behavioral Patterns
- dictionary (see maps)
- do keyword, Reserved Words
- domain-specific languages (see DSLs)
- DOT (dependent object typing), Wrapping Up and Looking Ahead
- DSLs (domain-specific languages), Why Scala?, Domain-Specific Languages in Scala-Internal Versus External DSLs: Final Thoughts
- considerations for, DSL Considerations
- defined, Domain-Specific Languages in Scala
- and dynamic invocation, Dynamic Invocation in Scala with the Dynamic Trait
- embedded, Domain-Specific Languages
- external, External DSLs with Parser Combinators-Internal Versus External DSLs: Final Thoughts
- internal, Internal DSLs-Internal DSLs, Internal Versus External DSLs: Final Thoughts-Internal Versus External DSLs: Final Thoughts
- internal versus external, Domain-Specific Languages in Scala, Internal Versus External DSLs: Final Thoughts-Internal Versus External DSLs: Final Thoughts
- overview, Domain-Specific Languages
- parser combinators with, External DSLs with Parser Combinators-A Payroll External DSL
- XML and JSON for, Examples: XML and JSON DSLs for Scala-Examples: XML and JSON DSLs for Scala, Internal Versus External DSLs: Final Thoughts
- duck typing, Structural Types
- dynamic invocation, Dynamic Invocation in Scala-Recap and What’s Next
- Dynamic Trait, Dynamic Invocation in Scala with the Dynamic Trait-Dynamic Invocation in Scala with the Dynamic Trait
- Dynamo, Big Data: A Brief History
E
- eager evaluation, Variables That Aren’t
- eclipse task, Using SBT
- either container, Either: A Logical Extension to Option-Either: A Logical Extension to Option
- else statements, Reserved Words
- Enum class, Self-Recursive Types: F-Bounded Polymorphism
- enumerations, Enumerations-Enumerations
- equality of objects, Equality of Objects-Array Equality and the sameElements Method
- equals sign
- error-handling strategies, Recap of What We Already Know
- evidence, implicit, Implicit Evidence-Implicit Evidence
- exception handling, Using try, catch, and finally Clauses
- exhaustive matches, Sealed Hierarchies and Exhaustive Matches-Sealed Hierarchies and Exhaustive Matches
- existential types, Existential Types-Existential Types
- expression, A Taste of Scala
- Expression Problem, The Expression Problem-The Expression Problem
- extends keyword, Reserved Words, Traits as Mixins
- extension methods, Type Class Pattern, Value Classes-Value Classes
- extracting (see pattern matching)
- extractors, unapply Method-unapplySeq Method
- extreme late binding, Runtime Reflection
F
- F-bounded polymorphic types, Self-Recursive Types: F-Bounded Polymorphism-Self-Recursive Types: F-Bounded Polymorphism
- Facade pattern, Structural Patterns
- Factorie, A List of Scala-Based Data Tools
- factories, Reference Versus Value Types
- Factory Method pattern, Creational Patterns
- false keyword, Reserved Words
- family polymorphism, Abstract Types Versus Parameterized Types
- fast scala compiler (fsc), The fsc Command-Line Tool
- fields, in classes, Fields in Classes-Unary Methods
- Figaro, A List of Scala-Based Data Tools
- file organization, Organizing Code in Files and Namespaces-Organizing Code in Files and Namespaces
- filtering, Guards: Filtering Values, Filtering-Filtering
- final declarations, Reserved Words
- final keyword, Option as a Container
- finally clauses, Using try, catch, and finally Clauses
- finally keyword, Reserved Words
- flat mapping, Flat Mapping-Flat Mapping
- flatMap, The Monad Category
- floating point literals, Floating-Point Literals
- Flyweight pattern, Structural Patterns
- folding, Folding and Reducing-Folding and Reducing
- for comprehensions, What About Java 8?, Reserved Words, Scala for Comprehensions-Expanded Scope and Value Definitions, for Comprehensions in Depth-Recap and What’s Next, Recap of What We Already Know
- collection methods, for Comprehensions: Under the Hood-for Comprehensions: Under the Hood
- container types, Options and Other Container Types-Scalaz Validation
- elements of, Recap: The Elements of for Comprehensions
- expanded scope, Expanded Scope and Value Definitions
- filters in, Guards: Filtering Values
- for loops, for Loops
- generator expressions, Generator Expressions, for Comprehensions: Under the Hood, Translation Rules of for Comprehensions-Translation Rules of for Comprehensions
- pattern matching and, Other Uses of Pattern Matching
- throwing exceptionsin, Throwing exceptions versus returning Either values-Throwing exceptions versus returning Either values
- translation rules, Translation Rules of for Comprehensions-Translation Rules of for Comprehensions
- yielding, Yielding-Yielding
- for loops, for Loops
- formal parameters, Anonymous Functions, Lambdas, and Closures
- forSome keyword, Reserved Words
- free variables, Anonymous Functions, Lambdas, and Closures
- function application, Functions Under the Hood
- function literals, Function Literals, Functional Programming in Scala
- function types, Function Types
- function, defined, Anonymous Functions, Lambdas, and Closures
- functional containers, Recap of What We Already Know
- functional programming (FP), Functional Programming in Scala-Recap and What’s Next, Advanced Functional Programming-Recap and What’s Next
- algebraic data types, Algebraic Data Types-Final Thought on Algebraic Data Types
- anonymous functions, lambdas, and closures, Anonymous Functions, Lambdas, and Closures-Methods as Functions
- category theory, Category Theory-The Importance of Monad
- combinators, Combinators: Software’s Best Component Abstractions-Combinators: Software’s Best Component Abstractions
- currying, Currying and Other Transformations on Functions-Currying and Other Transformations on Functions
- filtering, Filtering-Filtering
- flat mapping, Flat Mapping-Flat Mapping
- folding and reducing, Folding and Reducing-Folding and Reducing
- functional data structures, Functional Data Structures-Sets
- functions in mathematics, Functions in Mathematics-Functions in Mathematics
- immutable variables in, Variables That Aren’t-Variables That Aren’t
- left versus right traversals, Left Versus Right Traversals-Tail Recursion Versus Traversals of Infinite Collections
- mapping, Mapping-Mapping
- methods as functions, Methods as Functions
- mixed paradigm in Scala, Why Scala?
- overview, What Is Functional Programming?-Variables That Aren’t
- partially applied versus partial functions, Partially Applied Functions Versus Partial Functions-Partially Applied Functions Versus Partial Functions
- pure functions, Purity Inside Versus Outside
- recursion in, Recursion-Recursion
- structure sharing, What About Making Copies?-What About Making Copies?
- tail calls, Tail Calls and Tail-Call Optimization-Trampoline for Tail Calls
- transformations on functions, Currying and Other Transformations on Functions-Currying and Other Transformations on Functions
- traversal, Traversing, Mapping, Filtering, Folding, and Reducing-Traversal
- uses, Functional Programming in Scala
- Functional Reactive Programming (FRP), Reactive Programming
- functions
- functions versus methods, A Taste of Scala
- functions, higher-order, Functions in Mathematics
- Functor, Type Lambdas
- Functor category, The Functor Category-The Functor Category
- futures, A Taste of Futures-A Taste of Futures, Futures-Async
G
- generator expressions, Generator Expressions, for Comprehensions: Under the Hood, Translation Rules of for Comprehensions-Translation Rules of for Comprehensions
- generic classes, Java and Scala Generics-Java and Scala Generics
- generics, Why Scala?, Abstract Types Versus Parameterized Types
- GFS (Google File System), Big Data: A Brief History
- Gradle, Other Build Tools
- guards, Guards: Filtering Values, lazy val
I
- identifiers
- IDEs (integrated development environments), Running the Scala REPL in IDEs, A Taste of Scala, Runtime Reflection
- if statements, Reserved Words, Scala if Statements
- immutable variables, A Taste of Scala, Variable Declarations, Variables That Aren’t-Variables That Aren’t
- immutable variants, The collection.immutable Package-The collection.immutable Package
- implicit keyword, Methods with Multiple Argument Lists-A Taste of Futures, Reserved Words, Implicit Arguments, Implicit Conversions
- implicits, Recap of What We Already Know
- built-in, Scala’s Built-in Implicits-Scala’s Built-in Implicits
- implicit arguments, Implicit Arguments-Rules for Implicit Arguments
- implicit conversions, Reserved Words, Constraining Allowed Instances, Implicit Conversions-The Expression Problem, Implicit Conversions-Implicit Conversions
- implicit resolution rules, Implicit Resolution Rules-Implicit Resolution Rules
- overview, Implicits
- technical issues with, Technical Issues with Implicits-Technical Issues with Implicits
- and the Type Class Pattern, Type Class Pattern-Type Class Pattern
- wise use of, Wise Use of Implicits
- import keyword, Reserved Words
- import statements, Importing Types and Their Members-Package Objects
- infix notation, A Taste of Concurrency
- infix types, Infix Types-Infix Types
- inheritance, Parent Types-Parent Types, Good Object-Oriented Design: A Digression
- instances, Class and Object Basics-Class and Object Basics
- integer literals, Integer Literals-Integer Literals
- interfaces (see traits)
- internal DSLs, Domain-Specific Languages
- interpolated strings, A Taste of Concurrency, Interpolated Strings-Interpolated Strings, Build Your Own String Interpolator-Build Your Own String Interpolator
- Interpreter pattern, Behavioral Patterns
- invariance, Parameterized Types: Variance Under Inheritance
- invariants, Better Design with Design by Contract
- Iterator pattern, Behavioral Patterns
L
- lambdas, What About Java 8?, Anonymous Functions, Lambdas, and Closures, Functions Under the Hood
- lazy evaluation, Reserved Words, Variables That Aren’t
- lazy values, lazy val, Overriding fields in traits
- least upper-bound variance, Lower Type Bounds
- least-upper bound values, Scala if Statements
- let it crash, Akka: Actors for Scala, Better Design with Design by Contract
- libraries, third-party, Third-Party Libraries-Third-Party Libraries
- lifting, Methods as Functions, Currying and Other Transformations on Functions
- Like traits, Like Traits-Like Traits
- linearization, Stackable Traits, Linearization of an Object’s Hierarchy-Linearization of an Object’s Hierarchy
- LINQ, Dynamic Invocation in Scala with the Dynamic Trait
- Liskov Substitution Principle, Functions Under the Hood
- lists
- literal values, Literal Values-Tuple Literals
- literals
- local type inference, A Taste of Scala
- loops
- lower type bounds, Lower Type Bounds-Lower Type Bounds
M
- macros, Metaprogramming: Macros and Reflection, Macros-Final Thoughts on Macros
- Magnet Pattern, Dependent Method Types
- mailboxes, A Taste of Concurrency
- main method, A Taste of Scala
- Manifests, Class Tags, Type Tags, and Manifests
- mapping, Mapping-Mapping
- MapReduce, Big Data: A Brief History-Improving MapReduce with Scala
- maps, Maps
- match clauses, A Simple Match-A Simple Match
- match keyword, Reserved Words
- MatchError, Partial Functions
- matches (see pattern matching)
- Maven, SBT, the Standard Build Tool for Scala, Other Build Tools
- Mediator pattern, Behavioral Patterns
- members, Class and Object Basics
- metaprogramming, Metaprogramming: Macros and Reflection
- method declarations, Method Declarations
- method definitions, A Taste of Scala, Nesting Method Definitions and Recursion-Nesting Method Definitions and Recursion
- methods
- miniboxing, Miniboxing
- mixin composition, Why Scala?
- mixins, Recap of What We Already Know
- Momento pattern, Behavioral Patterns
- Monad category, The Monad Category-The Importance of Monad
- Monoids, Categories for Mathematics
- morphism composition, About Categories
- mutable types, Variance of Mutable Types-Variance of Mutable Types
- mutable variables, Variable Declarations-Variable Declarations
- mutable variants, The scala.collection.mutable Package-The scala.collection.mutable Package
N
- named arguments, Method Default and Named Arguments-Method Default and Named Arguments
- namespaces, Organizing Code in Files and Namespaces
- naming conventions, A Taste of Scala
- nested classes, Why Scala?
- nested methods, Nesting Method Definitions and Recursion-Nesting Method Definitions and Recursion, Nested Types-Nested Types
- nesting, Tail Calls and Tail-Call Optimization
- new keyword, Reserved Words
- no argument methods, Methods with Empty Argument Lists-Methods with Empty Argument Lists
- nominal typing, Structural Types
- none class, Option, Some, and None: Avoiding nulls-Option, Some, and None: Avoiding nulls
- nothing, Much Ado About Nothing (and Null)-Much Ado About Nothing (and Null)
- null keyword, Reserved Words
- nulls, Option, Some, and None: Avoiding nulls-Option, Some, and None: Avoiding nulls, Much Ado About Nothing (and Null)-Much Ado About Nothing (and Null)
O
- object keyword, Reserved Words
- object system (Scala)
- equality tests, Equality of Objects-Array Equality and the sameElements Method
- hierarchy linearization, Linearization of an Object’s Hierarchy-Linearization of an Object’s Hierarchy
- nothing and null, Much Ado About Nothing (and Null)-Much Ado About Nothing (and Null)
- overrides, Overriding Members of Classes and Traits-When Accessor Methods and Fields Are Indistinguishable: The Uniform Access Principle
- overriding
- predef object, The Predef Object-Miscellaneous Methods
- products, case classes, and tuples, Products, Case Classes, and Tuples-Products, Case Classes, and Tuples
- type hierarchy, The Scala Type Hierarchy
- variance under inheritance, Parameterized Types: Variance Under Inheritance-Variance in Scala Versus Java
- object-oriented design, Good Object-Oriented Design: A Digression-Good Object-Oriented Design: A Digression, Traits as Mixins
- object-oriented programming (OOP), Functional Programming in Scala, Combinators: Software’s Best Component Abstractions, Object-Oriented Programming in Scala-Recap and What’s Next
- class and object basics, Class and Object Basics-Class and Object Basics
- constructors, Constructors in Scala
- fields in classes, Fields in Classes-Unary Methods
- good design in, Good Object-Oriented Design: A Digression-Good Object-Oriented Design: A Digression, Traits as Mixins
- methods versus functions in, A Taste of Scala
- mixed paradigm in Scala, Why Scala?
- nested methods, Nested Types-Nested Types
- parent class, Parent Types-Parent Types, Calling Parent Class Constructors (and Good Object-Oriented Design)-Calling Parent Class Constructors (and Good Object-Oriented Design)
- reference versus value types, Reference Versus Value Types-Reference Versus Value Types
- validating input, Validating Input-Validating Input
- value classes, Value Classes-Value Classes
- objects, Class and Object Basics-Class and Object Basics
- Observer Design Pattern, Traits as Mixins
- Observer pattern, Behavioral Patterns
- Odersky, Martin, Why Scala?
- Open/Closed Principle, The Expression Problem
- operator names, Operator Overloading?-Syntactic Sugar
- operator precedence rules, Precedence Rules-Precedence Rules
- option class, Option, Some, and None: Avoiding nulls-Option, Some, and None: Avoiding nulls
- option container, Option as a Container-Option as a Container
- overloaded methods, Inferring Type Information
- override keyword, Reserved Words, Overriding Members of Classes and Traits-Overriding Members of Classes and Traits
- overrides, Overriding Members of Classes and Traits-When Accessor Methods and Fields Are Indistinguishable: The Uniform Access Principle
P
- package declarations, Organizing Code in Files and Namespaces-Importing Types and Their Members
- package keyword, Reserved Words
- package objects, Package Objects-Package Objects, Sequences-Sequences, Recap of What We Already Know
- parallel variants, The scala.collection.parallel Package-The scala.collection.parallel Package
- parameterized types, A Taste of Scala, Abstract Types Versus Parameterized Types-Abstract Types Versus Parameterized Types, Parameterized Types: Variance Under Inheritance, Parameterized Types-Type Parameter Names, Comparing Abstract Types and Parameterized Types-Comparing Abstract Types and Parameterized Types
- parametric polymorphism, Abstract Types Versus Parameterized Types, Type Class Pattern
- parent class, Parent Types-Parent Types, Calling Parent Class Constructors (and Good Object-Oriented Design)-Calling Parent Class Constructors (and Good Object-Oriented Design)
- parser combinators, External DSLs with Parser Combinators-A Payroll External DSL
- Parthenon Architecture, The Parthenon Architecture-The Parthenon Architecture
- partial functions, Partial Functions-Partial Functions, Partially Applied Functions Versus Partial Functions
- PartialFunction, A Taste of Concurrency
- partially applied function, defined, Partially Applied Functions Versus Partial Functions
- path-dependent types, Path-Dependent Types-path.x
- path.x
- pattern matching, What About Java 8?, A Taste of Concurrency-A Taste of Concurrency, Pattern Matching-Recap and What’s Next, Recap of What We Already Know
- on case classes, Matching on case Classes-unapplySeq Method
- in for comprehensions, Expanded Scope and Value Definitions, Other Uses of Pattern Matching, Other Uses of Pattern Matching
- and function literals, Other Uses of Pattern Matching
- identifiers in, Operator Overloading?
- in if expressions, Other Uses of Pattern Matching
- for lists, Other Uses of Pattern Matching
- match clauses, A Simple Match-A Simple Match
- on regular expressions, Matching on Regular Expressions-Matching on Regular Expressions, Other Uses of Pattern Matching
- and sealed hierarchies, Sealed Hierarchies and Exhaustive Matches-Sealed Hierarchies and Exhaustive Matches
- on sequences, Matching on Sequences-Matching on Sequences
- on tuples, Matching on Tuples, Matching on case Classes
- type matching, More on Type Matching
- values, variables, and types, Values, Variables, and Types in Matches-Values, Variables, and Types in Matches
- on variable argument lists, Matching on Variable Argument Lists-Matching on Variable Argument Lists
- versus subtype polymorphism, A Taste of Concurrency
- patterns (see design patterns; pattern matching)
- persistent data structures, What About Making Copies?, The collection.immutable Package
- phantom types, Phantom Types-Phantom Types
- Pickling library, Pickling and Spores
- postconditions, Better Design with Design by Contract
- pre-initialized fields, Overriding fields in traits-Overriding fields in traits
- precedence, operator, Precedence Rules-Precedence Rules
- preconditions, Better Design with Design by Contract
- Predef object, The Predef Object-Miscellaneous Methods
- primary constructor, A Taste of Scala
- primitive data types, Variable Declarations
- primitives, Reference Versus Value Types-Reference Versus Value Types, Specialization for Value Types
- private keyword, Reserved Words
- private visibility, Private Visibility-Scoped Private and Protected Visibility
- product types, Sum Types Versus Product Types-Sum Types Versus Product Types
- products, Products, Case Classes, and Tuples-Products, Case Classes, and Tuples
- property-based testing, Test-Driven Development in Scala
- protected keyword, Reserved Words
- protected visibility, Protected Visibility-Protected Visibility, Scoped Private and Protected Visibility-Scoped Private and Protected Visibility
- Prototype pattern, Creational Patterns
- Proxy pattern, Structural Patterns
- public visibility, Public Visibility: The Default-Public Visibility: The Default, Public Visibility-Public Visibility
- pure functions, A Taste of Concurrency, Functions in Mathematics, Variables That Aren’t-Variables That Aren’t, Purity Inside Versus Outside
R
- ranges, Ranges-Ranges
- Reactive Extensions (Rx), Reactive Programming
- Reactive Manifesto, Reactive Programming
- reactive programming, Reactive Programming-Reactive Programming
- recursion, Nesting Method Definitions and Recursion-Nesting Method Definitions and Recursion
- reduce function, Functional Programming in Scala
- reducing, Folding and Reducing-Folding and Reducing
- reference equality, The eq and ne Methods
- reference types, Reference Versus Value Types-Reference Versus Value Types
- referential transparancy, Functions in Mathematics-Functions in Mathematics
- reflection, Metaprogramming: Macros and Reflection, Runtime Reflection-Scala’s Advanced Runtime Reflection API
- Class Tags, Class Tags, Type Tags, and Manifests-Class Tags, Type Tags, and Manifests
- Manifests, Class Tags, Type Tags, and Manifests
- Scala advanced runtime reflection API, Scala’s Advanced Runtime Reflection API-Scala’s Advanced Runtime Reflection API
- Type Tags, Class Tags, Type Tags, and Manifests
- types, Reflecting on Types-Reflecting on Types
- regexes, Matching on Regular Expressions
- regular expressions, Matching on Regular Expressions-Matching on Regular Expressions
- Relate, A List of Scala-Based Data Tools
- relative imports, Imports Are Relative
- REPL (read, evaluate, print, loop), Running the Scala Command-Line Tools-A Taste of Scala
- requires keyword, Reserved Words
- reserved keywords, Reserved Words-Reserved Words
- return keyword, Reserved Words
- return type for methods, Nesting Method Definitions and Recursion-Inferring Type Information
- Ruby on Rails, A Motivating Example: ActiveRecord in Ruby on Rails
- runtime reflection, Runtime Reflection-Scala’s Advanced Runtime Reflection API
S
- SBT (standard build tool), Installing Scala, Using SBT-Using SBT, SBT, the Standard Build Tool for Scala-SBT, the Standard Build Tool for Scala
- Scala
- advanced runtime reflection API, Scala’s Advanced Runtime Reflection API-Scala’s Advanced Runtime Reflection API
- code examples, A Taste of Scala
- collections library (see collections library)
- installing, Installing Scala-Running the Scala REPL in IDEs
- introduction to, Zero to Sixty: Introducing Scala-The Seductions of Scala
- reflection library, Class Tags, Type Tags, and Manifests-Class Tags, Type Tags, and Manifests
- reserved keywords list, Reserved Words-Reserved Words
- type hierarchy, The Scala Type Hierarchy-The Scala Type Hierarchy
- scala command, Running the Scala Command-Line Tools
- scala command-line tool, The scala Command-Line Tool-The scala Command-Line Tool
- Scala Meta, Metaprogramming: Macros and Reflection, Macros
- Scala reflection API, Metaprogramming: Macros and Reflection
- scala.sys process package, The scala.sys.process Package-The scala.sys.process Package
- scalac, scalac Command-Line Tool-scalac Command-Line Tool, Limitations of scala versus scalac-Limitations of scala versus scalac
- Scaladocs, Installing Scala, A Taste of Scala, Abstract Types Versus Parameterized Types, The scaladoc Command-Line Tool
- ScalaNLP, A List of Scala-Based Data Tools
- scalap, A Taste of Scala, The scalap and javap Command-Line Tools
- ScalaStorm, A List of Scala-Based Data Tools
- Scalaz, Scalaz Validation-Scalaz Validation, Higher-Kinded Types, Category Theory
- Scalding, Improving MapReduce with Scala, Improving MapReduce with Scala, A List of Scala-Based Data Tools
- Schönfinkel, Moses, Currying and Other Transformations on Functions
- Scoobi, A List of Scala-Based Data Tools
- sealed class hierarchies, Sealed Class Hierarchies, Sealed Hierarchies and Exhaustive Matches-Sealed Hierarchies and Exhaustive Matches
- sealed keyword, Reserved Words, Sealed Class Hierarchies, Option as a Container
- self expression, Option as a Container
- self-recursive types, Self-Recursive Types: F-Bounded Polymorphism-Self-Recursive Types: F-Bounded Polymorphism
- self-type annotations, Self-Type Annotations-Self-Type Annotations
- separation of concerns, Traits as Mixins, The Importance of Monad
- sequences, Matching on Sequences-Matching on Sequences, Sequences-Sequences
- sets, Sets
- Shapeless, Higher-Kinded Types
- Single Responsibility Principle, The Expression Problem, Traits as Mixins
- singleton objects, Singleton Types
- Singleton pattern, A Taste of Scala, Creational Patterns
- singleton types, Builder, Singleton Types-Singleton Types
- Slick, A List of Scala-Based Data Tools
- some class, Option, Some, and None: Avoiding nulls-Option, Some, and None: Avoiding nulls
- Spark, Moving Beyond MapReduce-Moving Beyond MapReduce, A List of Scala-Based Data Tools
- Spire, A List of Scala-Based Data Tools
- Spores project, Pickling and Spores
- stackable traits, Stackable Traits-Stackable Traits
- State pattern, Behavioral Patterns
- static typing, Why Scala?
- statics, A Taste of Scala
- Strategy pattern, Behavioral Patterns
- Stream, Tail Recursion Versus Traversals of Infinite Collections, Recap: The Elements of for Comprehensions-Recap: The Elements of for Comprehensions
- strict evaluation, Variables That Aren’t
- string argument, A Taste of Scala
- string interpolation, Interpolated Strings-Interpolated Strings, Build Your Own String Interpolator-Build Your Own String Interpolator
- string literals, String Literals-String Literals
- structural types, Structural Types-Structural Types
- structure sharing, What About Making Copies?-What About Making Copies?
- subtype polymorphism, The Expression Problem, Type Class Pattern
- subtype polymorphism versus pattern matching, A Taste of Concurrency
- sum types, Sum Types Versus Product Types-Sum Types Versus Product Types
- Summingbird, A List of Scala-Based Data Tools
- super keyword, Reserved Words
- supervisors, Akka: Actors for Scala
- symbol literals, Symbol Literals
- syntactic sugar, Syntactic Sugar, Functions Under the Hood
T
- tail calls, Tail Calls and Tail-Call Optimization-Trampoline for Tail Calls, Trampoline for Tail Calls
- tail recursion, Tail Recursion Versus Traversals of Infinite Collections-Tail Recursion Versus Traversals of Infinite Collections
- Template Method Pattern, Stackable Traits, Avoid Overriding Concrete Members, Behavioral Patterns
- test-driven development (TDD), Test-Driven Development in Scala-Test-Driven Development in Scala
- third-party libraries, Third-Party Libraries-Third-Party Libraries
- this keyword, Reserved Words, Self-Type Annotations
- throw keyword, Reserved Words
- throwing exceptions, Throwing exceptions versus returning Either values-Throwing exceptions versus returning Either values, Much Ado About Nothing (and Null)-Much Ado About Nothing (and Null)
- tools, Scala Tools and Libraries-Test-Driven Development in Scala
- trait keyword, Reserved Words
- traits, Why Scala?, Traits: Interfaces and “Mixins” in Scala-Traits: Interfaces and “Mixins” in Scala, Traits-Recap and What’s Next
- trampolines, Trampoline for Tail Calls
- traversal, Traversing, Mapping, Filtering, Folding, and Reducing-Traversal, Left Versus Right Traversals-Tail Recursion Versus Traversals of Infinite Collections
- true keyword, Reserved Words
- try clauses, Using try, catch, and finally Clauses
- try container, Try: When There Is No Do-Try: When There Is No Do
- try keyword, Reserved Words
- tuples, Tuple Literals-Tuple Literals, Matching on Tuples, Products, Case Classes, and Tuples, Tuple Types
- type annotations, A Taste of Scala
- type annotations, required explicit, Inferring Type Information
- type bounds, Type Bounds-Lower Type Bounds
- Type Class Pattern, Type Class Pattern-Type Class Pattern
- type constructors, Type Constructors
- type erasure, Working Around Erasure-Working Around Erasure, Class Tags, Type Tags, and Manifests
- type hierarchy, The Scala Type Hierarchy-The Scala Type Hierarchy
- type inference, Why Scala?, Inferring Type Information-Inferring Type Information
- type keyword, Reserved Words
- type lambdas, Type Lambdas-Type Lambdas
- type matching, Values, Variables, and Types in Matches-Values, Variables, and Types in Matches, More on Type Matching
- type parameters
- type paths, C.this-path.x
- type projections, Type Projections-Type Projections
- type refinements, Type Refinements-Type Refinements
- type safety, Actors: Final Thoughts
- type system (Scala), Why Scala?, Scala’s Type System, Part I-Recap and What’s Next
- abstract types, Understanding Abstract Types-Comparing Abstract Types and Parameterized Types
- comparing abstract and parameterized types, Comparing Abstract Types and Parameterized Types-Comparing Abstract Types and Parameterized Types
- compound types, Compound Types-Type Refinements
- context bounds, Context Bounds
- dependent method types, Dependent Method Types-Dependent Method Types
- existential types, Existential Types-Existential Types
- F-bounded polymorphic types, Self-Recursive Types: F-Bounded Polymorphism-Self-Recursive Types: F-Bounded Polymorphism
- higher-kinded types, Higher-Kinded Types-Higher-Kinded Types
- parameterized types, Parameterized Types-Type Parameter Names, Comparing Abstract Types and Parameterized Types-Comparing Abstract Types and Parameterized Types
- path-dependent types, Path-Dependent Types-path.x
- self-recursive types, Self-Recursive Types: F-Bounded Polymorphism-Self-Recursive Types: F-Bounded Polymorphism
- self-type annotations, Self-Type Annotations-Self-Type Annotations
- structural types, Structural Types-Structural Types
- type bounds, Type Bounds-Lower Type Bounds
- type lambdas, Type Lambdas-Type Lambdas
- type projections, Type Projections-Type Projections
- value types, Types for Values
- view bounds, View Bounds-View Bounds
- Type tags, Class Tags, Type Tags, and Manifests
- types, Class and Object Basics, Recap of What We Already Know
- Typesafe, Inc., Recap and What’s Next
V
- val keyword, Variable Declarations-Variable Declarations, Reserved Words
- validation, Validating Input-Validating Input
- value classes, Value Classes-Value Classes
- value matches, Values, Variables, and Types in Matches-Values, Variables, and Types in Matches
- value types, Reference Versus Value Types, Specialization for Value Types-Miniboxing, Types for Values
- var keyword, Variable Declarations-Variable Declarations, Reserved Words
- variable argument lists, Matching on Variable Argument Lists-Matching on Variable Argument Lists
- variable declarations, Variable Declarations-Variable Declarations
- variable length argument list, A Taste of Scala
- variable matches, Values, Variables, and Types in Matches-Values, Variables, and Types in Matches
- variables, Variables That Aren’t
- variance annotations, Functions Under the Hood-Functions Under the Hood, Variance Annotations, Upper Type Bounds
- variance under inheritance, Parameterized Types: Variance Under Inheritance-Variance in Scala Versus Java
- view bounds, View Bounds-View Bounds
- visibility rules, Visibility Rules-Recap and What’s Next, Public Visibility: The Default-Public Visibility: The Default, Recap of What We Already Know
- Visitor pattern, Behavioral Patterns
..................Content has been hidden....................
You can't read the all page of ebook, please click
here login for view all page.