implicit examples

implic.sc

//////// Implicit parameter
def giveMeAnInt(implicit i: Int) = i
giveMeAnInt(123)

implicit val someInt: Int = 42
giveMeAnInt
giveMeAnInt(321)

def makeString(i: Int): String = s"makeString:  ${i.toString}"
makeString(1)

case class Balance(amount: Int)
val balance = Balance(100)

implicit def balance2String(balance: Balance): Int = balance.amount
makeString(balance)

///////// Implicit View
 class StringWrapper(s: String) {
  def quoted = s"""$s"""
}

new StringWrapper("my String").quoted
// but "my String".quoted won't compile, sooo ...

implicit  def wrapString(s: String): StringWrapper = new StringWrapper(s)
"my String".quoted

///////// Implicit View with a more complex type
package qq.ww

case class Asdf(a: Int, b: String)

object AsdfOps {
  class AsdfWrapper(c: Asdf) {
    def behave = c.copy(a = 5)
  }

  implicit def wrapAsdf(c: Asdf): AsdfWrapper = new AsdfWrapper(c)

}

object Main extends App {
  import qq.ww.AsdfOps._
  val q = Asdf(8, "asdfff")

  println(q.behave)
}
/////////// Implicit Class
implicit class RichBalance(val balance: Balance) {
  def unary_- : Balance = balance.copy(amount = -balance.amount)
}

//-balance // should work

////////// Scope
case class CaseClass(content: String)
object  CaseClass {
  implicit val cc = CaseClass("defined in companion obj")
}

object Explicit {
  implicit val explicitCaseClass = CaseClass("defined in Explicit obj")
}

object WildCard {
  implicit val wildCardCaseClass = CaseClass("defined in WildCard obj")
}

def findCaseClass(implicit cc: CaseClass) = cc

findCaseClass

////////// Scope
implicit val localCaseClass = CaseClass("defined in local val")
findCaseClass

////// import wildcard
//  import WildCard._
//  println(findCaseClass)


////// explicit import
//import Explicit.explicitCaseClass
//findCaseClass