Search for a command to run...
Travel | Movies | History | Nature
I am a software developer. Started my career as a Java developer, but later switched to Scala. I wish to write Scala articles which are easier for newbies to follow. I love to travel, prefer to be alone or in very small group. Love to watch movies/series.
No comments yet. Be the first to comment.
Implementing Continuous Data Flows with FS2 Streaming
Building Resumable Data Pipelines with Redis-backed Offset Tracking and Batch Processing
Creating Flexible Data Integration Patterns for Cross-System Data Movement
How to leverage Scala 3 Mirrors to generically parse CSV files into case classes, making data handling more flexible and type-safe.
Introduction Recently, at work, there was a requirement to list out the direct dependencies of the our SBT project, something like Bill Of Materials. SBT itself provides the dependencies as list or tree or searchable HTML page using the built-in comm...
Programming languages utilize the concept of Tagged Type to enhance type safety and mitigate common errors. While not a standard library feature, Scalaz, Shapeless, and Scala-Common offer their own implementations. Other options for Tagged Type consist of Case Classes, Value Classes, Opaque Type Aliases, and the refined library.
Tagged Type is a concept used in programming languages to enrich the type and avoid some common mistakes. For example, assume that we have a method which takes 2 String parameters, userId and name:
def printInfo(userId: String, name: String) = {
println(s"HEY, userId: $userId and name:$name")
}
While invoking the printInfo function, if we accidentally provide name in place of userId and vice versa, the compiler will not show any error as the syntax is correct.
So we can call the function as:
printInfo("user234", "Yadu Krishnan")
printInfo("Yadu Krishnan", "user234")
To avoid such mistakes, tagged types come in handy. The main advantage is that the add-on type it is erased after compilation, so that only the underlying original type will exist in the runtime. This will reduce the runtime overhead, but provide safety at compile time.
Tagged types are not available in Scala standard library. Many libraries like Scalaz, Shapeless, Scala-Common, etc have their own implementation. Here, let's look at how we can use Shapeless implementation of Tagged Type.
Shapeless provides the method tag to mark a type with additional information. We create empty traits to tag a type first.
trait UserId
trait Name
Now let's modify printInfo() function to use tagged types instead of String:
def printInfo(userId: String @@ UserId, name: String @@ Name) = {
println(s"HEY, userId: ${formatString(userId)} and name:${formatString(name)}")
}
def formatString(str: String) = s"`${str}`"
Here, userId parameter is having the type String@@UserId and name is of type String@@Name. The type on the left side of @@ is the original type. Now, let's see how we can invoke the function:
val userId = tag[UserId][String]("user234")
val name = tag[Name][String]("Yadu Krishnan")
printInfo(userId, name)
If we try to call the method with wrong parameter, it will show compilation error:
printInfo(name, userId) // compilation error
printInfo("hey","heyhey") // compilation error
We can directly use this tagged type where the underlying type is needed. For example, the method formatString() in the previous code sample takes a parameter String. Without any transformation, we can directly call formatString(userId). Full code sample is available in Github as a gist.
Since tagged type is not available in the standard library, each libraries implements its own version. So there is no standard or interchangeable version for this approach.
There are some alternatives in Scala for Type Tagging. But each one has its own advantages and disadvantages. Depending on the situation, we can select the best way to handle such scenario(including the usage of @@ if you are already using a supporting library)
Some of the alternatives that can be checked are:
Using Case Classes instead of simple types
Using Value Classes
Using Opaque Type Alias in Scala-3
Slightly different scenario, but can consider refined library.