por Pattern Matching in Scala is one of the basic libraries of this programming language. In effect, through this series of commands, functions are established that help in the processing of big data as part of this vast world of Big Data processing.
Without a doubt, this type of knowledge about one of the most used programming languages is established as fundamental for a good Data Scientist. Thus, In this post, we will explain what Pattern Matching is in Scala and what are its main categories.
What is Scala?
As a first instance, before explaining what Pattern Matching is in Scala, it is essential to know what the Scala programming language means within the Big Data world.
Well, Scala was created in 2003 by Martin Odersky at the EPFL (Federal Polytechnic School of Lausanne) and, as already mentioned, currently It is one of the most used programming languages for the management and development of Big Data.
It is even used by powerful companies such as Twitter, Coursera, Disney, Telefónica or Netflixamong other.
Lastly, Scala is a general purpose language running on the JVM (Java Virtual Machine or Java Virtual Machine), is multiparadigm, functional and is object oriented. Therefore, it not only works with Big Data, but is also implemented in DSL projects (Digital Subscriber Line or Digital Subscriber Line).
What is Pattern Matching in Scala?
Pattern Matching in Scala is a strategy of this popular programming language that It consists of considering one object with respect to others. So the category, value or expression of a data is evaluated when compared to the other categories, values or expressions of the rest of the data that is being processed.
Definitely, Pattern Matching in Scala is one of the most vigorous operationssince once the parameters with which the data will be governed are established, the object can be deconstructed based on these.
Well, within Pattern Matching in Scala, you can find two series of commands: one basic and one with extractors.
Basic Pattern Matching
First of all, Basic Pattern Matching in Scala consists of the simplest options to identify a pattern according to the value being worked on. Next, We share a brief illustrative example in this regard:
def defcon(level: Int): String = {
level match {
case 1 => «Nuclear war is imminent»
case 2 => «Next step to nuclear war»
case 3 => «Increase in force readiness above that required for normal readiness»
case 4 => «Increased intelligence watch and strengthened security measures»
case 5 => «Lowest state of readiness»
case_ => throw new Exception(«Invalid defcon value»)
}
def canSwim(bird: Bird): Boolean =
bird matches {
case : Swimmer => true
case_ => false
}
def isFullEquip(bird: Bird): Boolean =
bird matches {
case b if b.isInstanceOf[Swimmer] && b.isInstanceOf[Flying] => true
case _ => false
}
On the other hand, Pattern Matching Extractors or Scala Extractor refers to the ability to track pattern matches based on an extractor object. Below, we present an example of how its syntax is developed:
case class User(name: Stringemail: String)
def isGmailUser(user: User): Boolean =user matches {
case User(email) if email.endsWith(«@gmail.com») => true
case => false
}
def parseArg(arg : Stringvalue: Any) = (arg, value) matches {
case («-l», lang: String) => setLanguageTo(lang)
case («-i», iterations: Int) => setIterationsTo(iterations)
case («-h» | «–help», _) => displayHelp()
case unk => throw new Exception(s»Unsupported argument ${unk._1}${unk._2}»)
}
sealed trait Expression
case object x extends Expression
case class Const(value: Int) extends Expression
case class Add(left: Expression, right: Expression) extends Expression
case class Mult(left: Expression, right: Expression) extends Expression
def eval(expression : Expression, xValue: Int): Int = expression matches {
case X => xValue
case Const(value) => value
case Add(left, right) => eval(left, xValue) + eval(right, xValue)
case Mult(left, right) => eval(left, xValue) * eval(right, xValue)
}
val expr = Add(Const(1), Mult(Const(2), Mult(X, X)))
eval(expr, 2) // 9
case class User(name: Stringemail: Stringactivate: Boolean)
user matches {
case user @ User(, , true) => save(user)
case _ => _
}
How to continue learning about Big Data?
In this post, Have you learned what Pattern Matching is in Scala?, from theory and also from practice. Nevertheless, This knowledge requires discipline and development in console practice through a trial and error methodology. For this reason, It is necessary to continue learning about it.
If you still don’t know how, at we offer you the Full Stack Big Data, Artificial Intelligence & Machine Learning Bootcamp. Through this, you will be introduced to the theories of machine learning with an emphasis on regression and classification algorithms. So that, Over time, you will be able to know the advantages and disadvantages of the different algorithms analyzed. In addition, you will gain experience thanks to the fact that the fundamentals are merged with practical and realistic examples so that you can apply them. Request information, sign up now and keep learning!