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

1 + 2 * 3 / x

(1).+(((2).*(3))./(x))

> var score = 100
score: Int = 100

> score = 120
score: Int = 120

(x: Int) => x + 1

import java.time.LocalDateTime

def log(msg: String, writer: String => Unit) = writer(s"${LocalDateTime.now()} : $msg")

log("log line", msg => println(msg)) // 2018-11-01T15:20:56.570 : log line

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

val addTwo: Int => Int = add(2) // a function that add 2 to the given number

addTwo(4)  // 6
addTwo(8)  // 10
addTwo(20) // 22

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
  }
}

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

def formatArgs(args: Array[String]): String =
  args.mkString("\n")

def printArgs(args: Array[String]): Unit =
  println(formatArgs(args))

def calculateInt(num: Int): Int

// Take the sum of the integers between a and b:
def sumInts(a: Int, b: Int): Int = {
  if (a > b) 0
  else a + sumInts(a + 1, b)
}

// Sum integers between a and b:
def sumInts(a: Int, b: Int): Int =
  if (a > b) 0
  else a + sumInts(a + 1, b)

// Greatest common divisor of a and b:
def gcd(a: Int, b: Int): Int =
  if (b == 0) a
  else gcd(b, a % b)

def calculateRec(num: BigInt): BigInt

val fruits = List("apples", "oranges", "pears")
val nums   = List(1, 2, 3, 4)
val diag3  = List(List(1, 0, 0), List(0, 1, 0), List(0, 0, 1))
val empty  = List()

val list: List[Int] = ???

list match {
  case List(1, 2)    => println("Lista compuesta por los elementos 1 y 2")
  case 1 :: 2 :: Nil => println("Lista compuesta por los elementos 1 y 2")
  case 1 :: 2 :: xs  => println("Lista que comienza con los elementos 1 y 2")
  case x :: y :: xs  => println("Lista con 2 o más elementos")
  case x :: y :: Nil => println("Lista con solo 2 elementos")
  case List()        => println("Lista vacía")
  case Nil           => println("Lista vacía")
  case x :: xs       => println("Lista no vacía")
}

def flatten[A](xs: List[List[A]]): List[A]

def dropWhile[A](xs: List[A], f: A => Boolean): List[A]

def concat[A](xs: List[A], ys: List[A]): List[A]

def reverse[A](xs: List[A]): List[A]

def isEmpty[A](xs: List[A]): Boolean

def scaleList(xs: List[Double], factor: Double): List[Double] = xs match {
  case Nil => Nil
  case y :: ys => y * factor :: scaleList(ys, factor)
}

def ages(people: List[Person]): List[Int] = people match {
  case Nil => Nil
  case x :: xs => x.age :: ages(xs)
}

def map[A, B](xs: List[A])(f : A => B): List[B]

def scaleList_viaMap(xs: List[Double], factor: Double): List[Double]

def ages_viaMap(people: List[Person]): List[Int]

def flatMap[A, B](xs: List[A])(f : A => List[B]): List[B]

def posElems(xs: List[Int]): List[Int] = xs match {
  case Nil => Nil
  case y :: ys => if (y > 0) y :: posElems(ys) else posElems(ys)
}

def adults(persons: List[Person]): List[Person] = xs match {
  case Nil => Nil
  case y :: ys => if (y.age >= 18) y :: adults(ys) else adults(ys)
}

def filter[A](xs: List[A], f: A => Boolean): List[A]

def posElems_viaFilter(xs: List[Int]): List[Int]

def adults_viaFilter(persons: List[Person]): List[Person]

def sum(ints: List[Int]): Int = ints match {
  case Nil     => 0
  case x :: xs => x + sum(xs)
}

def length[A](l: List[A]): Int = l match {
  case Nil     => 0
  case _ :: xs => 1 + length(xs)
}

def foldRight[A,B](as: List[A], z: B)(f: (A, B) => B): B

def sum_viaFoldRight(ints: List[Int]): Int

def length_viaFoldRight[A](l: List[A]): Int

def concat_viaFoldRight[A](l1: List[A], l2: List[A]): List[A]

def flatten_viaFoldRight[B](xs: List[List[B]]): List[B]

def map_viaFoldRight[B](xs: List[Int], f : Int => B): List[B]

def foldRight[A, B](l: List[A], z: B, f: (B, A) => B): B = l match {
  case Nil => z
  case x :: xs => f(x, foldRight(xs, z, f))
}

foldRight(List(1, 2, 3), 0)((x, y) => x + y)
1 + foldRight(List(2, 3), 0)((x, y) => x + y)
1 + (2 + foldRight(List(3), 0)((x, y) => x + y))
1 + (2 + (3 + (foldRight(Nil, 0)((x, y) => x + y))))
1 + (2 + (3 + (0)))
6

def foldLeft[A,B](as: List[A], z: B)(f: (B, A) => B): B

def sum_viaFoldLeft(ints: List[Int]): Int

def length_viaFoldLeft[A](l: List[A]): Int

def reverse_viaFoldLeft[A](l: List[A]): List[A]

def foldLeft[A, B](l: List[A], z: B, f: (A, B) => B): B = {
  @tailrec
  def go(sublist: List[A], acc: B): B = sublist match {
    case Nil => acc
    case x :: xs => go(xs, f(x, acc))
  }
  go(l, z)
}

foldLeft(List(1, 2, 3), 0)((x, y) => x + y)
foldLeft(List(2, 3), 0 + 1)((x, y) => x + y)
foldLeft(List(3), (0 + 1) + 2)((x, y) => x + y)
foldLeft(Nil, ((0 + 1) + 2) + 3)((x, y) => x + y)
((0 + 1) + 2) + 3
6

foldRight(List(1, 2, 3), 0)((x, y) => x + y)
1 + foldRight(List(2, 3), 0)((x, y) => x + y)
1 + (2 + foldRight(List(3), 0)((x, y) => x + y))
1 + (2 + (3 + (foldRight(Nil, 0)((x, y) => x + y))))
1 + (2 + (3 + (0)))
6

def foldRight_viaFoldLeft[A,B](as: List[A], z: B)(f: (A, B) => B): B

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...

def mean(xs: List[Double]): Double = xs match {
  case Nil => ???
  case xs => xs.sum / xs.size
}

def mean(xs: List[Double]): Option[Double] = xs match {
  case Nil => ???
  case _   => ???
}

trait Option[A] {
  def map[B](f: A => B): Option[B]
  def flatMap[B](f: A => Option[B]): Option[B]
  def getOrElse[B >: A](default: => B): B
  // Con => el parámetro no se evalua a menos que se utilice
  def orElse[B >: A](ob: => Option[B]): Option[B]
  def filter(f: A => Boolean): Option[A]
}

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, client: String) 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) =>
    Response(s"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 ManuallyUser(val id: Int, val name: String) extends Product with Serializable {
  // El compilador agrega varios métodos como: copy(), hashCode(), equals(), etc.
  override def toString: String = s"ManuallyUSer($id,$name)"
}
object ManuallyUser {
  def apply(id: Int, name: String): ManuallyUser =
    new ManuallyUser(id, name)
  // for pattern matching
  def unapply(manuallyUser: ManuallyUser): Option[(Int, String)] =
    Some((manuallyUser.id, manuallyUser.name))
}

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

ManuallyUser(2, "pepe") match {
  case ManuallyUser(1, "pepe") => "Yes!"
  case x => s"No: $x"
}
// "No: ManuallyUser(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