Scala & Functional Programming Essentials

Learn the fundamentals of Scala by defining values with val, declaring variables with var, and exploring core types like boolean and string and type inference.

Explore expressions in Scala: learn how values and types form math, relational, and boolean expressions, plus code blocks, if expressions, and side effects.

Master defining and calling Scala functions with def, parameters and return types, recursion, and examples like greeting, factorial, Fibonacci, and prime tests.

Discover how the compiler infers types automatically, from strings and ints to function returns, and see how it handles type mismatches and recursive examples like factorial.

Explore tail recursion in Scala, using accumulators to turn recursive calls into iteration, with examples of factorial, string concatenation, isPrime, and Fibonacci while avoiding stack overflow.

Explore the difference between call-by-name and call-by-value in scala, using time-based examples to show evaluation timing and the role of by-name parameters in lazy evaluation.

Explore default values and named arguments in Scala, using a tail-recursive factorial and a save picture example, and learn you cannot omit leading defaults while you can name and reorder.

Discover how to manipulate strings in scala, using charAt, substring, split, replace, length, and toInt, and harness s, f, and raw interpolators for formatted and literal strings.

Master object-oriented basics in Scala by defining classes and objects, and distinguishing class parameters from fields with val. Learn about constructors, methods, and default parameters for flexible instantiation.

Practice object-oriented design in Scala by implementing a writer and novel with fields, methods, and copy, and build an immutable counter with inc and dec operations and overloads.

Explore how Scala's syntactic sugar makes method calls feel like natural language through infix, prefix, postfix, and apply notation, using single-parameter methods and operator-style names.

Overload operators in the person class, add age and learns methods, use postfix and apply overloads, and explore infix, prefix, and postfix notations in Scala.

Explore Scala objects as the singleton, class-level functionality in Scala, and how companions pair classes with objects, enabling factory methods, apply, and runnable Scala applications.

Explore Scala's single class inheritance, how subclasses inherit non-private members, and how constructors, access modifiers, and overriding shape behavior. Also covers super, polymorphism, and final and sealed controls.

Explore abstract data types in Scala by using abstract classes and traits, implementing dog and crocodile, and understanding the giant type hierarchy from any to nothing.

Implement an immutable Scala singly linked list by extending an abstract MyList with empty and Cons subtypes, providing head, tail, isEmpty, add, and a custom toString.

Learn how to define and use generic classes, traits, and methods in Scala, and explore covariance, invariance, contravariance, and bounded types with practical list examples.

Explore anonymous classes in Scala by creating on-the-spot implementations of traits and abstract classes; see how the compiler generates a named anonymous class and implement all required methods.

Apply contravariant design to build a generic list in Scala, implementing my predicate and my transformer, and add map, filter, and flatMap to transform, filter, and flatten collections.

Learn Scala case classes as boilerplate-free data holders. They promote parameters to fields, provide sensible toString, equals, hashCode, and copy, and enable serializable data with companion objects and pattern matching.

Learn how Scala 3 introduces enums as a first class data type with cases like read, write, execute, and none, and how to use ordinal, values, and companion objects.

Learn how to work with exceptions in Scala on the JVM, including throwing and catching with try, catch, and finally, and building custom exceptions and an exception-aware pocket calculator.

Learn how packaging and imports organize Scala code, access package members by simple or fully qualified names, and use package objects and aliasing to manage constants and conflicts.

Explore how Scala treats functions as first-class values, introducing function types, apply, and currying to bridge object-oriented and functional programming.

Explore anonymous functions in Scala, demonstrating lambdas for single and multiple parameters, type inference, and underscore shorthand, and trace their roots to lambda calculus by Alonzo Church.

Master higher order functions and currying in Scala, learning to pass and return functions with examples like map, flatMap, and filter, plus n times and multi-parameter lists.

Explore higher-order functions (HOFs) with practical exercises: for each, sort, zipwith, and fold, then master currying and function composition through hands-on Scala examples.

Explore map, flatMap, and filter on Scala collections, compare their use to for comprehensions, and learn to implement these fundamentals in a custom list and a simple maybe type.

Explore the Scala collections framework with emphasis on immutable collections, their hierarchy from Traversable to sets, maps, and sequences, and the distinction from mutable collections.

Explore Scala sequences, including list, array, and vector, with operations like indexing, reverse, map, filter, and concatenation. Compare performance of lists and vectors using a simple benchmark.

Explore tuples and maps in Scala: create, access, copy, swap, and transform tuples; build and query immutable maps; use map, filter, groupBy, and conversions.

Explore maps in Scala through a mini social network: add, remove, and friend operations, compute stats, and implement a breadth-first search for social connections.

Explore how Scala options model absence to avoid null pointer exceptions, and use map, flatMap, filter, and for comprehensions to safely chain unsafe APIs.

Master handling failure in Scala with the Try type, including success and failure wrappers and safe composition using map, flatMap, and for comprehensions.

Explore pattern matching in Scala, using case classes, guards, and exhaustiveness with sealed hierarchies, then implement a show function for arithmetic expressions with proper parentheses.

Explore Scala pattern matching across constants, wildcards, tuples, case classes, list patterns, type specifiers, name binding, multi patterns, and guards, plus a note on JVM type erasure.

Explore pattern matching in Scala through for comprehensions, tuples, and partial function literals, learning how generators and the head, tail patterns drive expressive code.

Discover scala 3's bracelet syntax with significant indentation that removes braces, uses the then keyword, and supports if expressions, for comprehensions, pattern matching, and end tokens.

Explore advanced Scala and functional programming topics, including parallel and concurrent programming, custom pattern matching, futures and promises, implicits, type classes, lazy evaluation, and bounded polymorphism.