* Collection of Notes about Scala Programming Language *
* Data types
* Control structures and Logical expressions
** About Case expressions :
You can use '|' to combine various case options.
** You can't use break or continute, use boolean variables in place.
* Function and methods
** When passing arguments to a method, you should enclose the argument in () if
they also explicitly specify type.
** You should always use = to define methods.
** You can use somewhat ugly () to return Unit from a method.
** backend_connection? is a invalid method name, while backend_conneciton_?
isn't.
** For using variadic functions, one should specify type with a * suffix.
def helloWorld(arg: Int*) = { }
One can use Any* for generic types.
** Scala compiler won't do type inference for function calls and hence type
must be specified while defining the functions.
** The equals sign that precedes the body of a function hints that in
the functional world view, a function defines an expression that results in a
value.
** Partial Applied Functions :
** A method name that ends with ":" is applied right to left and hence a:::b
will apply as b.:::(a)
** When you are invoking a method that takes tuples as parameters, you should
surround it with additional parenthesis. For example:
Following invocation won't pass a tuple.
tSet += ("Air","Tel")
But if you have to pass a tuple:
tSet.takesTuple(("Air","Tel"))
** 1 -> "lol" will return a two element tuple. The mechanism which allows us to
invoke -> on any object is called implicits in scala.
** One gotcha to watch out for is that whenever you leave off the equals sign
before the body of a method, its result type will definitely be Unit.
** When you are using Method chaining, you should always put the operator at
the end.
* Classes and Object Orientation
** When you use Method overloading, you must specify return type clearly.
** When a class inherits another class, default constructor is generally
automatically invoked, and you need not do any extra work for that.
** The parameters passed to a class for construction become private val fields
for the class.
** In java uninitialized fields of a class are initialized to default values
such as null,0 or false depending on their type if no value is provided for
them in class definition.
We can achieve the same effect in scala, by using:
var x: Int = _
** When a Singleton shares same name with the class template its called
companion object for the class. You must define class and its companion
object in the same file.
** one can use keyword 'require' in class definition for asserting arguments
passed while instantiating the object. For example:
class Rational(n: Int,d: Int) {
require(d != 0)
override def toString = n + "/" + d
}
** In scala, in body on any auxiliary constructor, first method call should be
of, another constructor of the same class. Called constructor can be primary
contructor or another auxiliary constructor which comes textually before
current contructor. This rule is enforced because in Scala only primary
contructor can invoke superclass constructors.
* Case class and Pattern Matching
** Since, case classes come predefined with their Factories for object
creation, you don't need to call new on them, but you must use () for
creating objects, even if case class constructor doesn't accept any
parameters.
* Functional Programming Primitives
* Language Specific Miscellenany
** Use split with care.
** Scala operator thingy:
nfix (least to highest precedence)
|
^
&
< >
= !
:
+ -
* / %
~
Postfix (unary_)
+
-
!
~
Operators ending with colon (:) are right-associative.
* Concurrent Programming Concepts
* Scala Collection Classes
** HashMaps and TreeMaps are based on RedBlackTrees and you often don't need
them for a simple hash type of functionality.
** Another simple and easy to use data structure is Map.
scala> val map = scala.collection.mutable.Map[String,Int]()
map: scala.collection.mutable.Map[String,Int] = Map()
scala> map("Hello") = 1
scala> map("World") = 2
scala> map.contains("Hello")
res39: Boolean = true
** If you are looking for 'join' method in scala, use mkString in place of join.
* Scala Type System
** In scala value assigned to a variable created with val can't be changed, but
often in the interpreter its possible. The behaviour of interpretor is
confusing.
** In scala, a val can be reassigned to some other value by defining the value
in a new scope. For example, following code won't compile:
val a = 1
val a = 2
println(a)
But following code will compile:
val a = 1
{
val a = 2
println(a)
}
println(a)
In this case an inner variable is said to "shadow" an outer variable.
* Language Tools
** To compile a scala file
scalac HelloWorld.scala
** Compile scala file to different location:
By default scalac generates the class files to the same location as the
corresponding source files.
You may specify a different output directory using the -d option.
scalac -d classes HelloWorld.scala
** To run a compiled scala file
scala HelloWorld
* UnAnswered Questions:
** What are those link and unlink methods in Actor class.
link and unlink are generally used to link Actors so as one actor can
monitor and vice-versa.
** How to globally identify an Actor without defining it as a singleton.
