gigiigig

object console extends App {

  trait Op
  trait Open extends Op
  trait Close extends Op

  trait Door[O <: Op]
  object Door {
    def apply[S <: Op] = new Door[S] {}

gigiigig

object console extends App {


  trait Printer[T] {
    def print(t: T): String
  }

  object Printer {
    implicit val intPrinter: Printer[Int] = new Printer[Int] {
      def print(i: Int) = s"$i: Int"

gigiigig

import shapeless._                                                                                                 
import shapeless.record._                                                                                          
import shapeless.ops.hlist.Selector                                                                                
                                                                                                                   
object console extends App {                                                                                       
                                                                                                                   
  trait HListContains[T <: HList, R <: HList]                                                                      
                                                                                                                   
  object HListContains {                                                                        

gigiigig

import shapeless._                                                                                                 
import shapeless.record._                                                                                          
import shapeless.ops.record._                                                                                      
import shapeless.ops.hlist._                                                                                       
                                                                                                                   
object console extends App {                                                                                       
                                                                                                                   
  object sql {                                                                                                     
                                                                                                

gigiigig

object console extends App {

  trait Nat {
    type Plus[That <: Nat] <: Nat
  }
  trait _0 extends Nat {
    type Plus[That <: Nat] = That
  }
  trait Succ[N <: Nat] extends Nat {
    type Plus[That <: Nat] = Succ[N#Plus[That]]

gigiigig

 trait Foo {
    case class Bar(i: Int, s: String)
  }

  val fb1 = new Foo {}.Bar(3, "ciao")
  val fb2 = new Foo {}.Bar(3, "ciao")

  val equal = fb1 == fb2
  println(s"equal: ${equal}") // equal: false

gigiigig

trait Config {
  val timeout: Int = 1
  val interval: Int = 2
  def wantToChangeThis: Int
}

object DefaultConfig extends Config {
  val wantToChangeThis: Int = 34
}

gigiigig

import scalaz._
import Scalaz._

/** I think there are two use cases where implicits are very useful:
 *  TypeClasses
 *  Pimp or Rich pattern
 *
 *  Let's start with typeclasses, probably the more popular, 
 *  e.g. Collection library in Scala is all TC based, look for CanBuildFrom
 */

gigiigig

Homebrew build logs for neovim/neovim/neovim on OS X 10.11.4
Build date: 2016-03-31 12:27:10

gigiigig

scala> sealed trait Op
defined trait Op

scala> case class Foo(s: String) extends Op
defined class Foo

scala> case class Ciao(i: Int) extends Op
defined class Ciao

scala> case class Bar(op: Op, b: Boolean)