Okay, we see all the hype about Scala<\/a><\/strong>, you also must have heard about Scala, you want to learn it but you are waiting for a solid reason to learn Scala. Why Scala? This article answers you question “Why should I learn Scala Programming Language?” Let see why Scala is a beneficiary language to learn and what it offers that you. You can share your own reasons to why Scala with us.<\/p>\n Scala automatically infers(detects) the data type of an expression partially or fully. This means that we don\u2019t need to declare it ourselves. Such a facility lets the programmer leave out type annotations while still allowing type checking.<\/p>\n So, how does this work? The compiler takes in the types of subexpressions, or those of atomic values like 42(Integer), true(Bool), and so on. It then aggregates this information, and then decides the type for an expression. Scala has no static variables or methods. Instead, it makes use of a singleton object. This is essentially a class with only a single object in the source file. We do this using the \u2018object\u2019 keyword, and not the \u2018class\u2019 keyword. For instance:<\/p>\n Follow this link to know about Scala Singleton & Scala Companion Object<\/a><\/strong><\/p>\n In Scala, every variable<\/a><\/strong> you declare is immutable by default. You cannot change it. However, you can also explicitly declare it to be mutable. You can change the value of such a variable.<\/p>\n Immutable data helps us manage concurrency control, as you would imagine. Once we create an immutable object, we cannot modify its state.<\/p>\n We discussed this when we talked Scala vs Java. Lazy evaluation is when Scala delays evaluating an expression until it absolutely needs it. This is also called call-by-need. In Scala, we can have a lazy declaration: A Scala case class<\/a> <\/strong>is a regular one that is immutable by default, and is decomposable via pattern matching. All its parameters are immutable and public by default.<\/p>\n Defining a case class takes the keywords \u2018case class\u2019, an identifier, and a parameter list(can be empty).<\/p>\n case class Book(isbn: String)<\/p>\n val frankenstein = Book(“978-0486282114”)<\/p>\n Pattern matching<\/a> <\/strong>lets us check a value against a pattern. You can use this in place of a switch-statement or a series of if-else statements in Java.<\/p>\n Scala\u2019s standard library includes the Actor model. Using this, you can implement concurrency in your code. Apart from this, it also has a platform\/tool, Akka. It is a separate, open-source framework providing for Actor-based concurrency. You can combine or distribute Akka\u2019s actors with software transactional memory.<\/p>\n Scala String interpolation<\/a><\/strong> is the act of evaluating a string literal, consisting of one or more placeholders, to yield a result. In this result, corresponding values replace the placeholders. This is a kind of template-processing. Read: Tuples in Scala<\/a><\/strong><\/p>\n A higher-order function is one that takes another as a parameter, or returns it. This is possible in Scala only because it treats functions as first-class citizens.<\/p>\n Here, map is a higher-order function. Read more about Scala Functions in detail<\/a><\/strong><\/p>\n A trait in Scala<\/a><\/strong> is a type containing certain fields and methods. You can combine multiple traits. So, a trait is like a partially implemented interface. You can create a trait with abstract, and optionally, non-abstract methods. Scala has a huge set of collections in its library. This has classes and traits to help you collect data into a mutable or immutable collection. The scala.collection.mutable package holds all mutable collections. Making use of this package, you can add, remove, and update data. Likewise, the scala.collection.immutable package holds all immutable collections; they don\u2019t let us modify data. Scala is a language of a functional paradigm. It treats its functions as first-class citizens. This is why it also lets us create higher-order functions- ones that can return a function, or take it as a parameter.<\/p>\n It also supports nesting of functions, and currying(translating evaluation of a function, that takes multiple arguments, into evaluating a sequence of functions, each with a single argument).<\/p>\n Scala supports object-oriented programming<\/a><\/strong>, purely. Every value is an object. We\u2019ll have more on this later.<\/p>\n In most cases, you won\u2019t need to specify redundant type information to Scala; it will figure it out on its own. This is in relevance to type inference. Developing domain-specific applications needs domain-specific language extensions. In a way, Scala puts forward a combination of language mechanisms, making it easy to smoothly add new language constructs as libraries. We can do this using facilities like implicit classes and string interpolation. You don\u2019t necessarily need meta-programming features like macros.<\/p>\n The Scala compiler turns the source code into byte code. This runs on the JVM (Java Virtual Machine)<\/a><\/strong>. This makes it a language similar to Java and Groovy.<\/p>\n Some of Scala\u2019s quirks confuse Java programmers:<\/p>\n1. Type Inference<\/h4>\n
\nRead: Features of Scala<\/a><\/strong><\/p>\n2. Singleton Object<\/h4>\n
object Main extends App {\r\n println(\"Hello, World!\")\r\n}<\/pre>\n3. Immutability<\/h4>\n
4. Lazy Evaluation<\/h4>\n
\nThis also avoids repeated evaluations. Lazy evaluation has the following benefits:<\/p>\n\n
\nlazy val images=getImages()
\nRead: Control Structures in Scala<\/a><\/strong><\/p>\n5. Case Classes and Pattern Matching<\/h4>\n
import scala.util.Random\r\nval x: Int = Random.nextInt(10)\r\nx match\r\n{\r\ncase 0 => \"zero\"\r\ncase 1 => \"one\"\r\ncase 2 => \"two\"\r\ncase _ => \"many\"\r\n}<\/pre>\n6. Concurrency Control<\/h4>\n
7. String Interpolation<\/h4>\n
\nSince version 2.10.0, Scala offers string interpolation. The three methods it offers for this are- s, f, and raw.<\/p>\n8. Higher-Order Functions<\/h4>\n
val salaries = Seq(20000, 70000, 40000)\r\nval doubleSalary = (x: Int) => x * 2\r\nval newSalaries = salaries.map(doubleSalary) \/\/ List(40000, 140000, 80000)<\/pre>\n
\nSuch functions also let us implement function compositions, and lambdas.<\/p>\n9. Traits<\/h4>\n
\nTo define a trait, we use the \u2018trait\u2019 keyword:
\ntrait Greeter<\/p>\n{\r\ndef greet(name: String): Unit\r\n}<\/pre>\n
\nNot yet convinced Why Scala is good for you? We have more reasons.<\/p>\n10. Rich Set of Collections<\/h4>\n
\nRead: Best Books for Scala<\/a><\/strong><\/p>\n11. Functional<\/h4>\n
12. Object-Oriented<\/h4>\n
13. Statically-typed<\/h4>\n
\nRead: Scala vs Java<\/a><\/strong><\/p>\n14. Extensibility<\/h4>\n
15. Scala Runs on the JVM<\/h4>\n
16. Miscellaneous Features<\/h4>\n