I’ve decided to learn (at least the basics) of Scala. This post will cover the standard programming constructs and features, whilst not intended to be in depth, it will act as an entry into using Scala or a reminder for myself.<\/p>\n
Note: I will be writing this post as somebody who comes from a C# background and has also used F#. So, sorry if you’re reading this and thinking “I don’t know what F# would look like” for example.<\/em><\/p>\n val and var<\/strong><\/p>\n A val<\/em> is immutable whereas a var<\/em> is not. Hence assuming we have the following<\/p>\n The we can assign our val thus<\/p>\n whereas our var will allow reassignment, hence<\/p>\n Simple enough.<\/p>\n Types<\/strong><\/p>\n I’m not going to list all the types supported in Scala – ofcourse we have Int, String etc. What I will say though, is like F#, a type may be inferred or we might specify the type where a hint is required<\/p>\n Let’s see how we can use a type<\/p>\n We declare a type after the name of the val\/var, as per the example above. <\/p>\n There’s an ultimate base type in Scala (a little like object in C#) and this is called Any<\/em>. According to Unified Type System<\/a> this Any<\/em> type is not the same as the java.lang.Object<\/em>. In Scala we have AnyRef<\/em> which IS analogous to java.lang.Object<\/em> whereas AnyVal<\/em> is the equivalent base of value types. Ofcourse Any<\/em> is the base of both AnyValue<\/em> and AnyRef<\/em>.<\/p>\n Like F#, Scala prefers the idea of a Nothing<\/em> value than a null<\/em> but (again like F#) null is also supported.<\/p>\n Scala, ofcourse, supports collections and arrays. <\/p>\n We can declare and array with type expected type or inferred, for example, these two arrays create the same type of array<\/p>\n To access\/alter an array at a given index we again use brackets (), i.e.<\/p>\n Return values<\/strong><\/p>\n When a method returns a value we can use the return function, for example <\/p>\n or without parenthesis, i.e. return 123<\/em> or, like F# the return can also be the last line of the function, i.e.<\/p>\n and with the type being inferred we can reduce this further to <\/p>\n Loops<\/strong><\/p>\n The for<\/em> loop, using the to<\/em> function, for example <\/p>\n The for<\/em> loop, using the until<\/em> method<\/p>\n to<\/em> and until<\/em> are methods, hence we could use the following syntax<\/p>\n each of the above does the same thing, just with different syntax. What each of these methods does is return a Range, for example, in the the following code r<\/em> is of type Range<\/p>\n It’s always worth noting the i<\/em> is a val (hence immutable) type and is created each time through the loop. <\/p>\n Note: So how can “to” and “until” be used without parenthesis? If a method is zero or one arguments, we do not need the parenthesis. Therefore, if we have code like this<\/em><\/p>\n Back to loops, so we have a for<\/em> loop, we’ve also got while<\/em> loops so <\/p>\n as well as do…while<\/em><\/p>\n like C#\/Java we can also break<\/em> out of a loop, however this keyword is not part of Scala. To use, we need to import the functionality using <\/p>\n Importing functionality\/libraries<\/strong><\/p>\n As you’ve seen with the Breaks.break<\/em> method, we can import functionality as we do in C# with using and import in Java, like this <\/p>\n The use of the _ is like a saying import everything within the scala.util.control namespace and we’ll then use code like Breaks.break<\/em> to call the method, but we could also be more explicit and change our code to be like this <\/p>\n Like F# being built atop .NET and therefore allowing us access to a rich framework and eco-system, Scala is built upon Java and hence allows us access to it’s rich set of frameworks etc.<\/p>\n in the above, it’s probably obvious, we’re using the Java Date class, we can import multiple specific classes like this <\/p>\n or for all (as already seen)<\/p>\n Classes and Objects<\/strong><\/p>\n We can define a class as follows<\/p>\n By default (i.e. without an scope declaration) classes are public, we could prefix the class thus private class Report<\/em> to change from the default.<\/p>\n The msg: String<\/em> is like a constructor (a similar design came up for Primary constructors<\/a> in C# 6) but we can also create overload for the constructor like this<\/p>\n We can also define an object<\/em> like this <\/p>\n In scala this is known as a singleton object, I would say similar to a static class in C#. Hence does not have a constructor as we cannot create an instance of Report<\/em> and we do not use the new<\/em> keyword to use it, i.e.<\/p>\n It’s also possible to associate an object<\/em> with a class<\/em>, for example<\/p>\n This pairing of class<\/em> with an object<\/em> is known as a companion class and vice versa we can think of the object as the companion object. In the example above, we’ve defined the equivalent of a static method in the object and the class output calls this. Obviously this is a slightly convoluted example, but another use is that the object might include (for example) private fields which are used from the class, like this<\/p>\n alternatively, we can import<\/em> the object and remove the need to prefix use of name<\/em> with Report<\/em> – like this<\/p>\n Commenting code<\/strong><\/p>\n As you’ve seen in some of the examples, scala supports \/\/ for single line comments as well as the standard (at least in C style languages) \/* *\/<\/p>\n\r\nobject Calculator {\r\n def add(a: Int, b: Int): Int = {\r\n a + b\r\n }\r\n\r\n def subtract(a: Int, b: Int): Int = {\r\n a - b\r\n }\r\n}\r\n<\/pre>\n\r\nval calc = Calculator\r\n\r\n\/\/ this line will error\r\ncalc = Calculator\r\n<\/pre>\n
\r\nvar calc = Calculator\r\n\r\n\/\/ this line will success\r\ncalc = Calculator\r\n\r\n<\/pre>\n
\r\nval inferredString = "Hello"\r\nval explcitString : String = "Hello"\r\n<\/pre>\n
\r\n\/\/ explicit\r\nval a = Array[String]("a", "b")\r\n\/\/ inferred\r\nval b = Array("a", "b")\r\n<\/pre>\n\r\nval a = Array("a", "b")\r\n\/\/ amend "b" to "c"\r\na(1) = "c"\r\n<\/pre>\n\r\ndef result : Int = {\r\n return(123)\r\n}\r\n<\/pre>\n\r\ndef result : Int = {\r\n 123\r\n}\r\n<\/pre>\n\r\ndef result = {\r\n 123\r\n}\r\n<\/pre>\n\r\nfor(i <- 1 to 3) {\r\n print(i);\r\n}\r\n\r\n\/\/ will print\r\n\/\/ 123\r\n<\/pre>\n\r\nfor(i <- 1 until 3) {\r\n print(i);\r\n}\r\n\r\n\/\/ will print\r\n\/\/ 12\r\n<\/pre>\n\r\nfor(i <- 1 to 3) {}\r\nfor(i <- 1 to.(3)) {}\r\nfor(i <- 1.to(3)) {}\r\n<\/pre>\n\r\nval r = 1.to(3)\r\n\r\nfor(i <- r) {\r\n print(i)\r\n}\r\n<\/pre>\n\r\nobject Calculator {\r\n def inc(a : Int): Int = {\r\n a + 1\r\n }\r\n}\r\n\r\n\/\/ we can do this\r\n\r\nval calc = Calculator\r\nval r = calc inc 2\r\n<\/pre>\n\r\nvar i = 0\r\nwhile(i < 3) {\r\n print(i)\r\n i = i + 1\r\n}\r\n<\/pre>\n\r\nvar i = 0\r\ndo {\r\n print(i)\r\n i = i + 1\r\n} while(i < 3)\r\n<\/pre>\n\r\nimport scala.util.control._\r\n\r\nvar i = 0\r\nwhile(true) {\r\n print(i)\r\n i = i + 1\r\n if(i == 3)\r\n Breaks.break\r\n}\r\n<\/pre>\n\r\nimport scala.util.control._\r\n<\/pre>\n
\r\nimport scala.util.control.Breaks.break\r\n\r\n\/\/ other code\r\nif(i == 3)\r\n break\r\n<\/pre>\n
\r\nimport java.util.Date\r\n\r\ndef output = print(new Date() + ":" + msg)\r\n<\/pre>\n
\r\nimport java.util.{Date, Locale}\r\n<\/pre>\n\r\nimport java.util._\r\n<\/pre>\n
\r\nclass Report(msg: String) {\r\n\r\n def output = println(msg)\r\n}\r\n<\/pre>\n\r\nclass Report(msg: String) {\r\n\r\n def this(msg: String, num: Int) = this(msg + " " + num.toString)\r\n def this(num: Int, msg: String) = this(msg + " " + num.toString)\r\n\r\n def output = println(msg)\r\n}\r\n<\/pre>\n\r\nobject Report {\r\n\r\n def output(msg: String) = println(msg)\r\n}\r\n<\/pre>\n\r\nval s = Report\r\ns.output("Hi")\r\n<\/pre>\n\r\nclass Report(msg: String) {\r\n\r\n def this(msg: String, num: Int) = this(msg + " " + num.toString)\r\n def this(num: Int, msg: String) = this(msg + " " + num.toString)\r\n\r\n def output = Report output(this.msg)\r\n}\r\n\r\nobject Report {\r\n def output(msg: String) = println(msg)\r\n}\r\n<\/pre>\n\r\nclass Report(msg: String) {\r\n\r\n def this(msg: String, num: Int) = this(msg + " " + num.toString)\r\n def this(num: Int, msg: String) = this(msg + " " + num.toString)\r\n\r\n def output = print(Report.name + ":" + msg)\r\n}\r\n\r\nobject Report {\r\n private def name = "Report"\r\n}\r\n<\/pre>\n\r\nclass Report(msg: String) {\r\n\r\n import Report._\r\n\r\n def this(msg: String, num: Int) = this(msg + " " + num.toString)\r\n def this(num: Int, msg: String) = this(msg + " " + num.toString)\r\n\r\n def output = print(name + ":" + msg)\r\n}\r\n\r\nobject Report {\r\n private def name = "Report"\r\n}\r\n<\/pre>\n