Improper type assignation
Need
Enforcement of proper type assignment and declaration
Context
- Usage of Scala for building scalable and functional applications
Description
Non compliant code
var data = 10
data = "Hello, World!"
In the above Scala code snippet, we have a variable data which is initially assigned an integer value 10. However, in the next line, we are assigning a string value "Hello, World!" to the same variable data.
This is a clear example of a variant variable, where no specific type is declared for the variable data. This practice can lead to potential bugs and inefficiencies in the code because Scala has to identify the variable's data type and cast it every time it is used.
In Scala, type inference is a powerful feature, but it should be used judiciously. It is always a good practice to declare the type of a variable explicitly when its usage is not immediately clear. This not only makes the code more readable but also avoids potential runtime errors due to type mismatch.
Steps
- Identify the specific data type that the variable should hold
- Declare the variable with the appropriate data type
- Assign the initial value to the variable with the correct data type
- Avoid reassigning the variable with a different data type
Compliant code
val dataInt: Int = 10
val dataString: String = "Hello, World!"
The original code had a variable data that was initially assigned an integer value, and later reassigned a string value. This is a type safety issue and can lead to runtime errors in Scala.
In the fixed code, we have declared two separate variables, dataInt and dataString, with explicit data types Int and String respectively.
The val keyword is used instead of var to declare the variables as immutable, meaning their values cannot be changed once assigned. This is a good practice in Scala to avoid accidental reassignment and to make the code safer and easier to reason about.
The dataInt variable is assigned the integer value 10, and the dataString variable is assigned the string value "Hello, World!". Now, each variable holds a value of the correct, expected type, and there is no risk of type errors related to these variables.