Presentation about dependency injection library for Akka actors: https://github.com/wilaszekg/Scala-Dynamic-DI Covers the approach details and basics of type-level programming in Scala and Shapeless necessary for understanding implementation. ScaLAB conference Wrocław, 25.06.2016

1. Typesafe dependency
injection in reactive
applications
Grzegorz Wilaszek
ScaLAB, 25.06.2016

2. About me

3. Typesafe DI in Akka
• Problems with asynchronous dependencies
• Need for special DI technique
• Refactoring with type level programming

4. Dependencies problem
User
ShopId
Future
Shop
Future
Future
Basket
PromotionsFuture
Basket
Actor
ask
response
Products

5. Introducing an Actor
User
ShopId
Future
Shop
Future
Future
Basket
PromotionsFuture
Basket
Actor
ask
response
Products

6. Introducing an Actor
User
ShopId
Future
Shop
Future
Future
Basket
PromotionsFuture
Basket
Actor
ask
response
Products
(User,
Shop)
=>
Future[Basket]
(ShopId)
=>
Future[Shop]
(Shop)
=>
Future[Promotions]

7. Introducing an Actor
User
ShopId
Future
Shop
Future
Future
Basket
PromotionsFuture
Basket
Actor
ask
response
Products
findBasket
findShop findPromotions

8. class ConfigurablePriceCalculator(user: User, shopId: ShopId,
findShop: ShopId => Future[Shop],
findBasket: (User, Shop) => Future[Basket],
findPromotions: Shop => Future[Promotions],
basketKeeper: ActorRef) extends Actor {
private var promotions: Promotions = _
override def preStart(): Unit = {
super.preStart()
for {
shop <- findShop(shopId)
basket <- findBasket(user, shop)
promo <- findPromotions(shop)
} yield {
promotions = promo
self ! basket
}
}
override def receive: Receive = waitForBasket
def waitForBasket: Receive = {
case basket: Basket =>
basketKeeper ! AskForProducts(basket)
context become waitForProducts
}
def waitForProducts: Receive = {
case products: Products => context become work(products)
}
def work(products: Products): Receive = {
case Calculate => sender ! promotions.price(products)
}
}

9. class ConfigurablePriceCalculator(user: User, shopId: ShopId,
findShop: ShopId => Future[Shop],
findBasket: (User, Shop) => Future[Basket],
findPromotions: Shop => Future[Promotions],
basketKeeper: ActorRef) extends Actor {
private var promotions: Promotions = _
override def preStart(): Unit = {
super.preStart()
for {
shop <- findShop(shopId)
basket <- findBasket(user, shop)
promo <- findPromotions(shop)
} yield {
promotions = promo
self ! basket
}
}
override def receive: Receive = waitForBasket
def waitForBasket: Receive = {
case basket: Basket =>
basketKeeper ! AskForProducts(basket)
context become waitForProducts
}
def waitForProducts: Receive = {
case products: Products => context become work(products)
}
def work(products: Products): Receive = {
case Calculate => sender ! promotions.price(products)
}
}

10. class ConfigurablePriceCalculator(user: User, shopId: ShopId,
findShop: ShopId => Future[Shop],
findBasket: (User, Shop) => Future[Basket],
findPromotions: Shop => Future[Promotions],
basketKeeper: ActorRef) extends Actor {
private var promotions: Promotions = _
override def preStart(): Unit = {
super.preStart()
for {
shop <- findShop(shopId)
basket <- findBasket(user, shop)
promo <- findPromotions(shop)
} yield {
promotions = promo
self ! basket
}
}
override def receive: Receive = waitForBasket
def waitForBasket: Receive = {
case basket: Basket =>
basketKeeper ! AskForProducts(basket)
context become waitForProducts
}
def waitForProducts: Receive = {
case products: Products => context become work(products)
}
def work(products: Products): Receive = {
case Calculate => sender ! promotions.price(products)
}
}

11. class ConfigurablePriceCalculator(user: User, shopId: ShopId,
findShop: ShopId => Future[Shop],
findBasket: (User, Shop) => Future[Basket],
findPromotions: Shop => Future[Promotions],
basketKeeper: ActorRef) extends Actor {
private var promotions: Promotions = _
override def preStart(): Unit = {
super.preStart()
for {
shop <- findShop(shopId)
basket <- findBasket(user, shop)
promo <- findPromotions(shop)
} yield {
promotions = promo
self ! basket
}
}
override def receive: Receive = waitForBasket
def waitForBasket: Receive = {
case basket: Basket =>
basketKeeper ! AskForProducts(basket)
context become waitForProducts
}
def waitForProducts: Receive = {
case products: Products => context become work(products)
}
def work(products: Products): Receive = {
case Calculate => sender ! promotions.price(products)
}
}

12. class ConfigurablePriceCalculator(user: User, shopId: ShopId,
findShop: ShopId => Future[Shop],
findBasket: (User, Shop) => Future[Basket],
findPromotions: Shop => Future[Promotions],
basketKeeper: ActorRef) extends Actor {
private var promotions: Promotions = _
override def preStart(): Unit = {
super.preStart()
for {
shop <- findShop(shopId)
basket <- findBasket(user, shop)
promo <- findPromotions(shop)
} yield {
promotions = promo
self ! basket
}
}
override def receive: Receive = waitForBasket
def waitForBasket: Receive = {
case basket: Basket =>
basketKeeper ! AskForProducts(basket)
context become waitForProducts
}
def waitForProducts: Receive = {
case products: Products => context become work(products)
}
def work(products: Products): Receive = {
case Calculate => sender ! promotions.price(products)
}
}

13. class ConfigurablePriceCalculator(user: User, shopId: ShopId,
findShop: ShopId => Future[Shop],
findBasket: (User, Shop) => Future[Basket],
findPromotions: Shop => Future[Promotions],
basketKeeper: ActorRef) extends Actor {
private var promotions: Promotions = _
override def preStart(): Unit = {
super.preStart()
for {
shop <- findShop(shopId)
basket <- findBasket(user, shop)
promo <- findPromotions(shop)
} yield {
promotions = promo
self ! basket
}
}
override def receive: Receive = waitForBasket
def waitForBasket: Receive = {
case basket: Basket =>
basketKeeper ! AskForProducts(basket)
context become waitForProducts
}
def waitForProducts: Receive = {
case products: Products => context become work(products)
}
def work(products: Products): Receive = {
case Calculate => sender ! promotions.price(products)
}
}

14. class ConfigurablePriceCalculator(user: User, shopId: ShopId,
findShop: ShopId => Future[Shop],
findBasket: (User, Shop) => Future[Basket],
findPromotions: Shop => Future[Promotions],
basketKeeper: ActorRef) extends Actor {
private var promotions: Promotions = _
override def preStart(): Unit = {
super.preStart()
for {
shop <- findShop(shopId)
basket <- findBasket(user, shop)
promo <- findPromotions(shop)
} yield {
promotions = promo
self ! basket
}
}
override def receive: Receive = waitForBasket
def waitForBasket: Receive = {
case basket: Basket =>
basketKeeper ! AskForProducts(basket)
context become waitForProducts
}
def waitForProducts: Receive = {
case products: Products => context become work(products)
}
def work(products: Products): Receive = {
case Calculate => sender ! promotions.price(products)
}
}

15. class ConfigurablePriceCalculator(user: User, shopId: ShopId,
findShop: ShopId => Future[Shop],
findBasket: (User, Shop) => Future[Basket],
findPromotions: Shop => Future[Promotions],
basketKeeper: ActorRef) extends Actor {
private var promotions: Promotions = _
override def preStart(): Unit = {
super.preStart()
for {
shop <- findShop(shopId)
basket <- findBasket(user, shop)
promo <- findPromotions(shop)
} yield {
promotions = promo
self ! basket
}
}
override def receive: Receive = waitForBasket
def waitForBasket: Receive = {
case basket: Basket =>
basketKeeper ! AskForProducts(basket)
context become waitForProducts
}
def waitForProducts: Receive = {
case products: Products => context become work(products)
}
def work(products: Products): Receive = {
case Calculate => sender ! promotions.price(products)
}
}

16. class PriceCalculator(products: Products, promotions: Promotions) extends Actor {
override def receive: Receive = {
case Calculate => sender ! promotions.price(products)
}
}
Desired actor

17. Refactoring out
dependencies
for {
shop <- findShop(shopId)
basket <- findBasket(user, shop)
promotions <- findPromotions(shop)
products <- (basketKeeper ? AskForProducts(basket))
.mapTo[Products]
} yield PriceCalculator.props(products, promotions)

18. Introducing proxy to create
actor immediately
ProxyProps(for {
shop <- findShop(shopId)
basket <- findBasket(user, shop)
promotions <- findPromotions(shop)
products <- (basketKeeper ? AskForProducts(basket))
.mapTo[Products]
} yield PriceCalculator.props(products, promotions))

19. Introducing proxy to create
actor immediately
ProxyProps(for {
shop <- findShop(shopId)
basket <- findBasket(user, shop)
promotions <- findPromotions(shop)
products <- (basketKeeper ? AskForProducts(basket))
.mapTo[Products]
} yield PriceCalculator.props(products, promotions))
monadic futures

20. Introducing proxy to create
actor immediately
ProxyProps(for {
shop <- findShop(shopId)
basket <- findBasket(user, shop)
promotions <- findPromotions(shop)
products <- (basketKeeper ? AskForProducts(basket))
.mapTo[Products]
} yield PriceCalculator.props(products, promotions))

21. Let’s imagine better API
ProxyProps(for {
shop <- findShop(shopId)
basket <- findBasket(user, shop)
promotions <- findPromotions(shop)
products <- (basketKeeper ? AskForProducts(basket))
.mapTo[Products]
} yield PriceCalculator.props(products, promotions))

22. Let’s imagine better API
ProxyProps(PriceCalculator.props)(Dependencies()
.given(shopId).given(user)
.requires(findShop)
.requires(findBasket)
.requires(findPromotions)
.requires(basketKeeper,
AskForProducts(_),
classOf[Products]))

23. Let’s imagine better API
ProxyProps(PriceCalculator.props)(Dependencies()
.given(shopId).given(user)
.requires(FutureDependency(findShop))
.requires(FutureDependency(findBasket))
.requires(FutureDependency(findPromotions))
.requires(ActorDependency(basketKeeper,
AskForProducts(_),
classOf[Products])))

24. Let’s imagine better API
val shopDependency = FutureDependency(findShop)
val basketDependency = FutureDependency(findBasket)
val promotionsDependency = FutureDependency(findPromotions)
val productsDependency = ActorDependency(basketKeeper,
AskForProducts(_),
classOf[Products])
ProxyProps(PriceCalculator.props)(Dependencies()
.given(shopId).given(user)
.requires(shopDependency)
.requires(basketDependency)
.requires(promotionsDependency)
.requires(productsDependency))

25. What should we expect?
• Checking availability of dependencies in
compile time
• Efficient composition of futures

26. Defining types
val shopDependency = FutureDependency(findShop)
val basketDependency = FutureDependency(findBasket)
val promotionsDependency = FutureDependency(findPromotions)
val productsDependency = ActorDependency(basketKeeper,
AskForProducts(_),
classOf[Products])
ProxyProps(PriceCalculator.props)(Dependencies()
.given(shopId).given(user)
.requires(shopDependency)
.requires(basketDependency)
.requires(promotionsDependency)
.requires(productsDependency))

27. Defining types
val shopDependency = FutureDependency(findShop)
val basketDependency = FutureDependency(findBasket)
val promotionsDependency = FutureDependency(findPromotions)
val productsDependency = ActorDependency(basketKeeper,
AskForProducts(_),
classOf[Products])
ProxyProps(PriceCalculator.props)(Dependencies()
.given(shopId).given(user)
.requires(shopDependency)
.requires(basketDependency)
.requires(promotionsDependency)
.requires(productsDependency))
()

28. Defining types
val shopDependency = FutureDependency(findShop)
val basketDependency = FutureDependency(findBasket)
val promotionsDependency = FutureDependency(findPromotions)
val productsDependency = ActorDependency(basketKeeper,
AskForProducts(_),
classOf[Products])
ProxyProps(PriceCalculator.props)(Dependencies()
.given(shopId).given(user)
.requires(shopDependency)
.requires(basketDependency)
.requires(promotionsDependency)
.requires(productsDependency))
()
(ShopId)

29. Defining types
val shopDependency = FutureDependency(findShop)
val basketDependency = FutureDependency(findBasket)
val promotionsDependency = FutureDependency(findPromotions)
val productsDependency = ActorDependency(basketKeeper,
AskForProducts(_),
classOf[Products])
ProxyProps(PriceCalculator.props)(Dependencies()
.given(shopId).given(user)
.requires(shopDependency)
.requires(basketDependency)
.requires(promotionsDependency)
.requires(productsDependency))
()
(ShopId, User)

30. Defining types
val shopDependency = FutureDependency(findShop)
val basketDependency = FutureDependency(findBasket)
val promotionsDependency = FutureDependency(findPromotions)
val productsDependency = ActorDependency(basketKeeper,
AskForProducts(_),
classOf[Products])
ProxyProps(PriceCalculator.props)(Dependencies()
.given(shopId).given(user)
.requires(shopDependency)
.requires(basketDependency)
.requires(promotionsDependency)
.requires(productsDependency))
()
(ShopId, User)
(ShopId, User, Shop)

31. Defining types
val shopDependency = FutureDependency(findShop)
val basketDependency = FutureDependency(findBasket)
val promotionsDependency = FutureDependency(findPromotions)
val productsDependency = ActorDependency(basketKeeper,
AskForProducts(_),
classOf[Products])
ProxyProps(PriceCalculator.props)(Dependencies()
.given(shopId).given(user)
.requires(shopDependency)
.requires(basketDependency)
.requires(promotionsDependency)
.requires(productsDependency))
()
(ShopId, User)
(ShopId, User, Shop)
(ShopId, User, Shop, Basket)
(ShopId, User, Shop, Basket, Promotions)
(ShopId, User, Shop, Basket, Promotions, Products)

32. Introducing Shapeless -
heterogenous lists
val hList = 1 :: "text" :: List(1, 2, 3) :: HNil

33. The basic concept -
heterogenous lists
val hList = 1 :: "text" :: List(1, 2, 3) :: HNil
val num: Int = hList.head

34. The basic concept -
heterogenous lists
val hList = 1 :: "text" :: List(1, 2, 3) :: HNil
val num: Int = hList.head

35. The basic concept -
heterogenous lists
val hList = 1 :: "text" :: List(1, 2, 3) :: HNil
val num: Int = hList.head
val text: String = hList.tail.head

36. The basic concept -
heterogenous lists
val hList = 1 :: "text" :: List(1, 2, 3) :: HNil
val num: Int = hList.head
val text: String = hList.tail.head

37. The basic concept -
heterogenous lists
val hList = 1 :: "text" :: List(1, 2, 3) :: HNil
val num: Int = hList.head
val text: String = hList.tail.head
val numList: List[Int] = hList.tail.tail.head

38. The basic concept -
heterogenous lists
val hList = 1 :: "text" :: List(1, 2, 3) :: HNil
val num: Int = hList.head
val text: String = hList.tail.head
val numList: List[Int] = hList.tail.tail.head
hList.tail.tail.tail.head

39. Recursive type definition
sealed trait HList extends Product with Serializable
final case class ::[+H, +T <: HList](head : H, tail : T) extends HList {
override def toString = head+" :: "+tail.toString
}
sealed trait HNil extends HList {
def ::[H](h : H) = shapeless.::(h, this)
override def toString = "HNil"
}
case object HNil extends HNil

40.
val hList: ::[Int, ::[String, ::[List[Int], HNil]]] =
1 :: "text" :: List(1, 2, 3) :: HNil
val hList: Int :: String :: List[Int] :: HNil =
1 :: "text" :: List(1, 2, 3) :: HNil

41. Defining types
val shopDependency = FutureDependency(findShop)
val basketDependency = FutureDependency(findBasket)
val promotionsDependency = FutureDependency(findPromotions)
val productsDependency = ActorDependency(basketKeeper,
AskForProducts(_),
classOf[Products])
ProxyProps(PriceCalculator.props)(Dependencies()
.given(shopId).given(user)
.requires(shopDependency)
.requires(basketDependency)
.requires(promotionsDependency)
.requires(productsDependency))
Dependencies[ShopId :: User :: Shop :: Basket :: Promotions :: Products :: HNil]

42. Defining types
val shopDependency = FutureDependency(findShop)
val basketDependency = FutureDependency(findBasket)
val promotionsDependency = FutureDependency(findPromotions)
val productsDependency = ActorDependency(basketKeeper,
AskForProducts(_),
classOf[Products])
ProxyProps(PriceCalculator.props)(Dependencies()
.given(shopId).given(user)
.requires(shopDependency)
.requires(basketDependency)
.requires(promotionsDependency)
.requires(productsDependency))
Dependencies[ShopId :: User :: Shop :: Basket :: Promotions :: Products :: HNil]
ProxyProps[Promotions :: Products :: HNil]

43. Defining types
val shopDependency = FutureDependency(findShop)
val basketDependency = FutureDependency(findBasket)
val promotionsDependency = FutureDependency(findPromotions)
val productsDependency = ActorDependency(basketKeeper,
AskForProducts(_),
classOf[Products])
val props: Props = ProxyProps(PriceCalculator.props)(Dependencies()
.given(shopId).given(user)
.requires(shopDependency)
.requires(basketDependency)
.requires(promotionsDependency)
.requires(productsDependency))
Dependencies[ShopId :: User :: Shop :: Basket :: Promotions :: Products :: HNil]
ProxyProps[Promotions :: Products :: HNil]

44. Defining types
val shopDependency: FutureDependency[Tuple1[ShopId], Shop] =
FutureDependency(findShop)
val basketDependency: FutureDependency[(User, Shop), Basket] =
FutureDependency(findBasket)
val promotionsDependency: FutureDependency[Tuple1[Shop], Promotions] =
FutureDependency(findPromotions)
val productsDependency: ActorDependency[Tuple1[Basket], Products] =
ActorDependency(basketKeeper, AskForProducts(_), classOf[Products])

45. Defining types
val shopDependency: FutureDependency[Tuple1[ShopId], Shop] =
FutureDependency(findShop)
val basketDependency: FutureDependency[(User, Shop), Basket] =
FutureDependency(findBasket)
val promotionsDependency: FutureDependency[Tuple1[Shop], Promotions] =
FutureDependency(findPromotions)
val productsDependency: FutureDependency[Tuple1[Basket], Products] =
ActorDependency(basketKeeper, AskForProducts(_), classOf[Products])

46. Building computation of
Dependencies
Dependencies()
HNil

47. Building computation of
Dependencies
Dependencies().given(user)
Future[User] :: HNil

48. Building computation of
Dependencies
Dependencies().given(user).given(shopId)
Future[ShopId] :: Future[User] :: HNil

49. Building computation of
Dependencies
Dependencies().given(user).given(shopId)
.requires(shopDependency)
Future[ShopId] :: Future[User] :: HNil
FutureDependency[Tuple1[ShopId], Shop]

50. Building computation of
Dependencies
Dependencies().given(user).given(shopId)
.requires(shopDependency)
Future[ShopId] :: Future[User] :: HNil
FutureDependency[Tuple1[ShopId], Shop]

51. Building computation of
Dependencies
Dependencies().given(user).given(shopId)
.requires(shopDependency)
Future[ShopId] :: Future[User] :: HNil
FutureDependency[Tuple1[ShopId], Shop]
Shapeless allows to use tuple (ShopId) as ShopId :: HNil

52. Building computation of
Dependencies
Dependencies().given(user).given(shopId)
.requires(shopDependency)
Future[ShopId] :: Future[User] :: HNil
FutureDependency[Tuple1[ShopId], Shop]
Shapeless allows to use tuple (ShopId) as ShopId :: HNil
Shop mustn't be present in dependencies

53. Building computation of
Dependencies
Dependencies().given(user).given(shopId)
.requires(shopDependency)
Future[ShopId] :: Future[User] :: HNil
FutureDependency[Tuple1[ShopId], Shop]
Shapeless allows to use tuple (ShopId) as ShopId :: HNil
Shop mustn't be present in dependencies
Future[ShopId] must be found in dependencies

54. Building computation of
Dependencies
Dependencies().given(user).given(shopId)
.requires(shopDependency)
Future[Shop] :: Future[ShopId] :: Future[User] :: HNil
FutureDependency[Tuple1[ShopId], Shop]
Shapeless allows to use tuple (ShopId) as ShopId :: HNil
Shop mustn't be present in dependencies
Future[ShopId] must be found in dependencies

55. Building computation of
Dependencies
Dependencies().given(user).given(shopId)
.requires(shopDependency)
.requires(basketDependency)
Future[Shop] :: Future[ShopId] :: Future[User] :: HNil
FutureDependency[(User, Shop), Basket]

56. Building computation of
Dependencies
Dependencies().given(user).given(shopId)
.requires(shopDependency)
.requires(basketDependency)
Future[Shop] :: Future[ShopId] :: Future[User] :: HNil
FutureDependency[(User, Shop), Basket]
Future[User] :: Future[Shop] :: HNil

57. Building computation of
Dependencies
Dependencies().given(user).given(shopId)
.requires(shopDependency)
.requires(basketDependency)
Future[Shop] :: Future[ShopId] :: Future[User] :: HNil
FutureDependency[(User, Shop), Basket]
Future[User] :: Future[Shop] :: HNil => Future[User :: Shop :: HNil]

58. Building computation of
Dependencies
Dependencies().given(user).given(shopId)
.requires(shopDependency)
.requires(basketDependency)
Future[Basket] :: Future[Shop] :: Future[ShopId] :: Future[User] :: HNil
FutureDependency[(User, Shop), Basket]

59. Building computation of
Dependencies
Dependencies().given(user).given(shopId)
.requires(shopDependency)
.requires(basketDependency)
.requires(promotionsDependency)
Future[Basket] :: Future[Shop] :: Future[ShopId] :: Future[User] :: HNil
FutureDependency[Tuple1[Shop], Promotions]

60. Building computation of
Dependencies
Dependencies().given(user).given(shopId)
.requires(shopDependency)
.requires(basketDependency)
.requires(promotionsDependency)
Future[Basket] :: Future[Shop] :: Future[ShopId] :: Future[User] :: HNil
FutureDependency[Tuple1[Shop], Promotions]

61. Building computation of
Dependencies
Dependencies().given(user).given(shopId)
.requires(shopDependency)
.requires(basketDependency)
.requires(promotionsDependency)
Future[Promotions] :: Future[Basket] :: Future[Shop] :: Future[ShopId] ::
Future[User] :: HNil
FutureDependency[Tuple1[Shop], Promotions]

62. Building computation of
Dependencies
Dependencies().given(user).given(shopId)
.requires(shopDependency)
.requires(basketDependency)
.requires(promotionsDependency)
.requires(productsDependency)
Future[Promotions] :: Future[Basket] :: Future[Shop] :: Future[ShopId] ::
Future[User] :: HNil
FutureDependency[Tuple1[Basket], Products]

63. Building computation of
Dependencies
Dependencies().given(user).given(shopId)
.requires(shopDependency)
.requires(basketDependency)
.requires(promotionsDependency)
.requires(productsDependency)
Future[Products] :: Future[Promotions] :: Future[Basket] :: Future[Shop] ::
Future[ShopId] :: Future[User] :: HNil
FutureDependency[Tuple1[Basket], Products]

64. Starting proxy actor with
Dependencies
val dependencies: Dependencies[Future[Products] :: Future[Promotions] ::
Future[Basket] :: Future[Shop] :: Future[ShopId] :: Future[User] :: HNil]

65. Starting proxy actor with
Dependencies
val dependencies: Dependencies[Future[Products] :: Future[Promotions] ::
Future[Basket] :: Future[Shop] :: Future[ShopId] :: Future[User] :: HNil]
val proxyProps = ProxyProps(PriceCalculator.props)

66. Starting proxy actor with
Dependencies
val dependencies: Dependencies[Future[Products] :: Future[Promotions] ::
Future[Basket] :: Future[Shop] :: Future[ShopId] :: Future[User] :: HNil]
val proxyProps: ProxyProps[Promotions :: Products :: HNil] =
ProxyProps(PriceCalculator.props)

67. Starting proxy actor with
Dependencies
val dependencies: Dependencies[Future[Products] :: Future[Promotions] ::
Future[Basket] :: Future[Shop] :: Future[ShopId] :: Future[User] :: HNil]
val proxyProps: ProxyProps[Promotions :: Products :: HNil] =
ProxyProps(PriceCalculator.props)
proxyProps(dependencies)

68. Starting proxy actor with
Dependencies
val dependencies: Dependencies[Future[Products] :: Future[Promotions] ::
Future[Basket] :: Future[Shop] :: Future[ShopId] :: Future[User] :: HNil]
val proxyProps: ProxyProps[Promotions :: Products :: HNil] =
ProxyProps(PriceCalculator.props)
proxyProps(dependencies)

69. Starting proxy actor with
Dependencies
val dependencies: Dependencies[Future[Products] :: Future[Promotions] ::
Future[Basket] :: Future[Shop] :: Future[ShopId] :: Future[User] :: HNil]
val proxyProps: ProxyProps[Promotions :: Products :: HNil] =
ProxyProps(PriceCalculator.props)
val props: Props = proxyProps(dependencies)

70. Starting proxy actor with
Dependencies
val dependencies: Dependencies[Future[Products] :: Future[Promotions] ::
Future[Basket] :: Future[Shop] :: Future[ShopId] :: Future[User] :: HNil]
val proxyProps: ProxyProps[Promotions :: Products :: HNil] =
ProxyProps(PriceCalculator.props)
val props: Props = proxyProps(dependencies)
context.actorOf(props)

71. Proxy behaviour
• runs all dependencies as one Future
• creates target actor once Future completes
• can retry running dependencies Future
• can re-run dependencies once target actor
terminates

72. Benefits of using Shapeless
• Clear and concise API
• Reusable dependencies definitions
• Efficient asynchronous computation - composing
futures
• Compiler ensures presence of all required
dependencies

73. Explaining Shapeless

74. Recursive implicit lookup
trait NotIn[T, L <: HList]
object NotIn {
implicit def notInHNil[T] = new NotIn[T, HNil] {}
implicit def notInList[H, T, L <: HList](implicit tIsNotH: <:!<[T, H],
hIsNotT: <:!<[H, T],
notInTail: NotIn[T, L]) =
new NotIn[T, H :: L] {}
}

75. Recursive implicit lookup
trait NotIn[T, L <: HList]
object NotIn {
implicit def notInHNil[T] = new NotIn[T, HNil] {}
implicit def notInList[H, T, L <: HList](implicit tIsNotH: <:!<[T, H],
hIsNotT: <:!<[H, T],
notInTail: NotIn[T, L]) =
new NotIn[T, H :: L] {}
}

76. Usage of recursive implicit
def addUnique[In <: HList, T](in: In, t: T)(implicit unique: NotIn[T, In]) =
t :: in

77. Usage of recursive implicit
def addUnique[In <: HList, T](in: In, t: T)(implicit unique: NotIn[T, In]) =
t :: in
addUnique(1 :: "txt" :: HNil, true)
addUnique(1 :: "txt" :: HNil, 2)

78. Usage of recursive implicit
def addUnique[In <: HList, T](in: In, t: T)(implicit unique: NotIn[T, In]) =
t :: in
addUnique(1 :: "txt" :: HNil, true)

79. Usage of recursive implicit
def addUnique[In <: HList, T](in: In, t: T)(implicit unique: NotIn[T, In]) =
t :: in
addUnique(1 :: "txt" :: HNil, true)
implicit NotIn[Boolean, Int :: String :: HNil]
?

80. Usage of recursive implicit
def addUnique[In <: HList, T](in: In, t: T)(implicit unique: NotIn[T, In]) =
t :: in
addUnique(1 :: "txt" :: HNil, true)
implicit NotIn[Boolean, Int :: String :: HNil]
?

81. Usage of recursive implicit
def addUnique[In <: HList, T](in: In, t: T)(implicit unique: NotIn[T, In]) =
t :: in
addUnique(1 :: "txt" :: HNil, true)
implicit NotIn[Boolean, Int :: String :: HNil]
implicit NotIn[Boolean, String :: HNil]
?
?

82. Usage of recursive implicit
def addUnique[In <: HList, T](in: In, t: T)(implicit unique: NotIn[T, In]) =
t :: in
addUnique(1 :: "txt" :: HNil, true)
implicit NotIn[Boolean, Int :: String :: HNil]
implicit NotIn[Boolean, String :: HNil]
?
?

83. Usage of recursive implicit
def addUnique[In <: HList, T](in: In, t: T)(implicit unique: NotIn[T, In]) =
t :: in
addUnique(1 :: "txt" :: HNil, true)
implicit NotIn[Boolean, Int :: String :: HNil]
implicit NotIn[Boolean, String :: HNil]
implicit NotIn[Boolean, HNil]
?
?
?

84. Usage of recursive implicit
def addUnique[In <: HList, T](in: In, t: T)(implicit unique: NotIn[T, In]) =
t :: in
addUnique(1 :: "txt" :: HNil, true)
implicit NotIn[Boolean, Int :: String :: HNil]
implicit NotIn[Boolean, String :: HNil]
implicit NotIn[Boolean, HNil]
?
?

85. Usage of recursive implicit
def addUnique[In <: HList, T](in: In, t: T)(implicit unique: NotIn[T, In]) =
t :: in
addUnique(1 :: "txt" :: HNil, true)
implicit NotIn[Boolean, Int :: String :: HNil]
implicit NotIn[Boolean, String :: HNil]
implicit NotIn[Boolean, HNil]
?

86. Usage of recursive implicit
def addUnique[In <: HList, T](in: In, t: T)(implicit unique: NotIn[T, In]) =
t :: in
addUnique(1 :: "txt" :: HNil, true)
implicit NotIn[Boolean, Int :: String :: HNil]
implicit NotIn[Boolean, String :: HNil]
implicit NotIn[Boolean, HNil]

87. Implicits usage in Shapeless
• Stating facts about types
• Often recursive:
• stop condition
• general condition
• Compiler finds implicit recursively
• Value resolved implicitly may have some functions -
the functions can do something useful for given types

88. More useful operations on
HList
val hList = 1 :: "text" :: List(1, 2, 3) :: HNil
val (removed: String :: Int :: HNil, rest: List[Int] :: HNil) =
hList.removeAll[String :: Int :: HNil]

89. More useful operations on
HList
val hList = 1 :: "text" :: List(1, 2, 3) :: HNil
val (removed: String :: Int :: HNil, rest: List[Int] :: HNil) =
hList.removeAll[String :: Int :: HNil]

90. More useful operations on
HList
val hList = 1 :: "text" :: List(1, 2, 3) :: HNil
val (removed: String :: Int :: HNil, rest: List[Int] :: HNil) =
hList.removeAll[String :: Int :: HNil]

91. More useful operations on
HList
val hList = 1 :: "text" :: List(1, 2, 3) :: HNil
val (removed: String :: Int :: HNil, rest: List[Int] :: HNil) =
hList.removeAll[String :: Int :: HNil]
def removeAll[SL <: HList](implicit removeAll : RemoveAll[L, SL])
: removeAll.Out = removeAll(l)

92. More useful operations on
HList
val hList = 1 :: "text" :: List(1, 2, 3) :: HNil
val (removed: String :: Int :: HNil, rest: List[Int] :: HNil) =
hList.removeAll[String :: Int :: HNil]
def removeAll[SL <: HList](implicit removeAll : RemoveAll[L, SL])
: removeAll.Out = removeAll(l)
trait RemoveAll[L <: HList, SL <: HList] {
type Out
def apply(t: L): Out
}

93. Recap
val shopDependency = FutureDependency(findShop)
val basketDependency = FutureDependency(findBasket)
val promotionsDependency = FutureDependency(findPromotions)
val productsDependency = ActorDependency(basketKeeper,
AskForProducts(_),
classOf[Products])
val props = ProxyProps(PriceCalculator.props)(Dependencies()
.given(shopId)
.given(user)
.requires(shopDependency)
.requires(basketDependency)
.requires(promotionsDependency)
.requires(productsDependency))
context.actorOf(props)

94. Declarative and functional
asynchronous dependencies
val shopDependency = FutureDependency(findShop)
val basketDependency = FutureDependency(findBasket)
val promotionsDependency = FutureDependency(findPromotions)
val productsDependency = ActorDependency(basketKeeper,
AskForProducts(_),
classOf[Products])
val props = ProxyProps(PriceCalculator.props)(Dependencies()
.given(shopId)
.given(user)
.requires(shopDependency)
.requires(basketDependency)
.requires(promotionsDependency)
.requires(productsDependency))
context.actorOf(props)

95. Type driven composition
val shopDependency = FutureDependency(findShop)
val basketDependency = FutureDependency(findBasket)
val promotionsDependency = FutureDependency(findPromotions)
val productsDependency = ActorDependency(basketKeeper,
AskForProducts(_),
classOf[Products])
val props = ProxyProps(PriceCalculator.props)(Dependencies()
.given(shopId)
.given(user)
.requires(shopDependency)
.requires(basketDependency)
.requires(promotionsDependency)
.requires(productsDependency))
context.actorOf(props)

96. Seamless futures
composition
val shopDependency = FutureDependency(findShop)
val basketDependency = FutureDependency(findBasket)
val promotionsDependency = FutureDependency(findPromotions)
val productsDependency = ActorDependency(basketKeeper,
AskForProducts(_),
classOf[Products])
val props = ProxyProps(PriceCalculator.props)(Dependencies()
.given(shopId)
.given(user)
.requires(shopDependency)
.requires(basketDependency)
.requires(promotionsDependency)
.requires(productsDependency))
context.actorOf(props)

97. Compile time checking
val shopDependency = FutureDependency(findShop)
val basketDependency = FutureDependency(findBasket)
val promotionsDependency = FutureDependency(findPromotions)
val productsDependency = ActorDependency(basketKeeper,
AskForProducts(_),
classOf[Products])
val props = ProxyProps(PriceCalculator.props)(Dependencies()
.given(shopId)
.given(user)
.requires(shopDependency)
.requires(basketDependency)
.requires(promotionsDependency)
.requires(productsDependency))
context.actorOf(props)

98. Less boilerplate
class
findShop: ShopId => Future[Shop],
findBasket: (User, Shop) => Future[Basket],
findPromotions: Shop => Future[Promotions],
basketKeeper: ActorRef)
private var
override def
super
for
shop <- findShop(shopId)
basket <- findBasket(user, shop)
promo <- findPromotions(shop)
}
}
}
override def
def
case
basketKeeper !
}
def
case
}
def
case
}
}
class PriceCalculator(products: Products, promotions: Promotions) extends Actor {
override def receive: Receive = {
case Calculate => sender ! promotions.price(products)
}
}

99. Thank you
"com.github.wilaszekg" %% "scala-dynamic-di" % "0.0.1"
https://github.com/wilaszekg/Scala-Dynamic-DI