Udemyexperten

Scala Advanced, Part 1 - The Scala Type System

Master Scala's powerful type system! Explore mutable state, deep dives into implicits, and advanced concepts for robust, concise code.

4.7(401)
3,448students
5h 19m
Certificate
Dick Wall
Dick WallScala Developer

Course Content

Scala Advanced, Part 1 - The Scala Type System is an advanced Udemy course taught by Dick Wall. It runs 5h 19m, is taught in English, and includes a certificate of completion. Learners rate it 4.7 out of 5 from 401 reviews, with 3,448 students enrolled. It is a paid course, last updated March 2023.

Elevate your Scala skills with Scala Advanced, Part 1! This course is designed for experienced Scala developers aiming to build robust and maintainable Scala libraries and APIs. Learn to create high-quality, correct, powerful, and flexible Scala libraries that are a pleasure for others to use.

Part 1 provides a deep dive into the Scala type system, a crucial foundation for any successful library development. We'll explore the potential pitfalls and safe handling of mutable shared state in Scala, including best practices for properties and caching.

Key topics covered include:

  • Generics: Master generic programming for reusable code.
  • Co- and Contra-Variance: Understand variance and its implications for type safety.
  • Upper and Lower Bounds: Control type relationships for enhanced flexibility.
  • Type Inference: Leverage Scala's powerful type inference system.
  • Type Parameters and Type Members: Gain control over type definitions.
  • Path Dependent Types: Explore advanced type constraints.
  • Refinement Types: Implement complex type restrictions.
  • Structural Types: Define types based on structure, not just name.
  • Recursive Types: Work with recursive data structures.
  • F-bounded Polymorphism: Utilize advanced polymorphism techniques.

Finally, we'll unlock the power of the secondary implicits type system, which extends the core Scala type system. Learn about:

  • Simple Implicit Parameters: Pass implicit values easily.
  • Type Classes: Implement generic programming with type classes.
  • Implicit Classes, Objects, and Methods: Define implicit behavior.
  • Type Class Composition: Combine type classes for powerful abstractions.
  • Implicit Constraints: Enforce constraints on implicit parameters.
  • =:= and Implicit Class and Type Tags: Advanced type comparison and tagging.
  • Implicit Conversions: Create seamless type conversions.
  • extends AnyVal: Understand the benefits of extending AnyVal.

By the end of this course, you'll possess a comprehensive understanding of the Scala type system, enabling you to design well-structured APIs, reason effectively about type abstraction and calculus, apply implicit constraints, and extend the language's capabilities.

Looking to expand your knowledge further? Parts 2 and 3 (available separately) delve into best practices, idioms, patterns, advanced functional programming, asynchronous programming, parser-combinators, macros, performance profiling, and optimization. These advanced parts build upon the foundational knowledge gained in this Scala Advanced, Part 1 course.

$ whoami — the devs behind tutorialsearch.io

Need a web app built? Hire the team behind TutorialSearch.io

We ship fast, production-grade full-stack apps (Next.js, React, edge infra) — the same stack that powers this site.