Scala | Lower Bound
Last Updated :
14 Mar, 2019
Type Bound basically is a kind of restriction on the parameter or the variable. By the usage of these type bounds we can set up limits for the variables. These bounds help to put up our code into real world examples. We need to impose certain limitations and boundaries to every factor in real life, that is what the Type bounds do in Scala.
There are mainly 2 types of Type bounds:
Upper type Bound
Lower type Bound
We will be more concerned about Lower Bounds in this section. Lower type bounds are used to declare a supertype of another type. A lower bound is denoted by >: . Any lower bound statement can be written as ‘[T>:S]’. Here T is a type parameter and S is a type. The above lower bound statement means that the type parameter T must be either same as S of a supertype of S.
Lets understand about supertype, suppose we write S>:T then this lower bound statement always has T equal to S or less than S, meaning that T is bound in this case. So we can say T is a supertype of S.
Syntax:
[T >: Demo[T]]
In the above case we have defined a Lower Bound from type parameter T to type Demo. And T must be either a Demo or a supertype of Demo type.
Let’s take another Example
If I declare all the classes in the certain format as shown below:
trait Food
class eatables extends Food
class drinks extends Food
class fruits extends eatables
class vegetables extends eatables
class cold_drinks extends drinks
class hot_drinks extends drinks
class position[A](val place:A)
Now all the classes as well as the sub-classes have been declared using the above statements. So if we consider the statement position[A], here position is generic and A is the abstract type. This can be further simplified, the position[A] indicates that the value required to pass to place must be of the type A. Which means that if I give a command position[fruits] then it will be created with an instance of Fruits. So to check this we will see one example:
new position[fruits](new fruits)
new position[fruits](new drinks)
new position[eatables](new vegetables)
In the above given example we will notice that the first statement will get compiled but the second statement will show errors because fruits and drinks are not of the same type. On the other hand the third statement will be compiled because vegetable is subtype of eatables. Now using some lower bound commands in the above given statements:
class position[A >: fruits](val place=A)
By this statement we can say that we can position any supertype of fruits which means eatables and Food. So, by this we can definitely see that the lower bounds of Scala can be very useful and adoptive if using some logic for any real world example. Thus we can add all the real life limitations and restrictions over our variables which we are using in the coding language.
Example:
class GeeksforGeeks
class Author extends GeeksforGeeks
class Geeks extends GeeksforGeeks
class ComputerSciencePortal
{
def display [T >: Geeks](d : T)
{
println(d)
}
}
object ScalaUpperBounds
{
def main(args : Array[String])
{
val geeksforgeeks = new GeeksforGeeks
val author = new Author
val geeks = new Geeks
val computerscienceportal = new ComputerSciencePortal
computerscienceportal.display(geeksforgeeks)
computerscienceportal.display(geeks)
computerscienceportal.display(author)
}
}
|
Output:
GeeksforGeeks@506e1b77
Geeks@4fca772d
Author@9807454
Here, Lower bound is defined in class ComputerSciencePortal, and GeeksforGeeks is the Super class of Author. it is accepted in lower bound.
class Principal
class Teacher extends Principal
class Student extends Teacher
class School
{
def display [T >: Teacher](t : T)
{
println(t)
}
}
object ScalaUpperBounds
{
def main(args : Array[String])
{
val principal = new Principal
val teacher = new Teacher
val student = new Student
val school = new School
school.display(principal)
school.display(teacher)
school.display(student)
}
}
|
Output:
Principal@506e1b77
Teacher@4fca772d
Student@9807454
Here, we have defined Lower bound in Class School i.e, [T >: Teacher] which implies that display method accepts Principal class object or subclass of it(i.e. Teacher) or subclass of Teacher class (i.e. Student) which means that super class of Teacher will be accepted.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...