ST01.sh

#!/bin/bash
SBT_OPTS="-Xms512M -Xmx1536M -Xss1M -XX:+CMSClassUnloadingEnabled"
java $SBT_OPTS -jar `dirname $0`/sbt-launch.jar "$@"

ST02.sh

chmod a+x /usr/local/bin/sbt    

ST03.build

set name:= "HelloScala."
show name

ST04.build

set name:= "HelloScala."
show name

ST05.build

name := "HelloScala."
version := "1.0"
scalaVersion := "2.11"
libraryDependencies += "org.apache.spark" % "spark-core_2.11" % "2.0.2"

ST06.scala

val h = "Hello Scala!"
println(h)

ST07.scala

class Test {
  val s = "Hello Scala!"
}

ST08.scala

val t = new Test
println(t.s)

ST09.scala

import org.apache.spark.SparkContext     

ST10.build

set libraryDependencies += "org.apache.spark" % "spark-core_2.10" % "2.0.2"   

ST100.scala

def fun(x:Int) = x + 4  

ST101.scala

def fac(n: Int) = if (n == 0) 1 else n * fac(n - 1)

ST102.scala

val i = 10

ST103.scala

i.+(15)

ST104.scala

i.*(5)
i.>(5)
i.abs
i.compare(15)

ST105.scala

i + 15
i * 5
i > 5

ST106.scala

i compare 5
i compare 15

ST107.scala

i to 20

ST108.scala

i.to(20)

ST109.scala

i to 20

ST11.scala

tar -zxvf scala-SDK-4.5.0-vfinal-2.11-linux.gtk.x86_64.tar.gz -C /usr/local/

ST110.scala

<object><method><parameter>

ST111.scala

<object><method> (<parameter-1> [, <parameter-2>, ...] )

ST112.scala

i to (20,2)    

ST113.scala

i abs

ST114.scala

val s = "my name is ..."
s toUpperCase

ST115.scala

s.toUpperCase        

ST116.scala

-i 

ST117.scala

-i * 2

ST118.scala

i.unary_-

ST119.scala

def functionName ([<parameterName> :<type> [, ....]]) : [return type] = {
    <function body>
    return [expr]
}

ST12.sh

mkdir -p ~/.sbt/0.13/plugins/

ST120.scala

def myMax(x: Int, y: Int): Int = {
  if (x > y)
    return x;
  else
    return y;
}

ST121.scala

['^(([^<>()[\]\\.,;:\\s@\"]+(\\.[^<>(),[\]\\.,;:\\s@\"]+)*)',
                                    '|(\\".+\\"))@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.',
                                    '[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\\.)+',
                                    '[a-zA-Z]{2,}))$'].join('') 

ST122.scala

def myMax(x: Int, y: Int): Int = {
  if (x > y)
    x
  else
    y
}
//I can squeeze it further like this.
def myMax(x: Int, y: Int): Int = {
  if (x > y) x else y
}

ST123.scala

def myMax(x: Int, y: Int): Int = if (x > y) x else y

ST124.scala

def myMax(x: Int, y: Int) = if (x > y) x else y

ST125.scala

def myMax(x:Int, y:Int) = { if (x > y)  x  else  y }    

ST126.scala

def hWorld() = println("Hello World!")

ST127.scala

hWorld() 

ST128.scala

hWorld 

ST129.scala

//String value
val s = "Hello World!"
// Integer value
val l = 5

ST13.scala

vi ~/.sbt/0.13/plugins/plugins.sbt

ST130.scala

val l: Long = 5
//Another alternative for enforcing the data type is this.
val l = 5: Long

ST131.scala

([<parameterName> :<type> [, ....]])  =>  {   
    <function body> 
    return [expr] 
} : [return type]
                                                      
//Compare it with standard def syntax for a Scala function
 def functionName ([<parameterName> :<type> [, ....]]) : [return type] = {
     <function body> 
     return [expr]
 }

ST132.scala

val f = (x:Int) => { x + 5 }

ST133.scala

val f = (x:Int) => { x + 5 }:Int

ST134.scala

val f:Int => Int = (x:Int) => { x + 5 }   

ST135.scala

myFun(5,"-") 
//should return -5-

ST136.scala

val myFun:(Int, String) => String = (x:Int, s:String) => { s + x + s }:String   

ST137.scala

val myFun = (x:Int, s:String) => { s + x + s }

ST138.scala

val customers = List( "donald", "angela","larry","narendra", "vladimir")

ST139.scala

(x:String) => x.capitalize 

ST14.scala

addSbtPlugin("com.typesafe.sbteclipse" % "sbteclipse-plugin" % "5.1.0") 

ST140.scala

customers.map((x:String) => x.capitalize) 

ST141.scala

val data = List(-250, 75, 145 ,222 ,-80 ,-140 , 170 , 85 , 122, 250)   

ST142.scala

data.map( (x:Int) => 1d*(x-data.min)/(data.max-data.min)*1d)

ST143.scala

val r = 1 to 10
r.map(x => x + 10)

ST144.scala

r.reduce((x,y) => x + y )   

ST145.scala

r.reduce((x, y) => x * y)
r.reduce((x, y) => x max y)
r.reduce((x, y) => x + y / x min y)

ST146.scala

r.map(x => x + 10)
r.reduce((x, y) => x * y)

ST147.scala

r.map(x + 10)
r.reduce(x * y)

ST148.scala

r.map(_ + 10)
r.reduce(_ * _)

ST149.scala

r.reduce( _ * _ )  

ST15.scala

mkdir -p TestEclipse/src/main/scala
cd TestEclipse
vi src/main/scala/TestEclipse.scala
//Copy and Paste the below code in your TestEclipse.scala file
object TestEclipse {
  def main(args: Array[String]): Unit = {
    println("Hello, World! from SBT")
  }
}

ST150.scala

r.filter(x => x > 5)

ST151.scala

r.filter(_ > 5) 

ST152.scala

r.reduce((x,y) => x + y / x min y)       

ST153.scala

val f = (x:Int) => x + 10

ST154.scala

val f1 = new Function1[Int, Int] {
  def apply(x: Int): Int = x + 10
}

ST155.scala

import scala.io.Source
import scala.io.Source._
def getErrors(fileName: String) = {

  def isError(line: String) = {
    if (line.contains("error")) true else false
  }

  val f = Source.fromFile(fileName)
  for (l <- f.getLines() if isError(l)) yield l
}
getErrors("/root/mylog.dat") foreach println

ST156.scala

val f2 = f1(5)
/*Output
    SQRT of 5 is 2.23606797749979
    f2: Int => Double = <function1>
 */

ST157.scala

f2(20)
//res0: Double = 5.0

ST158.scala

def f1(x: Int) = {
  println(s"SQRT of $x is " + Math.sqrt(x))
  (y: Int) => Math.sqrt(x + y)
}
val f1 = (x: Int) => {
  println(s"SQRT of $x is " + Math.sqrt(x))
  (y: Int) => Math.sqrt(x + y)
}

ST159.scala

def f1(x: Int) = {
  println(s"SQRT of $x is " + Math.sqrt(x))
  def f2(y: Int) = Math.sqrt(x + y)
}
/* Output - It return a Unit
        f1: (x: Int)Unit
 */
//You can still return an ordinary local function, but you have to do some extra work.
def f1(x: Int) = {
  println(s"SQRT of $x is " + Math.sqrt(x))
  def f2(y: Int) = Math.sqrt(x + y)
  f2 _
}

ST16.build

vi build.sbt
//Copy and paste below content into your build.sbt file
name := "TestEclipse"
version := "1.0"
scalaVersion := "2.11.8"
publishMavenStyle := false
libraryDependencies += "org.apache.spark" % "spark-core_2.11" % "2.0.2" notTransitive ()
EclipseKeys.withJavadoc := false
EclipseKeys.withSource := false

ST160.scala

val f2 = f1(3)

ST161.scala

f1(3)(5)

ST162.scala

def f1(x: Int) = {
  println(s"SQRT of $x is " + Math.sqrt(x))
  (y: Int) => Math.sqrt(x + y)
}

ST163.scala

def f1(x: Int) = { (y: Int) =>
  Math.sqrt(x + y)
}

ST164.scala

def f1(x:Int) = (y:Int) => Math.sqrt(x+y)    

ST165.scala

val f1 = (x:Int) => (y:Int) => Math.sqrt(x+y)

ST166.scala

val f1: Int => (Int => Double) = (x:Int) => (y:Int) => Math.sqrt(x+y)   

ST167.scala

val fs:String => (String => String) = (prefix: String) => (s: String) => prefix + " " + s     

ST168.scala

val fs = (prefix: String) => (s: String) => prefix + " " + s 

ST169.scala

val fs = (prefix: String) => { (s: String) => prefix + " " + s }

ST17.scala

sbt eclipse 

ST170.scala

fs("Hi")("There")

ST171.scala

val fs = (prefix: String) =>{ () => prefix + " " + "There" }       

ST172.scala

fs("Hi")()

ST173.scala

def intDecorator(x:Int, f: Int => String) = f(x)     

ST174.scala

intDecorator(5, (y:Int) => "[" + y + "]" )

ST175.scala

intDecorator(5, (y:Int) => "<b>" + y + "</b>" ) 

ST176.scala

intDecorator(5, "[" + _.toString + "]" )  

ST177.scala

def echo(s:String*) = s foreach println      

ST178.scala

echo("One","Two","Three")    

ST179.scala

echo("One","Two","Three", "Four", "Five") 

ST18.scala

Math.sqrt(4.0)

ST180.scala

def echo(s:String*, i:Int) = s foreach println      

ST181.scala

def doSomething(f: String  => Unit, s:String) = f(s)     

ST182.scala

doSomething(x =>println("[" + x + "]") , "Hi There!")   

ST183.scala

doSomething("Hi There!", x =>println("[" + x + "]") ) 

ST184.scala

doSomething(s="Hi There!", f = x =>println("[" + x + "]"))

ST185.scala

def doSomething(f: String  => Unit=println, s:String) = f(s)     

ST186.scala

doSomething(s="Hi There!")     

ST187.scala

def div(x:Double, y:Double):Double = x/y
def add(x:Double, y:Double):Double = x+y 

ST188.scala

def inv(y:Double):Double = 1.0/y    

ST189.scala

def inc(y:Double):Double = 1 + y 

ST19.scala

var g = 10
//Consider that g is a global variable.
def rt(i: Int): Int = {
  g = i + g;
  return g
}
//The rt is a function. That's Scala syntax to define a function.
//I am using this function like this.
val v1 = rt(5)
val v2 = rt(5)

ST190.scala

def div(x:Double, y:Double):Double = x/y 

ST191.scala

div(1, _:Double)

ST192.scala

val inv = div(1, _:Double)

ST193.scala

inv(10)   

ST194.scala

def sumOfX(f: Int => Int, a: Int, b: Int): Int =
  if (a > b) 0 else f(a) + sumOfX(f, a + 1, b)

ST195.scala

sumOfX(x => x, 1, 5)

ST196.scala

sumOfX(x => x * x, 1, 5)

ST197.scala

sumOfX(x => x * x * x, 1, 5)

ST198.scala

val sumOfCubes = sumOfX(x => x * x * x, _: Int, _: Int)
sumOfCubes(1, 5)

ST199.scala

def applySums(f: (Int, Int) => Int) =
  println("I am applying sum of 1 to 5 and the answer is " + f(1, 5))

ST20.scala

val x = doThis(a)
  .thenThis(b)
  .andThenThis(c)
  .doThisToo(d)
  .andFinallyThis(e)

ST200.scala

def sum(x: Int, y: Int, z: Int) = x + y + z
val s3 = sum(_: Int, _: Int, _: Int)

ST201.scala

val s4 = sum _

ST202.scala

def sumOfX(f: Int => Int, a: Int, b: Int): Int =
  if (a > b) 0 else f(a) + sumOfX(f, a + 1, b)

ST203.scala

def sumOfX(f: Int => Int)(a: Int, b: Int): Int =
  if (a > b) 0 else f(a) + sumOfX(f, a + 1, b)

ST204.scala

sumOfX(x => x * x * x)(1, 5)

ST205.scala

val si = sumOfX(x => x * x * x) _

ST206.scala

val si = sumOfX { x =>
  println("Cubing")
  x * x * x
} _

ST207.scala

def test(i: Int): String = {
  var s: String = null
  if (i == 1)
    s = "One"
  else
    s = "Something else"
  return s
}

ST208.scala

def testF(i: Int) =
  if (i == 1) "One" else "Something else"

ST209.scala

def testF(i: Int) =
  if (i == 1) "One"
  else if (i == 2) "two"
  else if (i == 3) "three"
  else "Something else"

ST21.scala

def doubler(i:Int):Int = {return i * 2}

ST210.scala

val i = 5
val s = if (i == 1) "One" else "Something else"
println(if (i == 1) "One" else "Something else")

ST211.scala

val i = 5
val s = if (i == 1) "One" else "Something else"

ST212.scala

val s = if (i == 1) println("One") else println("Something else")

ST213.scala

val s = if (i == 1) 1 else println("Something else")

ST214.scala

def matchX(x: Int) = {
  x match {
    case 1 => println("Case One")
    case 2 => println("Case Two")
    case 3 => println("Case Three")
    case _ => println("Case Default Case")
  }
}

ST215.scala

def matchX(x: Int) = {
  x match {
    case 1 => {
      println("Case One")
      println("Print it again - Case One")
    }
    case 2 =>
      println("Case Two")
      println("Print it again - Case Two")
    case 3 => println("Case Three")
    case _ => println("Case Default Case")
  }
}

ST216.scala

def matchX(x: Int) = {
  x match {
    case 1 => "Case One"
    case 2 => "Case Two"
    case 3 => "Case Thre"
    case _ => "Case Default Case"
  }
}

ST217.scala

val x = 2
val s = x match {
  case 1 => "Case One"
  case 2 => "Case Two"
  case 3 => "Case Three"
  case _ => "Case Default Case"
}
println(s)

ST218.scala

def loopN(i: Int) = {
  var j = 1
  while (j <= i) {
    println(j)
    j = j + 1
  }
}

ST219.scala

def loopDo(i: Int) = {
  var j = 1
  do {
    println(j)
    j = j + 1
  } while (j <= i)
}

ST22.scala

//Let's assign it to a variable.
val d = doubler(_)
// Now you can use the variable d as it is a function.
d(5)
d(3)

ST220.scala

var i = 0
repeat {
  println("Values of i is " + i)
  i = i + 1
} until (i > 3)

ST221.scala

def repeat(body: => Unit)(condition: => Boolean) = {
  do {
    //body
  } while (!condition)
}

ST222.scala

def testUntil = {
  var i = 0
  repeat {
    println("Values of i is " + i)
    i = i + 1
  }(i > 3)
}

ST223.scala

def repeat(body: => Unit) = {
  def until(condition: => Boolean) = {
    do {
      //body
    } while (!condition)
  }
  until _
}

ST224.scala

import scala.language.reflectiveCalls
def repeat(body: => Unit) = new {
  def until(condition: => Boolean) = {
    do {
      //body
    } while (!condition)
  }
  until _
}

ST225.scala

withTextFile(fileLocation) map (doThisWork)

ST226.scala

repeat(doThisWork) until (condition)

ST227.scala

val l = List("india", "USA", "UK", "china", "russia")
def f1(s: String) = {
  println("Printing " + s)
  "Returning " + s
}

ST228.scala

l.foreach(println)
/*Output
    india
    USA
    UK
    china
    Russia
 */

ST229.scala

l.map(f1)
/*Output
    Printing india
    Printing USA
    Printing UK
    Printing china
    Printing russia
    res7: List[String] = List(Returning india, Returning USA, Returning UK, Returning china, Returning russia)
 */

ST23.scala

val r = 1 to 10
r.map(doubler)      

ST230.scala

def f3(s: String) = s.split(" ")

ST231.scala

val l = List(
  "India is a multiparty democratic country, USA is two-party democratic country"
)

ST232.scala

l.map(f3)
/*output
    res8: List[Array[String]] = List(Array(India, is, a, mulyiparty, democratic, country,, USA, is, two-party, democratic, country))
 */

ST233.scala

l.flatMap(f3)
/*output
    res9: List[String] = List(India, is, a, mulyiparty, democratic, country,, USA, is, two-party, democratic, country)
 */

ST234.scala

val l = List("india", "USA", "UK", "china", "russia")
l.withFilter(x => x.startsWith("i")).map(x => x.capitalize)
res10: List[String] = List(India)

ST235.scala

l.filter(x => x.startsWith("i")).map(x => x.capitalize)

ST236.scala

for ( seq ) yield { expr } 

ST237.scala

for ( seq ) { expr }

ST238.scala

for (i <- 1 to 10) {
  statement - 1;
  statement - 2;
}

ST239.scala

e <- col

ST24.scala

r.map(d)

ST240.scala

val n = 1 to 5
// n is a Range collection with ten elements.
//Now I can iterate through this collection using a for Loop.
for (i <- n) println(i)
// You can remove the middleman and get a collection on the fly.
for (i <- 1 to 5) println(i)

ST241.scala

for (country <- List("India", "USA", "China", "Japan")) {
  country match {
    case "India" => println("Delhi")
    case "USA"   => println("Washington D.C.")
    case "Japan" => println("Tokyo")
    case _       => println("I don't know")
  }
}

ST242.scala

val countries = List("India","USA","China","Japan")

ST243.scala

countries.foreach { country =>
  country match {
    case "India" => println("Delhi")
    case "USA"   => println("Washington D.C.")
    case "Japan" => println("Tokyo")
    case _       => println("I don't know")
  }
}

ST244.scala

for ( seq ) yield { expr }

ST245.scala

val countries = List("India", "USA", "China", "Japan")
for (country <- countries) yield {
  country match {
    case "India" => "Delhi"
    case "USA"   => "Washington D.C."
    case "Japan" => "Tokyo"
    case _       => "I don't know"
  }
}

ST246.scala

val capitals = for (country <- countries) yield {
  country match {
    case "India" => "Delhi"
    case "USA"   => "Washington D.C."
    case "Japan" => "Tokyo"
    case _       => "I don't know"
  }
}

ST247.scala

for ( seq ) yield { expr }

ST248.scala

e <- col

ST249.scala

for (i <- 1 to 3; j <- 1 to 2) println(s"i=$i  j=$j")
/* Output
    i=1  j=1
    i=1  j=2
    i=2  j=1
    i=2  j=2
    i=3  j=1
    i=3  j=2
 */

ST25.scala

(i:Int) => { i*2 } :Int

ST250.scala

for (i <- 1 to 3; j <- 1 to 2; k <- 1 to 2) println(s"i=$i  j=$j k=$k")

ST251.scala

for {
  i <- 1 to 3;
  j <- 1 to 2;
  k <- 1 to 2;
} println(s"i=$i  j=$j k=$k")

ST252.scala

for {
  i <- 1 to 3
  j <- 1 to 2
  k <- 1 to 2
} println(s"i=$i  j=$j k=$k")

ST253.scala

for {
  i <- 1 to 3
  j <- 1 to 2; if (j % 2 == 0)
  k <- 1 to 2
} println(s"i=$i  j=$j k=$k")

ST254.scala

for {
  i <- 1 to 3
  j <- 1 to 2
  if (j % 2 == 0)
  k <- 1 to 2
} println(s"i=$i  j=$j k=$k")

ST255.csv

ST256.scala

import scala.io._
for (line <- Source.fromFile("employees.csv").getLines().toList) println(line)

ST257.scala

for (line <- Source.fromFile("employees.csv").getLines().toList) {
  val fields = line.split(",")
  println(fields(0) + "--" + fields(1) + "--" + fields(2) + "--" + fields(10))
}

ST258.scala

for {
  line <- Source.fromFile("employees.csv").getLines().toList
  fields = line.split(",")
} println(fields(0) + "--" + fields(1) + "--" + fields(2) + "--" + fields(10))

ST259.scala

for {
  line <- Source.fromFile("employees.csv").getLines().toList
  fields = line.split(",")
  if (fields(10) == "60")
} println(fields(0) + "--" + fields(1) + "--" + fields(2) + "--" + fields(10))

ST26.scala

val d = (i: Int) => { i * 2 }
//And then, you can call it using the variable.
d(3)

ST260.sql

select employee_id, first_name, last_name, department_id
from employees
where department_id=60;

ST261.csv

ST262.scala

val emp = for {
  dept <- Source.fromFile("departments.csv").getLines().toList
  deptfields = dept.split(",")
  emp <- Source.fromFile("employees.csv").getLines().toList
  empfields = emp.split(",")
  if (deptfields(0) == empfields(10))
} yield (empfields(0), empfields(1), empfields(2), deptfields(1))
emp foreach println

ST263.scala

for ( seq ) yield { expr }

ST264.scala

class JCustomer {
  //Private properties
  private var custID: Int = 0
  private var custName: String = null

  //Public constructor
  def this(id: Int, name: String) {
    this()
    this.custID = id
    this.custName = name
  }

  //Public getter
  def getID() = custID
  def getName() = custName

  //Public setter
  def setID(nID: Int) = custID = nID
  def setName(nName: String) = custName = nName
}

ST265.scala

val c = new JCustomer(101, "XYZ Corp")
//When you want to read the private field, you will call a getter method.
c.getID()
//When you want to modify the private field, you will call a setter method.
c.setName("XYZ Corporation")
c.getName()

ST266.scala

class Customer(var id: Int, var name: String)

ST267.scala

val c = new Customer(101, "XYZ Corp")
//But when you want to read the members variables, instead of calling a getter method, you will use them directly.
c.id
c.name
//There is no need to call a getID and getName methods.
//You don't even need the set methods as well. You can directly modify the members.
c.id = 101
c.name = "XYZ Corp"

ST268.scala

class JCircle {
  //Private field
  private var radius = 0
  //Constructor
  def this(r: Int) {
    this()
    setRadius(r)
  }
  //Set method with data validation
  def setRadius(r: Int): Unit = {
    if (r < 0) throw new Exception("-ive not allowed") else radius = r
  }
  //Get method
  def getRadius() = radius
}

ST269.scala

class Circle {
  //Private field
  private var _pradius = 0
  //Constructor
  def this(r: Int) {
    this()
    radius = r
  }
  //Set method with data validation
  def radius_=(r: Int) = {
    if (r < 0) throw new Exception("-ive not allowed") else _pradius = r
  }
  //Get method
  def radius = _pradius
}

ST27.scala

def getOps(c: Int) = (i: Int) => {
  val doubler = (x: Int) => { x * 2 }
  valtripler = (x: Int) => { x * 3 }
  if (c > 0) doubler(i)
  else tripler(i)
}

ST270.scala

class Circle { }

ST271.scala

class Circle {
  var radius = 0
  def draw = { println("Drawing the circle of radius " + radius) }
}

ST272.scala

val c = new Circle
/*Output
    radius radius_=
 */

ST273.scala

//But no one calls the writer using this notation. We can simply call it like this.
c.radius = 5

ST274.scala

class Circle {
  private var p_radius = 0
  //TODO: implement reader/writer methods
}

ST275.scala

class Circle {
  private var p_radius = 0
  //Reader
  def radius = p_radius
}

ST276.scala

class Circle {
  private var p_radius = 0
  //Reader
  def radius = p_radius
  //Writer
  def radius_=(r: Int) = {
    if (r < 0) throw new Exception("-ive not allowed") else p_radius = r
  }
  def setRadius(r: Int) = {
    if (r < 0) throw new Exception("-ive not allowed") else p_radius = r
  }
}
val c = new Circle

ST277.scala

c.setRadius = 5 

ST278.scala

c.setRadius(5)   

ST279.scala

class Circle {
  val radius = 0
}

ST28.scala

val r = 1 to 10
r.map(getOps(-5))

ST280.scala

class Circle {
  var radius = 0
}

ST281.scala

val c = new Circle()  

ST282.java

public class Circle {
    //Instance variable
    private int radius;

    //Constructor
    public Circle(int newRadius) {
        this.radius = newRadius;
    }

    //Get and Set methods
    public int getRadius() {
        return this.radius;
    }

    public void setRadius(int r) {
        this.radius = r;
    }
}

ST283.scala

class Circle {
  //Instance variable
  int radius;

  //Constructor
  Circle(intnewRadius) {
    this.radius = newRadius;
  }
}

ST284.scala

class Circle(var newRadius: Int) {
  var radius = newRadius
}

ST285.scala

class Circle(var radius: Int)

ST286.scala

class Circle(val radius: Int)

ST287.scala

class Circle(private val radius: Int)

ST288.scala

class Circle(radius: Int)

ST289.scala

class Box(var width: Int, var height: Int, var depth: Int) {
  //Auxiliary constructors
  def this() = {
    this(1, 1, 1);
  }
  def this(w: Int, h: Int) {
    this(w, h, 1);
  }
  def showBox = println(s"width = $width height= $height depth=$depth")
}

ST29.scala

def getOps2(c: Int) = (i: Int) => {
  if (c > 0) {
    i * 2
  } else {
    i * 3
  }
}

ST290.scala

val b = new Box()
b.showBox
val b = new Box(5, 3)
b.showBox
val b = new Box(5, 3, 2)
b.showBox

ST291.scala

val smallCircle = new Circle(5)
val mediumCircle = new Circle(25)
val largeCircle = new Circle(100)

ST292.scala

Console.println(s"${Console.RED}Ha Ha ${Console.RESET} He He..")

ST293.scala

import java.util.Calendar
import java.text.SimpleDateFormat
object StaticDateTime {
  private val dateFormat = "EEEE, d-MMM-yyyy"
  private val timeFormat = "K:m aa z(ZZ)"
  def currentDate: String = getCurrentDateTime(dateFormat)
  def currentTime: String = getCurrentDateTime(timeFormat)
  def dateAdd(date: String, days: Int): String = {
    val df = new SimpleDateFormat(dateFormat)
    val dt = df.parse(date)
    val cal = Calendar.getInstance()
    cal.setTime(dt)
    cal.add(Calendar.DATE, days)
    df.format(cal.getTime())
  }
  private def getCurrentDateTime(format: String): String = {
    val df = new SimpleDateFormat(format)
    val cal = Calendar.getInstance()
    df.format(cal.getTime())
  }
}

ST294.scala

//How to Use Scala Object Methods
StaticDateTime.currentDate
StaticDateTime.currentTime
StaticDateTime.dateAdd(StaticDateTime.currentDate, 5)

ST295.scala

object TestSingleton {
  println("First Use..")
  def sayHello = println("Hi there!")
}
TestSingleton.sayHello
//Now try it once again.
TestSingleton.sayHello
TestSingleton.sayHello

ST296.properties

//Create a configuration file in current directory
//File Name - config.properties
//Paste below content
dbpassword = dont - tell - password
database = localhost
dbuser = prashant

//Code Example
import java.util._
import java.io._
object appConfig {
  private val prop = new Properties();
  prop.load(new FileInputStream("config.properties"));
  def config = prop
}
//How to use it
appConfig.config.getProperty("dbuser")
appConfig.config.getProperty("database")

ST297.scala

object appConfig {
  private val prop = new Properties();
  prop.load(new FileInputStream("config.properties"));
  def apply(s: String) = prop.getProperty(s)
}
//How to use it
appConfig("dbuser")
appConfig("database")

ST298.scala

appConfig.apply("dbuser")    

ST299.scala

appConfig("dbuser")

ST30.scala

var customers = Array("Mike", "Zara","Abdul","Peter")        

ST300.scala

val myList = List("India", "America", "Japan", "China")
myList(0)
myList(2)

ST301.scala

myList.apply(2)

ST302.scala

class Graph(path: String) {
  println("Load the Graph from file")
  def numEdges = 506
  def numVertices = 305
  def persist(storageLevel: Int) = println("Returns a new persisted Graph")
}

val g = new Graph("file_location")
g.persist(Graph.MEMORY_ONLY)

ST303.scala

object StorageLevel {
  val DISK_ONLY = 0
  val MEMORY_ONLY = 1
  val MEMORY_ONLY_COMPRESSED = 2
  val MEMORY_AND_DISK = 3
  val MEMORY_AND_DISK_COMPRESSED = 4
}

ST304.scala

val g = new Graph("file_location")
g.persist(0)
g.persist(StorageLevel.MEMORY_ONLY)

ST305.scala

val g = new Graph("file_location")
g.persist(Graph.MEMORY_ONLY)

ST306.scala

object Graph {
  val DISK_ONLY = 0
  val MEMORY_ONLY = 1
  val MEMORY_ONLY_COMPRESSED = 2
  val MEMORY_AND_DISK = 3
  val MEMORY_AND_DISK_COMPRESSED = 4
  def apply(path: String) = new Graph(path)
}

ST307.scala

val g = Graph("file_location")

ST308.scala

val g = Graph("file_location")    

ST309.scala

class Graph private (path: String) {
  println("Load the Graph from file")
  def numEdges = 506
  def numVertices = 305
  def persist(storageLevel: Int) = println("Returns a new Graph")
}
object Graph {
  val DISK_ONLY = 0
  val MEMORY_ONLY = 1
  val MEMORY_ONLY_COMPRESSED = 2
  val MEMORY_AND_DISK = 3
  val MEMORY_AND_DISK_COMPRESSED = 4
  def apply(path: String) = new Graph(path)
}

ST31.scala

for (i <- 0 to customers.length - 1) {
  println("Hi " + customers(i));
}

ST310.scala

val myList = List("India", "America", "Japan", "China")    

ST311.scala

myList(0)    

ST312.scala

val s = Room(STANDARD)
val d = Room(DELUXE)
val sd = Room(SUPER_DELUXE)

ST313.scala

//File Name - hotels.scala

package guru.learningjournal.hotels

abstract class Room {
  def bookingPrice: Double
  def facilities: List[String]
  def availability: Int
  def book(noOfRooms: Int)
}

object Room {
  val STANDARD = 0
  val DELUXE = 1
  val SUPER_DELUXE = 2

  private class standardRoom extends Room {
    private var _availability = 20
    override def bookingPrice = 70
    override def facilities = List("Queen Bed", "TV", "Chair", "Table", "Fan")
    override def availability = _availability
    override def book(noOfRooms: Int) = {
      _availability = _availability - noOfRooms
    }
  }

  private class DeluxeRoom extends Room {
    private var _availability = 10
    override def bookingPrice = 90
    override def facilities = List("Bed", "TV", "Chair", "Table", "AC")
    override def availability = _availability
    override def book(noOfRooms: Int) = {
      _availability = _availability - noOfRooms
    }
  }

  private class superDeluxeRoom extends Room {
    private var _availability = 5
    override def bookingPrice = 120
    override def facilities =
      List("Double Bed", "Single Bed", "TV", "Sofa", "Reading Table", "AC")
    override def availability = _availability
    override def book(noOfRooms: Int) = {
      _availability = _availability - noOfRooms
    }
  }

  def apply(roomType: Int): Room = {
    roomType match {
      case SUPER_DELUXE => new superDeluxeRoom()
      case DELUXE       => new DeluxeRoom()
      case _            => new standardRoom()
    }
  }
}

ST314.sh

mkdir DemoHotel
cd DemoHotel

ST315.sh

vi hotels.scala

ST316.sbt

vi build.sbt
//paste below code in the build.sbt file
name:= "Demo Hotels"
version := "1.0"
scalaVersion := "2.12.4" 

ST317.scala

import guru.learningjournal.hotels.Room
import guru.learningjournal.hotels.Room._ 

ST318.scala

val s = Room(STANDARD)

ST319.scala

s.bookingPrice
s.availability

ST32.scala

def remindPayment(x: String) = println("Payment reminder for " + x)
//Here is my dummy function for payment reminder. The new loop looks like this.
var i = 0;
for (i <- 0 to customers.length - 1) {
  remindPayment(customers(i));
}

ST33.scala

forEach(customers, remindPayment)

ST34.scala

forEach(vendors, sendPayment) 

ST35.scala

def forEach(a: Array[String], f: String => Unit) = {
  var i = 0;
  for (i <- 0 to a.length - 1) {
    f(a(i));
  }
}

ST36.scala

customers foreach remindPayment

ST37.scala

var s = "Hello World!"
//After initializing it once, you can change it later.
s = "Hello Scala!"

ST38.scala

val v = "You can't change me."
//Let me try to reassign it.
v = "Let me try."

ST39.scala

3 + 1 = 4

ST40.scala

sum(3, 1) returns 4 

ST41.scala

def iFactorial(n: Int): Int = {
  var i = n
  var f = 1
  while (i > 0) {
    f = f * i
    i = i - 1
  }
  return f
}

ST42.scala

def rFactorial(n: Int): Int = {
  if (n <= 0)
    return 1
  else
    return n * rFactorial(n - 1)
}

ST43.scala

def eFactorial(n: Int): Int = {
  if (n <= 0)
    throw new Exception("boom!")
  else
    return n * eFactorial(n - 1)
}

ST44.scala

def tFactorial(n: Int, f: Int): Int = {
  println("Calling tFactorial.")
  if (n <= 0)
    return f
  else
    return tFactorial(n - 1, n * f)
}

ST45.scala

tFactorial(5,1)

ST46.scala

def tFactorial(n: Int, f: Int): Int = {
  if (n <= 0)
    throw new Exception("boom!")
  else
    return tFactorial(n - 1, n * f)
}

ST47.scala

def Factorial(i: Int): Int = {
  println("You called Factorial for " + i)
  def tFactorial(n: Int, f: Int): Int = {
    if (n <= 0)
      f
    else
      tFactorial(n - 1, n * f)
  }
  return tFactorial(i, 1)
}

ST48.scala

println("Hello Scala")

ST49.scala

var r = "" 

ST50.scala

def myResult(m: Int) = {
  var r = ""
  if (m >= 50)
    r = "passed";
  else
    r = "failed";
  println(r)
}

myResult(65)

ST51.scala

val x = println("Hello")         

ST52.scala

def myResult(m:Int) = if(m >= 50) "passed" else "failed"

ST53.scala

println(myResult(65)) 

ST54.scala

def Factorial(i: Int): Int = {
  println("You called Factorial for " + i)
  def tFactorial(n: Int, f: Int): Int = {
    if (n <= 0)
      f
    else
      tFactorial(n - 1, n * f)
  }
  returntFactorial(i, 1)
}

val s = Factorial(15) / Factorial(11)
/*Output
    You called Factorial for 15
    You called Factorial for 11
    s: Int = 50  */

ST55.scala

println(s)
println(s)

ST56.scala

def twice(i: Int) = {
  println("We haven't used i yet")
  i + i
}

ST57.scala

twice(Factorial(15)/Factorial(11) )

ST58.scala

def twice(f: => Int) = {
  println("We haven't used f yet")
  f + f
}

ST59.scala

twice({ Factorial(15) / Factorial(11) })
/*Output
    We haven't used f yet
    You called Factorial for 15
    You called Factorial for 11
    You called Factorial for 15
    You called Factorial for 11
    res2: Int = 100
 */

ST60.scala

def twice(f: => Int) = {
  val i = f
  println("We haven't used i yet")
  i + i
}

ST61.scala

lazy val l = Factorial(15)/Factorial(11)

ST62.scala

println(l)      

ST63.scala

def twice(f: => Int) = {
  val i = f
  println("We didn't use i yet")
  i + i
}

ST64.scala

twice(Factorial(15)/Factorial(11))

ST65.scala

def twice(f: => Int) = {
  lazy val i = f
  println("We didn't use i yet")
  i + i
}

ST66.scala

twice(Factorial(15) / Factorial(11))
/* Output
    We didn't use i yet
    You called Factorial for 15
    You called Factorial for 11
    res3: Int = 100 */

ST67.scala

import scala.io._
val s = Source
  .fromFile("error_log")
  .getLines()
  .toList
  .filter(_.contains("[error]"))
  .take(2)

ST68.scala

s foreach println      

ST69.scala

val s = Source.fromFile("error_log").getLines().toList

ST70.scala

val s = Source.fromFile("error_log").getLines().toStream.filter(_.contains("[error]")).take(2)  

ST71.scala

s foreach  println 

ST72.scala

def fibFrom(a: Int, b: Int): Stream[Int] = a #:: fibFrom(b, a + b)

ST73.scala

val f = fibFrom(1,2)     

ST74.scala

f.takeWhile(_<10) foreach println

ST75.scala

def myTest(x: Any) = {
  x match {
    case i: Integer => "It's an Integer = " + i
    case s: String  => "It's an String = " + s
    case d: Double  => "It's a double = " + d
    case _          => "Opps! Somthing Else"
  }
}
//Let me test my code.
println(myTest("abc"))
println(myTest(2.5))
println(myTest(2))
println(myTest(1 to 10))

ST76.scala

class Message(p_id: String, p_msg: String) {
  val id = p_id;
  val msg = p_msg;
}

ST77.scala

val messageList = List(
  Message("tom@gmail.com", "Message text 1"),
  Message("7742394590", "Message text 2"),
  Message("8326192398", "Message text 3"),
  Message("lisa@gmail.com", "Message text 4"),
  Message("lisa@yahoo.com", "Message text 5"),
  Message("harry@gmail.com", "Message text 6")
)

ST78.scala

def testMessagePattern(l: List[Message]): String = {
  l match {
    case Nil => "Not found"
    case Message(EmailAddress(u1, d1), _) :: Message(EmailAddress(u2, d2), _) :: _
        if (u1 == u2) =>
      u1 + " got two successive emails"
    case h :: t => testMessagePattern(t)
  }
}

ST79.scala

class Message(p_id: String, p_msg: String) {
  val id = p_id;
  val msg = p_msg;
}

object Message {
  def apply(id: String, msg: String) = new Message(id, msg)

  def unapply(m: Message): Option[(String, String)] = {
    if (m == null) None
    else Some(m.id, m.msg)
  }
}

object EmailAddress {
  def apply(uname: String, dname: String) = uname + "@" + dname

  def unapply(str: String): Option[(String, String)] = {
    val parts = str split "@"
    if (parts.length == 2) Some(parts(0), parts(1)) else None
  }
}

def testMessagePattern(l: List[Message]): String = {
  l match {
    case Nil => "Not found"
    case Message(EmailAddress(u1, d1), _) :: Message(EmailAddress(u2, d2), _) :: _
        if (u1 == u2) =>
      u1 + " got two successive emails"
    case h :: t => testMessagePattern(t)
  }
}

val messageList = List(
  Message("tom@gmail.com", "Message text 1"),
  Message("7742394590", "Message text 2"),
  Message("8326192398", "Message text 3"),
  Message("lisa@gmail.com", "Message text 4"),
  Message("lisa@yahoo.com", "Message text 5"),
  Message("harry@gmail.com", "Message text 6")
)

println(testMessagePattern(messageList))

ST80.scala

def getHike(salary:Double) = salary * p/100