Domain Specific Languages

Size: px

Start display at page:

Download "Domain Specific Languages"

Kristopher Pearson
6 years ago
Views:

1 Domain Specific Languages Programming in Scala (MI-PSL) - 13 Ing. Jiří Daněček Department of Software EngineeringFaculty of Information Technology CTU in Prague Evropský sociální fond Praha & EU: Investujeme do vaší budoucnosti

Domain-Specific Language A Domain-Specific Language is a programming language that mimics the terms, idioms, and expressions used among experts in the targeted domain.

2 Domain-Specific Language A Domain-Specific Language is a programming language that mimics the terms, idioms, and expressions used among experts in the targeted domain. Code written in a DSL reads like structured prose for the domain. Ideally, a domain expert with little experience in programming can read, understand, and validate this code. DSLs are classified: internal (embedded) is an idiomatic way of writing code in a general-purpose programming language. They are parsed just like any other code written in the language. external DSL is a custom language with its own custom grammar and parser. Interest in DSLs has surged recently, driven in part by the Ruby community, because they are very easy to implement in Ruby. Scala provides excellent support for the creation of internal and external DSLs.

3 DSLs benefits Well-crafted DSLs offer several benefits: Encapsulation - A DSL hides implementation details and exposes only those abstractions relevant to the domain. Efficiency - Because implementation details are encapsulated, a DSL optimizes the effort required to write or modify code for application features. Communication - A DSL helps developers understand the domain and domain experts to verify that the implementation meets the requirements. Quality - A DSL minimizes the impedance mismatch between feature requirements, as expressed by domain experts, and the implementing source code, thereby minimizing potential bugs.

4 DSLs drawbacks Good DSLs are harder to design than traditional APIs. The latter tend to follow language idioms for API design, where uniformity is important. Even then, elegant, effective, and easy-to-use APIs are difficult to design. In contrast, each DSL should reflect the unique language idioms of its domain. The DSL designer has much greater latitude, which also means it is much harder to determine the best design choices. Long-term maintenance DSLs can require more maintenance over the long term to factor in domain changes. Also, new developers will require more time to learn how to use and maintain a DSL. However, when a DSL is appropriate for an application e.g., when it would be used frequently to implement and change functionality a welldesigned DSL can be a powerful tool for building flexible and robust applications.

5 Payroll Application Example Payroll application computes an employee s paycheck every pay period (two weeks). The paycheck will include the employee s: salary: package payroll case class Paycheck( gross: Money, net: Money, deductions: Money) { def plusgross (m: Money) = Paycheck(gross + m, net + m, deductions) def p The Employee type uses a Name type: package payroll case class Name(first: String, last: String) case class Employee(name: Name, annualgrosssalary: Money)

6 Clasic Solution import payroll.api._ import payroll.api.deductionscalculator._ import payroll._ import payroll.type2money._ val buck = Employee(Name("Buck", "Trends"), Money(80000)) val jane = Employee(Name("Jane", "Doe"), Money(90000)) List(buck, jane).foreach { employee => val biweeklygross = employee.annualgrosssalary / 26. val deductions = federalincometax( employee, biweeklygross) + stateincometax(employee, biweeklygross) + insurancepremiums(employee, biweeklygross) + retirementfundcontributions(employee, biweeklygross) val check = Paycheck(biweeklyGross, biweeklygross - deductions, deductions) format("%s %s: %s\n", employee.name.first, employee.name.last, check)

7 Drawbacks of Clasic Solution Clasic solution is: noisy - for example, it mentions employee and biweeklygross incessantly. A DSL will help us minimize that noise and focus on what s really going on. imperative. It says divide this, add that, and so forth. We ll see that our DSLs look similar, but they are more declarative, hiding the work from the user.

8 Class Money package payroll import java.math.{bigdecimal => JBigDecimal, MathContext => JMathContext, RoundingMode => JRoundingMode class Money(val amount: BigDecimal) { def + (m: Money) = Money(amount.bigDecimal.add(m.amount.bigDecimal))... def > (m: Money) = amount > m.amount override def equals (o: Any) = o match { case m: Money => amount equals m.amount case _ => false override def hashcode = amount.hashcode * 31 // Hack: Must explicitly call the correct conversion: double2double override def tostring = String.format("$%.2f", double2double(amount.doublevalue))

9 Class DeductionsCal cu lator Deductions by DeductionsCal cu lator: package payroll.api import payroll.type2money._ object DeductionsCalculator { def federalincometax(empl: Employee, gross: Money) = gross *.25 def stateincometax(empl: Employee, gross: Money) = gross *.05 def insurancepremiums(empl: Employee, gross: Money) = Money(500) def retirementfundcontributions(empl: Employee, gross: Money) = gross *.10

10 Solution in DSL import payroll._ import payroll.dsl._ import payroll.dsl.rules_ val payrollcalculator = rules { employee => employee salary_for 2.weeks minus_deductions_for { gross => federalincometax is (25. percent_of gross) stateincometax is (5. percent_of gross) insurancepremiums are (500. in gross.currency) retirementfundcontributions are ( 10. percent_of gross) val buck = Employee(Name("Buck", "Trends"), Money(80000)) val jane = Employee(Name("Jane", "Doe"), Money(90000)) List(buck, jane).foreach { employee => val check = payrollcalculator(employee) format("%s %s: %s\n", employee.name.first, employee.name.last, check)

11 Infix Operator Notation User-Defined Types Implicit Conversions Apply Methods Scala support for DSL

12 Infix Operator Notation The infix notation:consider this line in the definition of payrollcalculator: employee salary_for 2.weeks minus_deductions_for { gross => This infix notation is equivalent to the following lessreadable form: employee.salary_for(2.weeks).minus_deductions_for { gross => Note: without the period in 2.weeks would be parsed as imployee.salary_for(2).weeks... Each method salary_for, minus_deductions_for returns this so you can continue calling methods on the same instance. Note that returning this allows those method calls to occur in any order.

13 Implicit Conversions Duration is one of the ad hoc types to implement helper methods. It use an implicit conversion to a Duration instance that wraps an Int specifying an amount: package payroll.dsl case class Duration(val amount: Int) { the number of work days in "amount" weeks. */ def weeks = amount * 5 the number of work days in "amount" years. */ def years = amount * 260 The weeks method multiples that amount by 5 to return the corresponding amount of work days. Hence, we designed the payroll calculator to work with days as the unit of time. This decision is completely hidden behind the DSL. Should we later add support for work hours, it would be easy to refactor the design to use hours instead. Duration is one of the ad hoc types that we designed to encapsulate the implicit context, to implement helper methods

14 Payroll Rules DSL Implementation The rules object encapsulates the process of building the rules for payroll calculation. Its apply method takes a function literal: Employee => Paycheck: package payroll.dsl import payroll._ object rules { def apply(rules: Employee => Paycheck) = new PayrollBuilderRules(rules) implicit def int2duration(i: Int) = Duration(i) implicit def employee2grosspaybuilder(e: Employee) = new GrossPayBuilder(e) implicit def grosspaybuilder2deductionsbuilder (b: GrossPayBuilder) = new DeductionsBuilder(b) implicit def double2deductionsbuilderdeductionhelper (d: Double) = new DeductionsBuilderDeductionHelper(d) import rules._...

15 Class PayrollBuilderRules The PayrollBuilderRules evaluates the function literal for the whole rule set, wrapped in a try/catch block: class PayrollException(message: String, cause: Throwable) extends RuntimeException(message, cause) protected[dsl] class PayrollBuilderRules (rules: Employee => Paycheck) { def apply(employee: Employee) = { try { rules(employee) catch { case th: Throwable => new PayrollException( "Failed to process payroll for employee: " + employee, th)...

16 Class GrossPayBuilder GrossPayBuilder initializes the gross and appends new values to it whenever salary_for is called. Finally, salary_for returns this to support chaining: import payroll.type2money._ protected[dsl] class GrossPayBuilder (val employee: Employee) { var gross: Money = 0 def salary_for(days: Int) = { gross += dailygrosssalary(employee.annualgrosssalary) * days this // Assume 260 working days def weeklygrosssalary(annual: Money) = annual / 52.0 def dailygrosssalary(annual: Money) = annual /

17 Class DeductionsBuilder protected[dsl] class DeductionsBuilder( gpb: GrossPayBuilder) { val employee = gpb.employee var paycheck: Paycheck = new Paycheck(gpb.gross, gpb.gross, 0) def currency = this def minus_deductions_for( deductionrules: DeductionsBuilder => Unit) = { deductionrules(this) paycheck def adddeductions(amount: Money) = paycheck = paycheck plusdeductions amount def adddeductionspercentageofgross( percentage: Double) = { val amount = paycheck.gross * (percentage/100.) adddeductions(amount) DeductionsBuilder saves the employee from the passed-in

18 Remaining two methods are used to calculate individual deductions: class DeductionCalculator { def is(builder: DeductionsBuilder) = apply(builder) def are(builder: DeductionsBuilder) = apply(builder) def apply(builder: DeductionsBuilder) = { The synonym methods is and are delegate to apply, they are effectively bubble words that the user could omit. That is, the following two DSL lines are equivalent: federalincometax is (25. percent_of gross) federalincometax(25. percent_of gross) The apply method takes DeductionsBuilder and does nothing with it! In fact, by the time apply is called, the deduction has already been calculated and factored into the paycheck.

19 DeductionsBuilderDeductionHelper federalincometax, etc. are singleton objects. The presence of expressions like federalincometax is are effectively syntactic sugar: object federalincometax extends DeductionCalculator object stateincometax extends DeductionCalculator object insurancepremiums extends DeductionCalculator object retirementfundcontributions extends DeductionCalculator protected[dsl] class DeductionsBuilderDeductionHelper( val factor: Double) { def in (builder: DeductionsBuilder) = { builder adddeductions Money(factor) builder def percent_of (builder: DeductionsBuilder) = { builder adddeductionspercentageofgross factor builder

20 Implicit Conversions (25. percent_of gross) is equivalent to the following steps: 1. rules.double2deductionsbuilderdeductionhelper(25.) 2. percent_of(deductionsbuilder) 3. gross.adddeductionspercentageofgross(factor)

Scala, Your Next Programming Language

Scala, Your Next Programming Language (or if it is good enough for Twitter, it is good enough for me) WORLDCOMP 2011 By Dr. Mark C. Lewis Trinity University Disclaimer I am writing a Scala textbook that