Scala Programming

  1. Advanced Language Features
    1. Pattern Matching
      1. Matching on Values
        1. Matching on Types
          1. Guards in case Clauses
            1. Matching on Case Classes
              1. Matching on Collections
                1. List
                  1. Vector
                    1. Array
                    2. Variable Binding in Patterns
                      1. Wildcard Patterns
                        1. The sealed Keyword for Exhaustive Matching
                          1. Pattern Matching in Variable Assignments
                            1. Pattern Matching Best Practices
                            2. Extractors and unapply Methods
                              1. Understanding unapply
                                1. Creating Custom Extractors
                                  1. Boolean Extractors
                                    1. Product Extractors
                                      1. unapplySeq for Variable-Length Matches
                                      2. Error Handling
                                        1. try-catch-finally Blocks
                                          1. Syntax and Usage
                                            1. Catching Multiple Exceptions
                                              1. Exception Hierarchy
                                              2. Functional Error Handling
                                                1. Option
                                                  1. Some
                                                    1. None
                                                      1. Common Operations on Option
                                                        1. Option vs null
                                                        2. Try
                                                          1. Success
                                                            1. Failure
                                                              1. Transforming and Recovering from Try
                                                              2. Either
                                                                1. Left
                                                                  1. Using Either for Error Handling
                                                                    1. Biased Operations
                                                                2. Implicits
                                                                  1. Implicit Parameters
                                                                    1. Defining and Using Implicit Parameters
                                                                      1. Implicit Parameter Resolution
                                                                      2. Implicit Conversions
                                                                        1. Defining Implicit Conversion Methods
                                                                          1. Use Cases and Pitfalls
                                                                            1. Implicit Conversion Rules
                                                                            2. Implicit Classes
                                                                              1. Extension Methods
                                                                                1. Syntax and Usage
                                                                                  1. Value Classes
                                                                                  2. Context Bounds
                                                                                    1. Syntax and Usage
                                                                                      1. Type Class Pattern
                                                                                      2. Best Practices and Limitations
                                                                                        1. Implicit Resolution Rules
                                                                                          1. Debugging Implicit Issues
                                                                                        2. Type System in Depth
                                                                                          1. Generics
                                                                                            1. Defining Generic Classes and Methods
                                                                                              1. Type Parameters
                                                                                                1. Generic Constraints
                                                                                                2. Variance Annotations
                                                                                                  1. Covariance
                                                                                                    1. Contravariance
                                                                                                      1. Invariance
                                                                                                        1. Use Cases for Variance
                                                                                                          1. Variance and Function Types
                                                                                                          2. Type Bounds
                                                                                                            1. Upper Bounds
                                                                                                              1. Lower Bounds
                                                                                                                1. Bounded Generics in Practice
                                                                                                                2. Type Aliases
                                                                                                                  1. Defining and Using Type Aliases
                                                                                                                    1. Abstract Type Members
                                                                                                                    2. Self-Type Annotations
                                                                                                                      1. Syntax and Use Cases
                                                                                                                        1. Dependency Injection with Self-Types
                                                                                                                        2. Existential Types
                                                                                                                          1. Structural Types
                                                                                                                            1. Path-Dependent Types

                                                                                                                          Previous

                                                                                                                          5. The Scala Collections Library

                                                                                                                          Go to top

                                                                                                                          Next

                                                                                                                          7. Concurrency and Parallelism