Implicits in Scala: Understanding implicit scopes and use cases

Implicits
Scalain
Derek Wyatt
Twitter: @derekwyatt
Email: derek@derekwyatt.org
Friday, 11 October, 13

Agenda
Lies and Damn Lies
Use Cases
Scope
ExampleCode!
Truths
Rules of Thumb

Implicits are NEW

Implicits are NEW
New things can be cool!

Implicits are NEW
New things can also be scary!
❉
Scala 2.10’s new set of
warnings don’t help the
situation.
❉

Implicits are NEW
❉
situation.
❉
Especially when they’re complicated!

Implicits are NEW
Newness + Complexness = Fearsometimes
❉
situation.
❉

Implicits are NEW
Fear Avoidance
❉
situation.
❉

Implicits are NEW
Fear Avoidance
Avoidance :(
❉
situation.
❉

Implicits

Implicits
Are Not

Implicits
Are Not
Global variables LIE!

Implicits
Are Not
Global variables
Dynamically Applied
LIE!
DAMN
LIE!

Implicits
Are Not
Global variables
Dynamically Applied
Dangerous (...much...)
LIE!
DAMN
LIE!
Fib

Implicits
Are Not
Global variables
Dynamically Applied
Dangerous (...much...)
Implicits are like scissors.
Use them. Don’t run with them.
LIE!
DAMN
LIE!
Fib

Use Cases
What are they used for?

Use Case: Type Classes

val a = someInt()
val b = someOtherInt()
val lesser = if (lessThan(a, b)) a else b

val a = someInt()
lessThan needsdefinition

def lessThan[A](a: A, b: A)(implicit o: Ordering[A]): Boolean =
o.lt(a, b)
val a = someInt()

o.lt(a, b)
val a = someInt()
Ordering[Int]’s gottacome from somewhere

o.lt(a, b)
implicit object intOrdering extends Ordering[Int] {
def compare(a: Int, b: Int): Int = a - b
}
val a = someInt()

o.lt(a, b)
implicit object intOrdering extends Ordering[Int] {
def compare(a: Int, b: Int): Int = a - b
}
val a = someInt()
val a = someInt()
val lesser = if (lessThan(a, b)(intOrdering)) a else b

Use Case: Class Extension

val hexVals = “implicit”.asHexSeq
// Vector(0x69, 0x6D, 0x70, 0x6C, 0x69, 0x63, 0x69, 0x74)
The “Pimp”

The “Pimp”
implicit class HexableString(s: String) {
def asHexSeq: Seq[String] = s map { c =>
f”0x$c%02X”
}
}
The implicit class definition provides the
extension method

The “Pimp”
implicit class HexableString(s: String) {
def asHexSeq: Seq[String] = s map { c =>
f”0x$c%02X”
}
}
The implicit class definition provides the
extension method
Bonus: If you extend implicit classes from AnyVal,
no temporary object construction will occur.

Use Case: Decluttering
val future1 = someCall(“a parameter”, 5.seconds)
val future2 = someCall(345, 5.seconds)
val future3 = someCall(235.9352, 5.seconds)

Blurgh

Blurgh
def someCall[A](a: A)(implicit timeout: Duration): Future[A] = ???
But, if we define someCall this way...

Blurgh
def someCall[A](a: A)(implicit timeout: Duration): Future[A] = ???
But, if we define someCall this way...
implicit val myTimeoutValue = 5.seconds
val future1 = someCall(“a parameter”)
val future2 = someCall(345)
val future3 = someCall(235.9352)
And define an
implicit value, we can
simplify the calls...

Use Case: Internal DSLs
Create your own sub-language with ease

implicit class Recoverable[A](f: => A) {
def recover(g: Throwable => A): A =
try {
f
} catch {
case t: Throwable =>
g(t)
}
}

implicit class Recoverable[A](f: => A) {
def recover(g: Throwable => A): A =
try {
f
} catch {
case t: Throwable =>
g(t)
}
}
def thisThrows(): Int = throw new Exception(“Argh!”)
val stable = thisThrows() recover { t =>
if (t.getMessage == “Argh!”)
10
else
5
} // stable == 10

Use Case: Other stuff...

Overriding defaults
def func[A](a: A)(implicit tout: Duration = 3.seconds): Future[A]

Overriding defaults
Decoupled Dependency Injection
class Database(ec: ExecutionContext) {
def create(row: Row): Future[Result] = ???
def delete(id: RowId): Future[Result] = ???
// etc...
}

Overriding defaults
class Database(ec: ExecutionContext) {
def create(row: Row): Future[Result] = ???
def delete(id: RowId): Future[Result] = ???
// etc...
}
NO!

Overriding defaults
class Database {
def create(row: Row)(implicit ec: ExecutionContext): Future[Result]
def delete(id: RowId)(implicit ec: ExecutionContext): Future[Result]
// etc...
}
We can now vary the ExecutionContext at any
point by supplying the right implicit value

Implicit Scope
Rules!!!!

Implicit Scope
Rules!!!!
There are a Lot of Rules

Implicit Scope
Rules!!!!
Read “Scala In Depth”*
*Josh Suereth

Implicit Scope
Rules!!!!
Implicits without the Import Tax*
*Josh Suereth

Implicit Scope
Rules!!!!
Implicits without the Import Tax*
*Josh Suereth
I don’t know them super well, and I haven’t cut my
arm off yet...

Creating a Protocol

Creating a Protocol
an Implicit

Creating a Protocol
an Implicit
We want:
actor emit Message(“Hello”)

Creating a Protocol
an Implicit
We want:
actor emit Message(“Hello”)
To Produce:
actor ! Envelope(ComponentType(“Client”),
ComponentType(“DBActor”),
ComponentId(“/user/supervisor/DB”),
WorkId(“764efa883dd7671c4a3bbd9e”),
MsgType(“org.my.Message”),
MsgNum(1),
Message(“Hello”))

An Actor Derivation
trait EnvelopingActor extends Actor
with EnvelopeImplicits
with ActorRefImplicits {
implicit val myCompType = ComponentType(getClass.getSimpleName)
implicit val myCompId = ComponentId(self.path)
private var currentWorkId = unknownWorkId
implicit def workId: WorkId = currentWorkId
private var currentMsgNum = MsgNum(-1)
implicit def msgNum: MsgNum = currentMsgNum
def derivedReceive: Receive
def derivedReceiveWrapper(wrapped: Receive): Receive = ???
final def receive = derivedReceiveWrapper(derivedReceive)
}

An Actor Derivation
trait EnvelopingActor extends Actor
with EnvelopeImplicits
with ActorRefImplicits {
implicit val myCompType = ComponentType(getClass.getSimpleName)
implicit val myCompId = ComponentId(self.path)
private var currentWorkId = unknownWorkId
implicit def workId: WorkId = currentWorkId
private var currentMsgNum = MsgNum(-1)
implicit def msgNum: MsgNum = currentMsgNum
def derivedReceive: Receive
def derivedReceiveWrapper(wrapped: Receive): Receive = ???
final def receive = derivedReceiveWrapper(derivedReceive)
}
Sets up the
implicits in a
high priority
scope

The Receive Wrapper
def derivedReceiveWrapper(wrapped: Receive): Receive = {
case Envelope(_, _, _, workId, _, messageNum, message) =>
currentWorkIdVar = workId
currentMessageNumVar = messageNum
wrapped(message)
case message =>
currentWorkIdVar = createWorkId()
currentMessageNumVar = MessageNum(-1)
wrapped(message)
}

The Receive Wrapper
def derivedReceiveWrapper(wrapped: Receive): Receive = {
case Envelope(_, _, _, workId, _, messageNum, message) =>
currentWorkIdVar = workId
currentMessageNumVar = messageNum
wrapped(message)
case message =>
currentWorkIdVar = createWorkId()
currentMessageNumVar = MessageNum(-1)
wrapped(message)
}
Ensures that the values that vary (workId and msgNum)
are updated in the implicit scope.

Envelope Implicits
trait EnvelopeImplicits {
import scala.language.implicitConversions
implicit def any2Envelope(a: Any)
(implicit fromCompType: ComponentType,
fromCompId: ComponentId,
workId: WorkId,
msgNum: MsgNum) =
Envelope(fromCompType, fromCompId, unknownCompId,
MsgType(a.getClass.getSimpleName),
workId, msgNum, a)
}
Allows us to substitute a concrete Envelope value where
an Any has been supplied. The implicit parameters make
this possible.

ActorRef Implicits
trait ActorRefImplicits {
implicit class PimpedActorRef(ref: ActorRef) {
def emit(envelope: Envelope)
(implicit sender: ActorRef = Actor.noSender): Unit = {
ref.tell(envelope.copy(
toComponentId = ComponentId(ref.path),
msgNum = envelope.msgNum.increment
), sender)
}
}
}
The emit method demands an Envelope. When you call
emit, that starts the implicit conversion! any2Envelope
creates it, and we update it here with better values.

Using the Protocol
class MyActor extends EnvelopingActor {
def derivedRecieve: Receive = {
case Message(str) =>
someOtherActor emit Message(s”I got: $str”)
}
}

Using the Protocol
}
}
Envelope(
ComponentType(“SomeActor”),
ComponentType(“MyActor”),
ComponentId(“/user/myactor”),
WorkId(“ad7e877e41ff32a2”),
MsgNum(0),
Message(“SomeActor sent”))
Incoming

Using the Protocol
}
}
Envelope(
MsgNum(0),
Incoming
Envelope(
ComponentType(“SomeOtherActor”),
ComponentId(“/user/someother”),
MsgNum(1),
Message(“I got: SomeActor sent”))
Outgoing

Using the Protocol
}
}
Envelope(
MsgNum(0),
Incoming
Envelope(
MsgNum(1),
Outgoing
Chained

Using the Protocol
}
}
Envelope(
MsgNum(0),
Incoming
Envelope(
MsgNum(1),
Outgoing
Maintained

Using the Protocol
}
}
Envelope(
MsgNum(0),
Incoming
Envelope(
MsgNum(1),
Outgoing
Incremented

All the Implicits

All the Implicits
Pimp ActorRef with Emit

All the Implicits
Convert Any to envelope

All the Implicits
Simplify the API

All the Implicits
Simplify the API
actor emit Message(”Here’s a message”)
Just in case you forgot...

All the Implicits
Simplify the API
actor emit Message(”Here’s a message”)
Just in case you forgot...
SIMPLE

The Last Use Case

The Last Use Case
Implicits help you put complexity
where it belongs...
In your libraries!
&Away from your
Users!

Pitfalls
&Rules of Thumb

Pitfalls
&Rules of Thumb
Use very speciﬁc types
ComponentType(s: String) String()NOT

Pitfalls
&Rules of Thumb
Enable by import, not compiler switches
Keeps libraries self-contained and avoids surprises

Pitfalls
&Rules of Thumb
Push parameters to methods if you can
This keeps implicit resolution more ﬂexible

Pitfalls
&Rules of Thumb
Push parameters to methods if you can
This keeps implicit resolution more ﬂexible
Use the right tool for the right job!!

Implicits
Scalain
Derek Wyatt
Twitter: @derekwyatt
Email: derek@derekwyatt.org
Thanks to @heathermiller for the presentation style
Source code is available at:
https://github.com/primal-github/implicit-messaging

Implicits in Scala: Understanding implicit scopes and use cases

Recommended

Recommended

More Related Content

Viewers also liked

Viewers also liked (20)

Similar to Implicits in Scala: Understanding implicit scopes and use cases

Similar to Implicits in Scala: Understanding implicit scopes and use cases (20)

Recently uploaded

Recently uploaded (20)

Implicits in Scala: Understanding implicit scopes and use cases