PragPub 2011-10: Issue #28 by The Pragmatic Bookshelf

Author:The Pragmatic Bookshelf
Language: eng
Format: epub, mobi
Tags: PragPub—Monthly Magazine
Publisher: The Pragmatic Bookshelf, LLC
Published: 2011-10-01T04:00:00+00:00

Scala for the Intrigued

Sensible Typing and Optional Items

by Venkat Subramaniam

In this second installment of this series on the Scala programming language, Venkat shows how Scala’s static typing leads to low ceremony programming.

In this second part of the series we will look at the statically typed nature of Scala and its low ceremony.

Java programmers are used to static typing. Scala is also statically typed. However, it employs type inference to figure out types at compile time. So for the most part, you don’t have to specify type information. While Scala provides type inference, it does not go to extremes to determine the type (like F#, for example, which will analyze the method body to figure out types of parameters). Scala type inference reduces the number of keystrokes you have to type and reduces noise in code without compromising readability or understandability.

Let’s first look at how we’d define a variable, set its type, and assign it an initial value. Then we can look at what type inference buys us.

var greet : String = "hello"

You use var to define a mutable variable, a variable whose value can change (true to its varying nature). When defining a variable, use a colon to separate the name of the variable from its type. Finally you can assign a value to the variable using the all-too-familiar equals operator.

Let’s extend that example to change the variable’s value and print the new value.

var greet : String = "hello"

println(greet)

greet = "howdy"

println(greet)

We initialized the variable greet to “hello” and then changed it to “howdy.” The output from the code is shown below:

hello

howdy

At this point if you listen keenly you may hear Scala laughing at the redundancy in typing. Scala already knows that greet is of type String from the fact that its value was initialized to “hello.” So, the : String part is redundant, and you can omit it:

var greet = "hello"

println(greet)

greet = "howdy"

println(greet)

Scala infers the type of the variables at compile time. If Scala notices any ambiguity or errors, it will report right away and will not run any part of the code.

Let’s see what happens if we try to set a value of the greet variable to something not compatible with its type:

var greet = "hello"

println(greet)

greet = 1

println(greet)

When you try to run this script, you will get an error:

error: type mismatch;

found : Int(1)

required: java.lang.String

greet = 1

Scala is quick to tell us that the value 1 we’re assigning to the variable does not match with the type String, the type which it inferred at the point of declaration.

Scala’s type inference plays well far beyond simple variable declarations, too. For instance, in the declaration

val numbers : List[Int] = List(1, 2, 3)

the type declaration is redundant and you can write it as:

val numbers = List(1, 2, 3)

I must acknowledge that this can be a blessing or a curse, depending on how you look at it. numbers is inferred as a List[Int] based on the values you present to the list. If all the values are of the same type, then this is not a concern.

Download

Copyright Disclaimer:
This site does not store any files on its server. We only index and link to content provided by other sites. Please contact the content providers to delete copyright contents if any and email us, we'll remove relevant links or contents immediately.