This document discusses two Scala features - implicit conversion and implicit parameters - and how they can be used to implicitly pass context between functions. It describes how implicit parameters allow values to be implicitly provided to functions when they are not explicitly passed as arguments. Implicit conversion allows types that are not directly assignable to be converted between via an implicit conversion method. The document provides examples of how implicits can be used for DSLs, type conversions, and implicitly passing context. It also discusses self-type annotations and how they declare dependencies between types. Finally, it covers the Cake pattern for dependency injection and modularization of components in Scala.

1. Expressing The Context
A functional way
Rodrigo Gómez de Agüero
SUGAR - Scala MeetUp
Agosto 2017

2. Two Scala features
● Implicit Conversion & Implicit Parameters
● Self-type annotation

3. The Context is...
“The parts of something written or spoken that
immediately precede and follow a word or
passage and clarify its meaning.”

4. What surrounds us
● The current configuration
● The current user
● Environment (Dev, QA, Prod, etc)
● Security Level
● Etc.

5. Expressing the Context
● Global variables
● Monkey Patch
● Dependency Injection
● Cake Pattern

6. The Functional Way
“Parametrize all”
● No Side-effect
● Type-Safe
● Grained Control

7. But too many parameters
is tedious
Leave some of them implicit.

8. Implicits
● Improve the semantics on APIs
● It allows to create designs more robust and
elegant.

9. Implicit Parameters
● When an implicit parameter don’t have an
argument, then the compiler tries to find a
value for that parameter.
● If more than one exists, chooses the more
specific one.
● If candidates are not uniques, an ambiguity
error is thrown.

10. Implicit Conversion
● If exists an expression where the Types are
not assignable, the compiler tries to find an
implicit method that make the conversion.
● The search rule is the same as for implicit
parameters.

11. Use Case: DSL

12. Use Case: Type Conversion

13. Use Case: Passing Context

14. Self-Type Annotation
● Declare dependencies between Types
● A self-type is a way to narrow the type of this
or another identifier that aliases this.

15. Self-Type Annotation

16. The Cake Pattern
● A way to modularize components and Inject
Dependencies supported by the language.
● Read the Martin Ordersky paper: Scalable
Components Abstraction
● Is a boilerplate pattern but there are some
variation that minimize the code.

17. The Cake Pattern

18. The Cake Pattern

19. The Cake Pattern with Implicit

20. Thanks!