Partial Functions in Scala

In Scala, a partial function is a trait that allows you to define a function domain for which the function is defined and can produce a result. In other words, it's a function that doesn't provide answers for every possible input. The PartialFunction trait has two main methods: isDefinedAt and apply.

isDefinedAt: This method checks if the function is defined for a particular input.
apply: This method computes the result for a given input, but should only be called for inputs for which isDefinedAt returns true.

Here's a simple example of a partial function:

val divide: PartialFunction[(Int, Int), Int] = {
  case (x, y) if y != 0 => x / y
}

In this example, the divide function is only defined for pairs of integers where the second integer is not zero.

You can use the isDefinedAt method to check if the function can handle a specific input:

println(divide.isDefinedAt((10, 0)))  // false
println(divide.isDefinedAt((10, 2)))  // true

And you can use the function directly for inputs that are within its domain:

if (divide.isDefinedAt((10, 2))) {
  println(divide(10, 2))  // 5
}

However, invoking divide(10, 0) directly will lead to a MatchError since it's not defined for that input.

Using `collect` with Partial Functions:

Partial functions are particularly useful with methods like collect on collections. The collect method allows transformation only for elements that satisfy the function's domain:

val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9)

val evenSquares: PartialFunction[Int, Int] = {
  case x if x % 2 == 0 => x * x
}

val squared = numbers.collect(evenSquares)
println(squared)  // List(4, 16, 36, 64)

In this example, only even numbers are squared, and the result is a list containing these squared values.

Conclusion:

Partial functions in Scala provide a way to define functions that are not applicable to every possible input and can be beneficial for defining specific transformations or operations that are only valid in certain scenarios. They're especially handy in conjunction with methods like collect on collections.

Introduction to Partial Functions in Scala:
A partial function is a function that is not defined for all possible input values. It's defined only for a subset of the input domain.
```
val divide: PartialFunction[Int, Int] = {
  case x: Int if x != 0 => 10 / x
}
```
Partial Functions vs. Total Functions in Scala:
Total functions are defined for all input values, while partial functions are not. Partial functions use pattern matching to determine if they are defined for a given input.
```
// Total Function
val totalFunction: Int => Int = x => x * 2

// Partial Function
val partialFunction: PartialFunction[Int, Int] = {
  case x: Int if x > 0 => x * 2
}
```
Pattern Matching with Partial Functions in Scala:
Partial functions often use pattern matching to define their behavior.
```
val divide: PartialFunction[Int, Int] = {
  case x: Int if x != 0 => 10 / x
}

val result = divide(5) // Result: 2
```

Handling Undefined Inputs with Partial Functions:

isDefinedAt method helps check if a partial function is defined for a particular input.

val divide: PartialFunction[Int, Int] = {
  case x: Int if x != 0 => 10 / x
}

if (divide.isDefinedAt(0)) {
  val result = divide(0)
  println(result)
} else {
  println("Undefined input")
}

Using 'case' Statements for Partial Functions in Scala:
Partial functions can be defined using case statements to handle different input patterns.
```
val greet: PartialFunction[String, String] = {
  case "Alice" => "Hello, Alice!"
  case "Bob" => "Hello, Bob!"
}
```

Partial Functions Composition in Scala:

Partial functions can be composed using the orElse method to create a new partial function.

val greetAlice: PartialFunction[String, String] = {
  case "Alice" => "Hello, Alice!"
}

val greetBob: PartialFunction[String, String] = {
  case "Bob" => "Hello, Bob!"
}

val greet = greetAlice orElse greetBob

Error Handling with Partial Functions in Scala:
Partial functions can be used for error handling by defining cases that handle exceptional conditions.
```
val safeDivide: PartialFunction[(Int, Int), Int] = {
  case (x, y) if y != 0 => x / y
}
```

Practical Examples of Partial Functions in Scala:

Partial functions are commonly used in scenarios where a function is not defined for all inputs, such as user input validation or handling specific cases.

val validateUserInput: PartialFunction[String, Boolean] = {
  case input if input.matches("[0-9]+") => true
  case _ => false
}

val userInput = "123"
if (validateUserInput.isDefinedAt(userInput)) {
  println("Input is valid!")
} else {
  println("Invalid input!")
}

Partial Functions in Scala

Using collect with Partial Functions:

Conclusion:

Using `collect` with Partial Functions: