From Python to Scala (II): Types, Variables & Values

Blog Logo

on
30 Jul 2014

read

Following my series of tutorial of Scala for Python programmers, I’ll start to
talk about something most Python programmers don’t usually pay attention to
because the language doesn’t require it to do so.

Scala Types

I’m talking about data types. It’s not that Python doesn’t have types for its
variables, but as it is a dynamically typed programming language, you usually
don’t care about the type of the variable. At least not unless you try to add a
number and a letter: you cannot add apple and oranges, naturally you cannot add
strings and numbers (not at least without conversion first):

In general terms, however, Python won’t bother about the type you are giving to
your variables: actually, you won’t be able to declare a type for them as Python
will infer it. So, this is perfectly normal for a Python program:

string="This is a string"print(string)# Will output "This is a string"string+100# Invalid. Will result in a TypeError exception.string=100# Perfectly valid. `string` type will be int from now on.print(string)# Will output 100string+100# Valid. Will result in 200.

In Scala this is not the case. Once a variable is assigned a type, it will have
it until the end of that variable’s scope. Of course, as in Python, some
operations between variables of different types are not permitted. However, in
this case, sum is not one of those cases. If you add a string to a number, Scala
will automatically transform the number into a String and result in a String
concatenation:

varstring="This is a string"println(string)// Will output "This is a string"
string+100// Valid. Will result in the string "This is a string100"
string=100//Invalid.Willresultina"type mismatch"error.

Scala, as well as Python, can infer the type of the variables you are using.
But, it add the possibility to declare the type of the variable (something that
many times comes in handy as we will see in future tutorials):

varstring:String="This is a string with declared type"varnum:Int=100//Thisisanumberwithdeclaredtype

Scala has a variety of types (you should check on the Scala Documentation for more information on
it), but the most common are Int (sometimes written as Integer), String, Long,
Float, Double and Boolean.

Although many Python fans can call this a disadvantage, I personally end up
having better experience with static data typing, as I feel I have more control
over the variables of my application. Then again, this is just a matter of
opinion.

Variables and Values

So, now you know that Scala is statically typed, which means once you give
variable a type (either inferred by the compiler or declared by the programmer)
you cannot set that variable to a value of another type.

Scala has also two kinds of “variables”: mutable and immutable. Ok, maybe it has
only one type of variable, the ones that are mutable, since there is no much
variation in the immutable type. For making this simpler, let’s say Scala has to
type of storage locations.

Mutable variables, or just variables, are the classic ones and the most near in
concept to the ones use by Python (with the static type exception). You can
create them with one value and the change them through the whole scope to
whatever value of the same type you want. They are declared with the reserved
word var.

Immutable variables, or values, are the ones that will have a constant value
during the whole scope of the variable. If you try to change the value for
another one (even of the same type), the compiler will throw an error. Values
are declared with the reserved word val.

varvariable:Int=10// This is a Scala variable.
variable=20// Valid. "variable" is now set to value 20.
valvalue:Int=10// This is a Scala value.
value=20//Invalid.Willresultinacompilererror.

If you are coming from the Python environment (or, more in general from a
imperative paradigm environment) you would think values don’t have any
usefulness beyond declaring a constant. Nevertheless, in Scala values are quite
fundamental. This is because Scala has been designed as an object-oriented
functional language. The word functional is a big deal here, because the
functional paradigm is quite different from the imperative paradigm which most
of Python programmers are used to.

If you ever tried something like LISP, Haskell or Earlang (also known as
academic languages), the concept of stateless is not a stranger to you. For
most of Python programmers, this is quite unusual though. In the most simple
terms stateless is defined by math functions: you apply a function to some
parameters and get a result. For the same parameters you get the same result
every time, and there will never be an inner state of the function that will
modify that returned value. Stateful (although you probably didn’t hear it under
that name) is more common among imperative languages, and means you have a state
that can change the final computation.

This is not a tutorial for functional programming (not even on Scala) but to
understand the basics of Scala. Scala is a multi-paradigm language and can be
used for imperative programming. Still, if you are learning Scala I would
recommend you to learn something on functional programming. Otherwise you will
be wasting the full Scala potential. If you are interested in this matter there
should be lots of tutorials and resources on the internet, but my personal
recommendation is to take the Functional Programming Principles in Scala, in
Coursera, by Martin Odersky (the creator of the
Scala language).

I think is more than enough for this session. As always I appreciate any
feedback on comments (event to tell me I’m having some grammar or spelling
mistakes). Thank you for reading!