Scala Study Notes

• function is value,

  val f = (x:Int) => x*x
  

  One difference between def f = ... and val f = ... is: def is evaluated on call and returns a new function instance every time.

  val test: () => Int = {
      println("val")
      val r = util.Random.nextInt
      () => r
  }
  // returns the same result every time you call test(),
  // "val" will be printed after definition
  
  def test: () => Int = {
      println("def")
      val r = util.Random.nextInt
      () => r
  }
  // returns the difference results every time you call test(),
  // "def" will be printed every time you call it.
  
  val tt = test
  // acts like the first example
  
  val test = () => util.Random.nextInt
  def test = () => util.Random.nextInt
  // they are the same from behavior, you have to call the function by test()
  // the def declaration actually defined a function that returns a function.
  // if you type test without parenthesis, you will receive a function value.
  
  def test = util.Random.nextInt
  // this line directly assign the test function to the nextInt function,
  // you can call the function directly by name without the parenthesis
  

  method/expression starts by def will be evaluated when you call obj.f while those starts by val will be evaluated once. In addition, if you declare a val that assigns to def, the def will be evaluated immediately, and the new val acts like the first case in the examples above.

• Abbreviation:

  val l = List(1,2,3)
  l.map((x) => x*x)
  l.map( x => x*x) // ignore the parenthese
  l.map( _ % 2 == 0) // ignore the parameter, using the placeholder for expression
  l.map(f(_)) // using the placeholder for function
  l.map(f) // ignore the placeholder for function
  

abstract class is like Java, trait is like interface in Java. However, trait can have parameters and defined methods. In addition, trait is not abstract class since it cannot has constructors.

• Logical problem: is List<Parent> the parent of List<Childe>?

  It is not true for mutable collection.

  var s = new Array[Man](new Man())
  var t:Array[Human] = s
  t[0] = new Woman()
  var m:Man = s[0]// what is it? man or woman?
  

  But we can use imutable collection.

• Covariant, Contvariant, Invariant
  • Covariant: defined by Class<+T>, Class<Parent> is the parent of Class<Child>
  • Contvariant: defined by Class<-T>, Function<Parent> is the child of Function<Child>

  The principle is: child type can do anything that can be done by parent type.

• Check Rules and Boundary

  To avoid conflict, the compile force the +T can only be used for returned type, the -T can only be used for argument type. A method to by pass this problem is using boundary.

  class List<+T>{
       def prepend[U >: T](U elem)
  }
  

  Notice that in generic type definition, one can use A>:B and A<:B to add constraint to the meta type.

Case class enables you to make classes with different parameters

abstract class CodeTree
case class Fork(left: CodeTree, right: CodeTree, chars: List[Char], weight: Int) extends CodeTree
case class Leaf(char: Char, weight: Int) extends CodeTree

For the classes listed above, you cannot directly access to any paramter (field) of Fork or Leaf. You have to use case Fork(a,b,_,_) to access to the paramters.

case match can also be used in lambda function as a short version.

List.map(p => p._1 * p._2)

List.map({case (x,y) => x * y})
//List.map{case (x,y) => x * y} also works

Option calsss used for the condition that the returned type can be empty/null, etc.

If you want to match a variable in context, you have to weither use a capitalized variable name Variable or wrap it by backticks `variable`.

• List is a chain while Vector is a tree that each node is an array that contains 32 elements. Vector groups in depth slowly log_{32}(N). Important functions: map, filter, reduceRight, reduceLeft, foldRight, foldLeft, flatten, flatMap, take, drop, takeWhile, =dropWhile, span, group, groupBy.

  Sequence as parameter list is represented by this(par: T*).

• Map.
  • The + and ++ operations overwrite the existing

  key.

  • Initialized by Map(k1->v1, k2->v2, k3->v3)
  • Set default value by withDefaultValue, this function returns a new map (everything in this course are immutable).

Honestly, I don't understand it. But I collect my thoughts about it here. First, the monda is used to chain operations and if the first (preceding) operation fails, the whole chain stops. An example that I understand is the usage of for-expression with pattern match. If the pattern matches, go next operation, else skip this element.

Another point of view is about the unit operation. A monad flatMap with its unit operation will return the monad itself.

My conclusion:

A monad is a container that supports operation chain and follows the monad laws. The basic operations of this container are flatMap and unit, where flatMap actually accepts a function that maps each element to a container, then binds these containers together; unit returns a container given an element. Monad laws guarantee the reliability of operation chain on these contains.

Monad seems like a design pattern that enables the operation chain along with pattern match in functional programming. Because flatMap chain with different functions is equivalent to nested flatMap, the for-expression is a syntax sugar based on flatMap chain. The advantage of this design pattern is avoding side effect.

Generator is created by yield as well as for-expression. Pay attention, there is no generator class/type/trait. The genrator created through for-expression has the same type of the sequence/iterator/stream used in for-expression. That proves the for-expression is a syntax sugar of monad types. So, guess what will happen when we create a for-expression using both list and stream?

val fibo:Stream[Int] = 1 #:: 1 #:: fibo.zip(fibo.tail).map(x=>x._1+x._2)
val l = List(1,2,3,4,5)
val lsg = for{x <- l; fib <- fibo} yield (x,fib)// infinite loop, crash the software/your machine
val slg = for{fib <- fibo; x <- l} yield (x,fib)// return a stream

Following the definition of Monad, the first mixture lsg actually makes l flatMap (x => fibo), which returns a List that tries to expand infinite stream fibo, hence block your machine. The second mixture slg returns a Stream that expand the list l, hence, works well. Besides, I have to clarify one thing: different monads demonstrated above all accept GenTraversableOnce as parameter and return monad of their own type. That is why they can be mixed together and the first expression decides the type of the final output of for-expression.

It is a tool for property-based testing for scala. It has NO external dependencies and integrated in the test frameworks ScalaTest. It can also be used standalone, with its built-in test runner.