In Scala, the keywords val and var are used to declare variables, but they differ in terms of mutability.

val (Immutable Variable)

• Immutable: Once a value is assigned to a val, it cannot be changed.
• Similar to a constant or a final variable in other languages like Java.
• Thread-safe by design since the value cannot change after initialization.

Usage:

val x = 10  // Immutable integer
x = 20      // Compilation error: reassignment to val is not allowed

Advantages:

• Safer to use in concurrent or multithreaded environments.
• Encourages immutability, which is a key concept in functional programming.

var (Mutable Variable)

• Mutable: A var can be reassigned a different value after its initial assignment.
• Similar to a regular variable in most programming languages.

Usage:

var y = 10  // Mutable integer
y = 20      // No error, reassignment is allowed

Disadvantages:

• More prone to bugs in complex programs, especially in concurrent systems, because the state can change unexpectedly.

Key Differences:

Aspect	val	var
Mutability	Immutable	Mutable
Reassignment	Not allowed	Allowed
Thread-safety	Safer for concurrency	Requires care in concurrent programming
Preferred Usage	Encouraged for immutability (functional programming)	Used when mutability is necessary

Best Practices:

• Prefer val whenever possible, as immutability reduces complexity, especially in large or concurrent programs.
• Use var only when you need to change the value of a variable explicitly.

In functional programming, immutability (val) is generally preferred because it leads to safer, more predictable, and easier-to-understand code.

---

Semicolons (;) not needed in Scala

In Scala, semicolons are optional for terminating statements. The Scala compiler can automatically infer the end of a statement based on the structure of the code, so semicolons are typically unnecessary unless you are placing multiple statements on a single line.

How Scala Handles Statement Termination:

• In most cases, Scala uses newline characters to determine the end of a statement, so you don’t need to end each line with a semicolon.

Example without Semicolons:

val x = 10
val y = 20
println(x + y)

When Semicolons Might Be Needed:

You might only need semicolons in certain cases where you’re writing multiple statements on the same line:

val x = 10; val y = 20; println(x + y)

Summary:

• Semicolons are optional in Scala and rarely needed when each statement is written on its own line.
• They are only required when you want to write multiple statements on a single line.
• This feature contributes to Scala’s cleaner, more readable syntax compared to languages like Java.

---

Methods calls and Function syntax

In Scala, sum(a, b) being equivalent to a.sum(b) reflects how method calls and function syntax work in Scala.

Here’s a detailed explanation:

Infix Notation:

Scala allows infix notation for method calls with one parameter. This means that instead of calling a method in the traditional way (with a dot and parentheses, like a.sum(b)), you can write the same method in infix style as a sum b. This is more readable and allows a natural, mathematical-like syntax in some cases.

Example :

class MyNumber(val n: Int) {
  def sum(b: MyNumber): MyNumber = new MyNumber(n + b.n)
}

val a = new MyNumber(10)
val b = new MyNumber(20)

// Traditional method call
val result1 = a.sum(b)

// Infix notation (equivalent to a.sum(b))
val result2 = a sum b

println(result1.n)  // Output: 30
println(result2.n)  // Output: 30

Syntactic Sugar for Method Calls:

In Scala, methods with one parameter can be written without parentheses, which makes it appear as if you’re using operators or functions directly. Thus, a.sum(b) and sum(a, b) (if sum is defined as a method of class a) would behave in a similar way.

Operators Are Methods:

In Scala, operators are just methods. For example, a + b is essentially shorthand for a.+(b), meaning the + operator is just a method in the class that a belongs to. This is why custom operators can be defined as methods.

For example:

val x = 1 + 2  // Equivalent to 1.+(2)

Similarly, if you had a method called sum, it could be used both ways:

val result1 = a.sum(b)
val result2 = a sum b  // Both are valid

If we imagine sum(a, b) as a standalone function, it’s not exactly equivalent to a.sum(b). However, if sum is a method defined on the object a, then a.sum(b) and sum(a, b) may be conceptually similar, depending on where the method sum is defined.

• Standalone Function (sum(a, b)) refers to a function call where sum is a top-level function (not bound to any object).
• Method Call (a.sum(b)) refers to a method that belongs to the object a.

Example with Standalone Function:

def sum(a: MyNumber, b: MyNumber): MyNumber = new MyNumber(a.n + b.n)

val a = new MyNumber(10)
val b = new MyNumber(20)

val result = sum(a, b)  // Calls the standalone function

println(result.n)  // Output: 30

Summary:

• a.sum(b) refers to a method sum defined inside the class/object of a.
• sum(a, b) is a top-level function that accepts two arguments.
• In Scala, infix notation allows writing a sum b as a more readable form of a.sum(b).

---

Diamond Inheritance Problem – how Scala avoids it ?

Scala avoids the diamond inheritance problem through its use of traits and the linearization of method resolution, effectively sidestepping the ambiguity that arises in languages like C++ when multiple inheritance is used.

Diamond Inheritance Problem:

In languages that support multiple inheritance, like C++, the diamond problem occurs when a class inherits from two classes that both inherit from a common base class. This can lead to ambiguity about which version of a method should be inherited from the common base class.

Example in C++ (with ambiguity):

class A {
public:
    void print() { cout << "A" << endl; }
};

class B : public A {};
class C : public A {};

class D : public B, public C {};  // Diamond inheritance

int main() {
    D obj;
    obj.print();  // Ambiguity: Which print() method from class A should be called?
}

How Scala Avoids This Problem:

1. Traits and Mixins Instead of Multiple Inheritance:
   • Scala does not support multiple inheritance of classes (you can only extend one class), but it allows a class to implement multiple traits.
   • Traits in Scala are similar to interfaces in Java, but they can contain both abstract and concrete methods.
   • This avoids the complexity of multiple inheritance because the class can extend only one class and mix in multiple traits, which are resolved in a specific, predictable order.
2. Linearization (Method Resolution Order): Scala solves the diamond problem using linearization (also known as Method Resolution Order, MRO). When a class extends multiple traits or classes, Scala “linearizes” the inheritance chain into a single linear path. This means that the traits or classes are flattened into a specific order, and the method resolution follows that order.

Example in Scala:

trait A {
  def print() = println("A")
}

trait B extends A {
  override def print() = println("B")
}

trait C extends A {
  override def print() = println("C")
}

class D extends B with C

val d = new D
d.print()  // Output: "C"

Explanation:

• Traits B and C both override A‘s print method.
• Class D extends B and mixes in C.
• When D calls print(), Scala uses linearization to determine the order of method resolution: D → C → B → A.
• Since C comes after B in the linearization order (due to the with C clause), the method from C is called, not B.

How Linearization Works:

When you extend multiple traits in Scala, the traits are linearized from left to right. The most specific trait’s method (the one furthest to the right in the linear hierarchy) is called first.

The line class D extends B with C in Scala demonstrates how inheritance and trait mixing work in Scala. It signifies that D is a class that:

1. Extends Class or Trait B (in this case, B can be either a class or a trait).
2. Mixes in Trait C to add functionality from C.

Breakdown:

• class D: This defines a new class D.
• extends B: D extends B, meaning D inherits from B. In Scala, a class can only extend one class or one trait directly. B can either be a class or a trait, but typically it’s a class in this context.
• with C: D also mixes in trait C. C is a trait, and Scala allows a class to mix in multiple traits by using the with keyword. D inherits the members (methods, fields) of trait C, on top of whatever it inherits from B.

Explanation:

1. B and C both extend A: Traits B and C both override the show method from A.
2. class D extends B with C: Class D extends B and mixes in C. Since D extends B, it inherits the behavior of B. However, with C mixes in trait C, and in the method resolution order, the method from C is preferred because of Scala’s linearization of traits.
3. When D calls show(), C‘s method is used, because Scala’s linearization process ensures that C takes precedence over B.

Key Points:

• extends: In Scala, a class can extend only one class or trait. In this case, D is extending B.
• with: The with keyword is used to mix in multiple traits. A class can mix in any number of traits, adding behavior from multiple traits.
• Linearization: In the case of conflicting methods (e.g., B and C both override show()), Scala uses linearization to determine which method is invoked. In this example, C is mixed in after B, so C‘s method takes precedence.

Thus, class D extends B with C means that D inherits behavior from B, while also mixing in the functionality provided by C, and in case of any conflicts (e.g., method overrides), Scala resolves them based on the linearization order.

Summary:

• Scala doesn’t have the diamond inheritance problem because it uses traits (instead of multiple inheritance) and resolves method calls using linearization.
• Linearization ensures there is a well-defined order for resolving methods from the inheritance hierarchy, preventing ambiguity.
• As a result, there is no confusion about which method gets called, as Scala follows a strict and predictable order.