Intermediate Scala test (Intermediate)

Sample questions

5 sample questions from the Intermediate Scala test, with the answers. Samples are taken out of the live test, so you will not meet these when you sit it.

1. A Scala developer is encountering a compilation error when using `getOrElse` on an `Option[Int]` with a default value of type `String`. What is the most likely cause of this bug?

   1. The bug is in the usage of `getOrElse` without handling the case when the `Option` is empty.
   2. The bug is in the usage of `getOrElse` with a default value that is not compatible with the expected return type.
   3. The bug is due to incorrect syntax in the `getOrElse` method call.
   4. The bug is due to a missing import for the `getOrElse` method.

   Answer: B. The bug is in the usage of `getOrElse` with a default value that is not compatible with the expected return type.

   The `getOrElse` method on `Option` is used to provide a default value when the `Option` is empty. If the default value is not of the same type as the `Option`, it will cause a type mismatch error. In this case, the bug is due to providing a default value of an incompatible type.

2. Which of the following is the correct way to apply a curried function `f` that takes two arguments in Scala?

   1. f((1, 2))
   2. f(1, 2)
   3. f(1, 2, 3)
   4. f(1)(2)

   Answer: D. f(1)(2)

   In Scala, currying is the process of transforming a function that takes multiple arguments into a sequence of functions, each taking a single argument. When applying a curried function, you must provide one argument at a time. Therefore, the correct way to apply a curried function `f` with two arguments is `f(1)(2)`. The other options are either incorrect syntax or do not follow the currying pattern.

3. Which of the following best describes the difference between a partial function definition and a regular function definition in Scala?

   1. A partial function definition is used when the function is defined for all inputs, and it explicitly states the domain of applicability using the `case` syntax, whereas a regular function is only defined for certain inputs and does not distinguish between valid and invalid cases.
   2. A partial function definition is used when the function is only defined for certain inputs, and it explicitly states the domain of applicability using the `case` syntax, whereas a regular function is only defined for certain inputs and does not distinguish between valid and invalid cases.
   3. A partial function definition is used when the function is defined for all inputs, and it explicitly states the domain of applicability using the `case` syntax, whereas a regular function is defined for all inputs and does not distinguish between valid and invalid cases.
   4. A partial function definition is used when the function is only defined for certain inputs, and it explicitly states the domain of applicability using the `case` syntax, whereas a regular function is defined for all inputs and does not distinguish between valid and invalid cases.

   Answer: D. A partial function definition is used when the function is only defined for certain inputs, and it explicitly states the domain of applicability using the `case` syntax, whereas a regular function is defined for all inputs and does not distinguish between valid and invalid cases.

   A partial function definition is appropriate when a function is only applicable for certain inputs, and it uses the `case` syntax to define those inputs explicitly. A regular function, on the other hand, is defined for all possible inputs and does not make such distinctions. The `PartialFunction` trait in Scala is used for this purpose, and it is typically used in pattern matching scenarios where not all input cases are covered.

4. Consider the following code snippet: `type Angle = Int`. A developer is using this type alias to represent angle values in a trigonometry-related application. However, they are encountering precision issues when working with fractional angles. What is the correct way to fix this bug?

   1. The bug is in the assignment of the angle value. The angle value should be converted to an `Int` before being assigned to a variable of type `Angle`.
   2. The bug is in the comparison logic. The comparison should be performed using `==` instead of `equals`.
   3. The bug is in the method that uses the `Angle` type. The method should be changed to accept `Int` instead of `Double`.
   4. The bug is in the type alias definition. The type alias should be defined as `type Angle = Double` instead of `type Angle = Int` to ensure that the angle values are represented with floating-point precision.

   Answer: D. The bug is in the type alias definition. The type alias should be defined as `type Angle = Double` instead of `type Angle = Int` to ensure that the angle values are represented with floating-point precision.

   The type alias `type Angle = Int` is incorrect because angles are typically represented as floating-point numbers (e.g., in radians or degrees) rather than integers. Using `Int` could lead to precision loss when dealing with fractional angle values. The correct definition would be `type Angle = Double` to ensure accurate representation of angle values.

5. What is the difference between implicit and explicit conversions in Scala?

   1. Implicit conversions are used to automatically convert one type to another, whereas explicit conversions require the programmer to explicitly call a method or function for the conversion.
   2. Implicit conversions are used to convert a value to a String, whereas explicit conversions are used for converting a String to another type.
   3. Implicit conversions are used to convert a String to another type, whereas explicit conversions are used to convert a value to a String.
   4. Implicit conversions are used for type inference, whereas explicit conversions are used for type erasure.

   Answer: A. Implicit conversions are used to automatically convert one type to another, whereas explicit conversions require the programmer to explicitly call a method or function for the conversion.

   Implicit conversions allow the compiler to automatically convert one type to another when needed, which can make code more concise. However, they can also lead to unexpected behavior if not used carefully. Explicit conversions, on the other hand, require the programmer to explicitly call a method or function for the conversion, making the code more readable and less error-prone in some cases. Therefore, the correct answer is the one that describes the difference between implicit and explicit conversions accurately.