vigneshwaranr

import scala.concurrent.Future

trait AsyncJob {
  def execute(): Future[Boolean]
}

class MyLongRunningJob(asyncJob: AsyncJob) extends Runnable {
  override def run(): Unit = {
    asyncJob.execute()
  }

vigneshwaranr

import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future

// YESS :(
someFutureJob().map { value =>
  operate(value)
}

vigneshwaranr

import scala.concurrent.duration.Duration
import scala.concurrent.{Await, Future}

val future = someFutureJob()

// NOO :(
val value = Await.result(future, Duration.Inf)

operate(value)

vigneshwaranr

def divide3(a: Int, b: Int): MaybeDivideable = {
  for {
    x <- MaybeDivideable(a)
    y <- MaybeDivideable(b)
  } yield (x / y)
}

vigneshwaranr

sealed trait MaybeDivideable {
  def get: Int
  def flatMap(f: Int => MaybeDivideable): MaybeDivideable
  
  /* New map method */
  def map(f: Int => Int): MaybeDivideable
}

case class Divideable(value: Int) extends MaybeDivideable {
  require(value != 0, "value must not be 0")

vigneshwaranr

def divide2(a: Int, b: Int): MaybeDivideable = {
  val aMayBe = MaybeDivideable(a)
  val bMayBe = MaybeDivideable(b)
  aMayBe.flatMap { x =>
    bMayBe.flatMap { y =>
      MaybeDivideable(x / y)
    }
  }
}

vigneshwaranr

def divide1(a: Int, b: Int): MaybeDivideable = {
  MaybeDivideable(a) match {
    case UnDivideable =>
      UnDivideable
    
    case Divideable(x) =>
      MaybeDivideable(b) match {
        case UnDivideable =>
          UnDivideable
        

vigneshwaranr

sealed trait MaybeDivideable {
  def get: Int //Extraction
  def flatMap(f: Int => MaybeDivideable): MaybeDivideable
}

object MaybeDivideable {
  def apply(value: Int): MaybeDivideable = 
      if (value == 0) UnDivideable else Divideable(value) // Lifting
}

vigneshwaranr

public int sumOfSquaresOfEvenElements(List<Integer> list) {
    if (list == null) {
        return 0;
    }
    int acc = 0;
    for (int elem: list) {
        if (elem % 2 == 0) {
            acc += (elem * elem);
        }
    }

vigneshwaranr

import java.util.Random;

public class Main {
    private static final MyBlockingQueue<Integer> queue = new MyBlockingQueue<>();

    static class Producer extends Thread {
        Producer(int i) {
            super("Producer-" + i);
        }
        @Override