Lesson 5: Scala Programming Language Tutorial

Lesson 5: Scala Programming Language Tutorial

Example 1: Lazy Evaluation in Scala

lazy val message = {
  println("Initializing message...")
  "Hello, Scala!"
}

println("Before accessing message")
println(message)
println("After accessing message")

Explanation:

1. lazy val message = { println("Initializing message..."); "Hello, Scala!" } – Declares a lazy val, meaning the block only executes when message is first accessed.

2. println("Before accessing message") – Prints a message before accessing message. Since message is lazy, "Initializing message..." is not printed yet.

3. println(message) – Accessing message triggers initialization, printing "Initializing message..." followed by "Hello, Scala!", demonstrating how lazy delays evaluation.

4. println("After accessing message") – Prints "After accessing message", showing that message is initialized only once and not recalculated on subsequent accesses.

Example 2: Implicit Parameters in Scala

def greet(implicit name: String): String = s"Hello, $name!"

implicit val defaultName: String = "Scala"

println(greet)

Explanation:

1. def greet(implicit name: String): String = s"Hello, $name!" – Defines greet with an implicit parameter name. If no explicit argument is provided, Scala looks for an implicit value in scope.

2. implicit val defaultName: String = "Scala" – Declares an implicit value defaultName. When calling greet without arguments, defaultName is automatically used.

3. println(greet) – Calls greet without passing a parameter, so Scala injects defaultName ("Scala"), producing "Hello, Scala!".

4. implicit parameters – This feature reduces boilerplate and improves code clarity, especially when configuring dependencies or context-based values.

Example 3: Using Try for Exception Handling

import scala.util.{Try, Success, Failure}

def divide(a: Int, b: Int): Try[Int] = Try(a / b)

val result = divide(10, 0)

result match {
  case Success(value) => println(s"Result: $value")
  case Failure(ex) => println(s"Error: ${ex.getMessage}")
}

Explanation:

1. import scala.util.{Try, Success, Failure} – Imports Try, Success, and Failure, used for handling exceptions safely without using try-catch blocks.

2. def divide(a: Int, b: Int): Try[Int] = Try(a / b) – Wraps a / b inside Try, capturing division errors like division by zero.

3. result match { case Success(value) => println(s"Result: $value") – If division succeeds, value is printed, demonstrating safe handling of successful operations.

4. case Failure(ex) => println(s"Error: ${ex.getMessage}") – If division fails, Failure captures the exception, printing an error message instead of crashing the program.

Example 4: Working with Streams for Infinite Sequences

val stream: Stream[Int] = Stream.from(1)

val evens = stream.filter(_ % 2 == 0).take(5).toList

println(evens)

Explanation:

1. val stream: Stream[Int] = Stream.from(1) – Creates an infinite sequence starting from 1. Stream evaluates elements lazily, computing only when needed.

2. val evens = stream.filter(_ % 2 == 0).take(5).toList – Filters only even numbers from stream, taking the first 5 results and converting them to a List.

3. println(evens) – Prints [2, 4, 6, 8, 10], demonstrating how Stream efficiently generates values without unnecessary computations.

4. Stream vs List – Unlike List, Stream supports lazy evaluation, avoiding excessive memory usage when working with large or infinite sequences.

This concludes Lesson 5 of Scala programming, covering lazy evaluation, implicit parameters, exception handling, and infinite sequences using Streams for efficient and scalable applications.