These are the slides I used during the scala meetup at The Telegraph https://www.meetup.com/it-IT/Scala-Central/events/239750331/

1. Expression Problem
Giuseppe Scopelliti
Platform Engineer | @peppescopellit1

2. Agenda
➢ Introduction
➢ Set up a use case
➢ Proposed solution
➢ Talk about pros and cons
➢ Q/A

3. Introduction 1/2
The expression problem is one in which the challenge
is:
➢ Define a data type with cases.
➢ Add new cases of the type, and operations for the
types.
➢ Avoid recompiling.

4. Introduction 2/2
Any implementation of the expression problem should
satisfy the following requirements:
➢ Extensibility in both dimensions.
➢ Strong static type safety.
➢ No modification of the existing code.
➢ Separate compilation.

5. Use case 1/3
We are using a third party library
case class Employee(name: String, id : Long)
trait Payroll {
def processEmployees(employees: Vector[Employee]): Either[String, Throwable]
}

6. Use case 2/3
We can easily add new types
class USPayroll extends Payroll {
def processEmployees(employees: Vector[Employee]) = Left("US payroll")
}
class JapanPayroll extends Payroll {
def processEmployees(employees: Vector[Employee]) = Left("Japan payroll")
}

7. Use case 3/3
What if we need to add new operations on the types?
E.g. Deal with Contractors
trait ExtendedPayroll extends Payroll {
def processEmployees(employees: Vector[Employee]): Either[String, Throwable]
def processContractors(contractors: Vector[Contractor]): Either[String, Throwable]
}

8. In summary
OP
TYPE

9. This is a practical problem
How to add features to an
existing system
incrementally without
doing modifications?

10. Proposed solution
➔ Leverage scala traits and abstract type members to
solve the expression problem.
➔ Rewrite the same payroll system, so you can easily
add new operations to it, without breaking type-
safety, and at the same time add a new type.

11. Some Code 1/5The new payroll system will be:
trait PayrollSystem {
case class Employee(name: String, id: Long)
type P <: Payroll
trait Payroll {
def processEmployees(employees: Vector[Employee]): Either[String, Throwable]
}
def processPayroll(p: P): Either[String, Throwable]
}
// You nest everything inside a trait so that you can treat it as a module.
// The type P denotes some subtype of the Payroll trait,
// which declares an abstract method to process salaries for employees.
// The processPayroll method needs to be implemented to process payrolls for a
// given Payroll type.

12. Some Code 2/5We can still easily add a new type
trait USPayrollSystem extends PayrollSystem {
class USPayroll extends Payroll {
def processEmployees(employees: Vector[Employee]) = {
println("US payroll")
Left("US payroll")
}
}
}
PayrollSystem
USPayrollSystem

13. Some Code 3/5What about a new operation ?
trait ContractorPayrollSystem extends PayrollSystem {
case class Contractor(name: String)
//Shadowing the Payroll trait defined in PayrollSystem
trait Payroll extends super.Payroll {
def processContractors(contractors: Vector[Contractor]): Either[String,
Throwable]
}
}
PayrollSystem
USPayrollSystem
ContractorPayrollSystem

14. Some Code 4/5And ...
trait USContractorPayrollSystem extends USPayrollSystem with ContractorPayrollSystem
{
//We are shadowing the former definition of USPayroll.
class USPayroll extends super.USPayroll with Payroll {
def processContractors(contractors: Vector[Contractor]) = {
println("US contract payroll")
Left("US contract payroll")
}
}
}
PayrollSystem
USPayrollSystem
ContractorPayrollSystem
USContractorPayrollSystem

15. Some Code 5/5Finally ...
object USEmployeeAndContractorPayroll extends USContractorPayrollSystem {
type P = USPayroll
def processPayroll(p: USPayroll): Either[String, Throwable] = {
p.processEmployees(Vector(Employee("a", 1)))
p.processContractors(Vector(Contractor("b")))
Left("payroll processed successfully")
}
}

16. Proposed solution
This was a good example to demonstrate:
– The power of Scala’s type system
– The abstraction available to build scalable and
extensible components

17. We achieved a solution
OP
TYPE

18. Pros And Cons
– Inside the context, shadowing let you extend the old
definition, without overriding it.
– Shadowing can introduce unintended errors in your
code.

19. Thanks for listening!
Any Questions?

20. Some resources to get more details
❖ http://www.scala-lang.org/docu/files/TheExpressionProblem.pdf
❖ https://news.ycombinator.com/item?id=11683379
❖ http://fileadmin.cs.lth.se/sde/people/gorel/misc/ExpProblemTalkPart1.
pdf
❖ http://lambda-the-ultimate.org/node/3141
❖ https://prezi.com/wwqo9dtgqhs2/comparing-solutions-to-the-
expression-problem-in-scala-and-r/