speedcom

/**
 * Part Zero : 10:15 Saturday Night
 *
 * (In which we will see how to let the type system help you handle failure)...
 *
 * First let's define a domain. (All the following requires scala 2.9.x and scalaz 6.0)
 */

import scalaz._
import Scalaz._

speedcom

import scalaz.\/
import scalaz.syntax.either._

object Example2 {
  // This example simulates error handling for a simple three tier web application
  //
  // The tiers are:
  // - the HTTP service
  // - a user authentication layer
  // - a database layer

speedcom

// 1 example
class A(name: String) {
  case class B(nr: Int)

  def add(first: B, second: B): Int = first.nr + second.nr
}

val a1 = new A(name = "first")
val a2 = new A(name = "second")

speedcom

trait Acceptable[T]

object Acceptable {
  implicit object LongOK extends Acceptable[Long]
  implicit object IntOK extends Acceptable[Int]
}


object A {
  def f[T : Acceptable](t : T) = t

speedcom

// SCALA PHANTOM TYPES EXAMPLES

// 1 SIMPLE EXAMPLE 
trait DoorStatus 
trait DoorOpened extends DoorStatus
trait DoorClosed extends DoorStatus

case class Door[Status <: DoorStatus] private () {

  def close[T >: Status <: DoorOpened](): Door[DoorClosed] = Door[DoorClosed]()

speedcom

// implicit conversion from one type to another one

// 1 way
object ViewBound {

  trait Show {
    def show: String
  }

  object Show {

speedcom

package Boot

import akka.actor.{Cancellable, Actor, ActorSystem, Props}
import akka.stream.{OverflowStrategy, ActorFlowMaterializer}
import akka.stream.actor.ActorSubscriberMessage.{OnComplete, OnNext}
import akka.stream.actor.{ActorSubscriber, OneByOneRequestStrategy, RequestStrategy}
import akka.stream.scaladsl._
import org.akkamon.core.exporters.StatsdExporter
import org.akkamon.core.instruments.{CounterTrait, LoggingTrait, TimingTrait}

speedcom

object ReadSample extends App {

  /**
   * The readable trait defines how objects can be converted from a string
   * representation to the objects instance. For most of the standard types
   * we can simply use the toType function of String.
   */
  trait Readable[T] {
    def read(x: String): T
  }

speedcom

/** A for comprehension ready Monad */
case class Focomo[A](value: A) {
  self =>
  /** satisfies monadic binding of a function f that returns B */
  def map[B](f: A => B): Focomo[B] = { 
    println("map!"); 
    Focomo(f(value)) 
  }
  /** satisfies monadic binding of a function f that returns Focomo[B] */
  def flatMap[B](f: A => Focomo[B]): Focomo[B] = { 

speedcom

import java.util.concurrent.ThreadPoolExecutor.AbortPolicy
import java.util.concurrent._

import scala.concurrent.{ Promise, Future }
import scala.concurrent.duration.FiniteDuration
import scala.language.implicitConversions
import scala.util.Try

object ScheduledExecutor {
  private val defaultHandler: RejectedExecutionHandler = new AbortPolicy