println({
  val x = 1 + 1
  x + 1
})
// 3

val value = {
  val a = 1
  val b = { val c = 2; val d = 9; c + d }
  a + b
}
if (value > {val a = 1; a * 2 }) {
  println(s"Value $value is greater than 1*2")
  0
} else value
// Value 12 is greater than 1*2

(x: Int) => x + 1

def matchTest(x: Int): String = x match {
  case 1 => "one"
  case 2 => "two"
  case 3 | 4 => "three or four"
  case _ => "many"
}

def matchTest(x: Int): String = x match {
  case 1 => "one"
  case 2 => "two"
  case 3 | 4 => "three or four"
  case x if x < 1 => s"It's < 1: $x"
  case x => s"It's > 4: $x"
}

def printArgs(args: Array[String]): Unit = {
  var i = 0
  while (i < args.length) {
    println(args(i))
    i += 1
  }
}

class BankAccount {
  var balance = 0

  def deposit(amount: Int) {
    if (amount > 0) balance += amount
    else balance
  }

  def withdraw(amount: Int): Int =
    if (amount >= 0 && amount <= balance) {
      balance -= amount
      balance
    } else {
      println("insufficient funds")
      balance
    }
}

val account = new BankAccount
account.deposit(30) // return 30
account.deposit(20) // return 20
account.withdraw(10) // return 10

// Current balance: 40

Traversable(1, 2, 3)
Iterable("x", "y", "z")
Map("x" -> 24, "y" -> 25, "z" -> 26)
Set(Color.red, Color.green, Color.blue)
SortedSet("hello", "world")
Buffer(x, y, z)
IndexedSeq(1.0, 2.0)
LinearSeq(a, b, c)

def isEmpty: Boolean
def size: Int
def ++[B >: A, That](xs: GenTraversableOnce[B])(implicit bf: ...): That
def map[B, That](f: A => B)(implicit bf: ...): That
def filter(p: A => Boolean): Traversable[A]
def groupBy[K](f: A => K): Map[K, Traversable[A]]
def foreach[U](f: A => U): Unit
def forall(p: A => Boolean): Boolean
def exists(p: A => Boolean): Boolean
def count(p: A => Boolean): Int
// Y muchos más...

case class Donut(fat: Int)

case class Person(weight: Int) {
  def eat(donut: Donut):Person =
    Person(weight + donut.fat)
}

class Greeter(prefix: String, suffix: String) {
  def greet(name: String): Unit =
    println(prefix + name + suffix)
}

trait Size {
  def size: Int
}

package logging

object Logger {
  def info(message: String): Unit =
    println(s"INFO: $message")
}

case class Point(x: Int, y: Int)

sealed trait Error {
  def msg: String
}
case class ConnectionError(msg: String, clientType: ClientType) extends Error
case class BusinessError(msg: String) extends Error
case class UnrecoverableError(msg: String) extends Error

case class Response(body: String, status: Int)

def errorHandling(error: Error): Response = error match {
  case ConnectionError(msg, client, HttpClient) =>
    Response(s"Rest Client Error trying to connect to $client. Cause: $msg", status = 500)

  case ConnectionError(msg, client, DBClient) =>
    Response(s"DB Error trying to connect to $client. Cause: $msg", status = 500)

  case BusinessError(msg) =>
    Response(s"Wrong requests due to: $msg", status = 400)

  case UnrecoverableError(msg) =>
    Response(s"Unexpected error: $msg", status = 500)

}

case class User(id: Int, name: String)

class User(val id: Int, val name: String) extends Product with Serializable {

  // El compilador agrega varios métodos como: copy(), hashCode(), equals(), etc.

  // Ej:
  override def toString: String = s"User($id,$name)"
}

object User {
  def apply(id: Int, name: String): User =
    new User(id, name)

  // for pattern matching
  def unapply(user: User): Option[(Int, String)] =
    Some((user.id, user.name))
}

User(1, "pepe") match {
  case User(1, "pepe") => "Yes!"
  case x               => s"No: $x"
}
// "Yes!"

User(2, "pepe") match {
  case User(1, "pepe") => "Yes!"
  case x               => s"No: $x"
}
// "No: User(2, "pepe")"

abstract class Expr {
  def isNumber: Boolean
  def isSum: Boolean
  def numValue: Int
  def leftOp: Expr
  def rightOp: Expr
}

class Number(n: Int) extends Expr {
  def isNumber: Boolean = true
  def isSum: Boolean = false
  def numValue: Int = n
  def leftOp: Expr = error("Number.leftOp")
  def rightOp: Expr = error("Number.rightOp")
}

class Sum(e1: Expr, e2: Expr) extends Expr {
  def isNumber: Boolean = false
  def isSum: Boolean = true
  def numValue: Int = error("Sum.numValue")
  def leftOp: Expr = e1
  def rightOp: Expr = e2
}

abstract class Expr {
  def eval: Int
}
class Number(n: Int) extends Expr {
  def eval: Int = n
}
class Sum(e1: Expr, e2: Expr) extends Expr {
  def eval: Int = e1.eval + e2.eval
}

sealed abstract class Expr
case class Number(n: Int) extends Expr
case class Sum(e1: Expr, e2: Expr) extends Expr

sealed abstract class Expr
case class Number(n: Int) extends Expr
case class Sum(e1: Expr, e2: Expr) extends Expr

sealed trait List[+A]
case object Nil extends List[Nothing]
case class Cons[+A](head: A, tail: List[A]) extends List[A]

sealed trait Error {
  def msg: String
}
case class ConnectionError(msg: String, client: String) extends Error
case class BusinessError(msg: String) extends Error
case class UnrecoverableError(msg: String) extends Error

def printResult(result: Result): String = {
  if (result != null)
    result.toString
  else
    "Result is null"
}

def divide(dividend: Int, divisor: Int): Int = {
  if (divisor == 0)
    throw new RuntimeException("Divisor can't be 0")
  dividend / divisor
}

def usingDivision: Unit = {
  try {
    val result = divide(10, 0)
    println(s"The result is $result")
  } catch {
    case exc: Throwable =>
      println(s"Exception: ${exc.getMessage}")
  }
}

def usingDivision: Response = {
  try {
    val result = restTemplate.getForEntity(s"$url/$id", classOf[String])
    Response(status = 200, result)
  } catch {
    case exc: Throwable =>
      println(s"Exception: ${exc.getMessage}")
      Response(status = 500, "Please, retry later")
  }
}

val thread: Thread = new Thread() {
  override def run(): Unit = {
    println("Thread Running")
  }
}
thread.start()

def printResult(result: Result): String = {
  if (result != null)
    result.toString
  else
    "Result is null"
}

def printResult(foo: Option[Result]): String = {
  foo.map { fooValue =>
    fooValue.value
  } getOrElse "foo is None"
}

def divide(dividend: Int, divisor: Int):Int = {
  if (divisor == 0)
    throw new RuntimeException(
      "Divisor can't be 0")
  dividend / divisor
}

def divide(dividend: Int,
           divisor: Int):
    Either[String, Int] = {
  if (divisor == 0)
    Left("Divisor can't be 0")
  else
    Right(dividend / divisor)
}

def usingDivision: Response = {
  try {
    val result = restTemplate
      .getForEntity(s"$url/$id", classOf[String])
    Response(status = 200, result)
  } catch {
    case exc: Throwable =>
      println(s"Exception: ${exc.getMessage}")
      Response(status = 500,
               body = "Please, retry later")
  }
}

def retrieveValue(): Try[String] = Try {
  restTemplate.getForEntity(s"$url/$id",
                            classOf[String])
}

def getResponse: Response = retrieveValue() match {
  case Success (result) => Response(status = 200, result)
  case Failure (exc)    => Response(status = 500,
                                    body = errorMsg)
}

val thread: Thread = new Thread() {
  override def run(): Unit = {
    println("Thread Running")
  }
}
thread.start()

implicit val executionContext: ExecutionContext = ???

Future {
  println("Thread Running")
}

implicit val executionContext: ExecutionContext = ???

val usdQuote = Future { connection.getCurrentValue(USD) }
val arsQuote = Future { connection.getCurrentValue(ARS) }

val purchase = usdQuote flatMap { usd =>
    arsQuote
      .filter(ars => isProfitable(usd, ars))
      .map(ars => connection.buy(amount, ars))
}

purchase foreach { _ =>
  println("Purchased " + amount + " ARS")
}

type F[T] = Option[T]

type F[T] = Either[E, T]

type F[T] = List[T]

type F[T] = Try[T]

type F[T] = Future[T]

trait F[A] {
  def map[B](f: A => B): F[B]
  def flatMap[B](f: A => F[B]): F[B]
  def getOrElse[B >: A](default: => B): B
  def orElse[B >: A](ob: => F[B]): F[B]
  def filter(f: A => Boolean): F[A]
  // y muchos más!!
}

object F {
  def apply(value: => A): F[A]
}

def getFirstName(user: User): Option[String] = ???
def getLastName(user: User): Option[String] = ???

def getFullName(user: User): Option[String] = {
  getFirstName(user).flatMap { firstName =>
    getLastName(user).map(lastName =>
      s"$firstName:$lastName")
  }
}

def getFullName_viaForCmp(user: User): Option[String] = {
  for {
    firstName <- getFirstName(user)
    lastName  <- getLastName(user)
  } yield {
    s"$firstName:$lastName"
  }
}

def add(x: Int, y: Int): Int = x + y

def area(width: Int = 1, height: Int = 2): Int = width * height

area() // 2

area(10) // 20

area(height = 3) // 3

def area(width: Int, height: => Int): Int = {
  if(width == 0) 0 else width * height
}

def computeHeight: Int = {
  println("Fetching height...")
  10
}

println(area(1, computeHeight))
// Fetching height...
// 10

println(area(0, computeHeight))
// 0

import scala.math._

case class Circle(radius: Double) {
  import Circle._
  def area: Double = calculateArea(radius)
}

object Circle {
  private def calculateArea(radius: Double): Double =
    Pi * pow(radius, 2.0)
}

val circle = new Circle(5.0)
circle.area