Model Manipulation Using Embedded DSLs in Scala
1 like1,764 views
The document discusses model manipulation using embedded domain-specific languages (DSLs) in Scala within the context of model-driven engineering. It explores various approaches to model consistency checking, model-to-model, and model-to-text transformations, highlighting the advantages and disadvantages of external vs. embedded DSLs. Additionally, it suggests further developments in deep embedding, formal analysis, and domain-specific error checking to improve efficiency and expressiveness in model manipulation tasks.
![Common Infrastructure Support
• Navigation
• Modification
self.getLibrary().getIsbn() self.library.isbn
self.library.books collect {
case Book(title, Author(author),_,_,_,_) => (title, author)
}
val sicp = Book(name = "SICP", copies = 2)
sicp.author = library.authors find (_.name == "H. Abelson")
with LibraryPackageScalaSupport
• Generate a Scala support trait for each EMF package
• Improving null handling
• Multiplicity 0..1 is wrapped into Option[T]](https://image.slidesharecdn.com/scalaworkshop13extended-130702130513-phpapp02/85/Model-Manipulation-Using-Embedded-DSLs-in-Scala-9-320.jpg)
![Further Work
Domain-Specific error checking
• Using ~ without corresponding rule yields compile time error
@implicitNotFound("No conversion rule between ${Source} and ${Target}.")
trait Rule[S <: EObject, T <: EObject]
implicit class EListM2MSupport[A <: EObject: ClassTag](that: EList[A]) {
def unary_~[B <: EObject](implicit rule: Rule[A, B]) = // ...
}
implicit val _ruleClass2Table = rule(ruleClass2Table _)](https://image.slidesharecdn.com/scalaworkshop13extended-130702130513-phpapp02/85/Model-Manipulation-Using-Embedded-DSLs-in-Scala-17-320.jpg)
![Further Work
Faster M2M Transformations
Translate declarative rules into imperative code
source.eAllContents collect {
case x: Class ⇒
ruleClass2Table(x, create[Table], create[Column])
case x: Property ⇒
ruleProperty2Column4(x, create[Column])
case x =>
logger warn (s"No rule to transform ${x}.")
}
class OO2DB extends M2M with OOPackageScalaSupport with DBPackageScalaSupport {
def ruleClass2Table(cls: Class, tab: Table, pkey: Column)
def ruleProperty2Column(prop: Property, col: Column)
}](https://image.slidesharecdn.com/scalaworkshop13extended-130702130513-phpapp02/85/Model-Manipulation-Using-Embedded-DSLs-in-Scala-18-320.jpg)
![Further Work
Even Faster M2M Transformations
Translate declarative rules into imperative code
class OO2DB extends M2M with OOPackageScalaSupport with DBPackageScalaSupport {
def ruleClass2Table(cls: Class, tab: Table, pkey: Column)
def ruleProperty2Column(prop: Property, col: Column)
}
val it = source.eAllContents
while (it.hasNext) {
val x = it.next
if (x.isInstanceOf[Class])
ruleClass2Table(x.asInstanceOf[Class], create[Table], create[Column])
else if (x.isInstanceOf[Property])
ruleProperty2Column4(x.asInstanceOf[Property], create[Column])
else
logger warn (s"No rule to transfrom ${x}.")
}](https://image.slidesharecdn.com/scalaworkshop13extended-130702130513-phpapp02/85/Model-Manipulation-Using-Embedded-DSLs-in-Scala-19-320.jpg)
Model Manipulation Using Embedded DSLs in Scala
- 1. Model Manipulation Using Embedded DSLs in Scala Filip Křikava I3S laboratory, Université Nice Sophia-Antipolis Scala Workshop 2013, Montpellier, 2.7.2013
- 2. Context Model Manipulation • Essential in Model-Driven Engineering (MDE) • Automating operations such as • model consistency checking • model-to-model transformation (M2M) • model-to-text transformation (M2T)
- 3. Approaches in http://eclipse.org/modeling/ GPL external DSL M2M transformation QVT ETL Kermeta ATL Model consistency checking OCL EVL Kermeta M2T transformation MOFM2T EGL Kermeta Xpand
- 4. Issues ✓ Versatility ✓ Tool support ✓ Performance ✓ Integration ✗ Limited tool support ✗ Limited performance ✗ Limited versatility (fall back to Java) ✗ Limited interoperability ✓ High level of abstraction ✓ Expressiveness and ease of use ✓ Domain-specific error checking and optimizations ✗ Low level of abstraction ✗ Limited expressiveness (lack of functional aspects in the language) ✗ Limited domain-specific error checking and optimizations = giving raise to accidental complexities, albeit of a different nature. QVT ETL ATL OCL EVL Kermeta MOFM2T EGL Xpand
- 5. Towards Embedded DSLs • External model manipulation DSLs • embed general-purpose programming constructs into a specific model-manipulation DSL
- 6. Towards Embedded DSLs • External model manipulation DSLs • embed general-purpose programming constructs into a specific model-manipulation DSL • We explore Internal / embedded model manipulation DSLs, that • embed domain-specific model manipulation constructs into a GPL • aiming at • similar features and expressiveness • increased versatility • improved tool support • with significantly reduced engineering effort
- 7. Quick Example Model Consistency Checking Checking Library books’ ISBN codes. context Book: invariant UniqueISBN: self.library.books->forAll(book | book <> self implies book.isbn <> self.isbn); OCL
- 8. Quick Example Model Consistency Checking Checking Library books’ ISBN codes. ✓ Tool support (rich editor, debugger) ✓ Unit testing ✓ Invariant inheritance ✓ Integration (build tools, workflows) context Book: invariant UniqueISBN: self.library.books->forAll(book | book <> self implies book.isbn <> self.isbn); OCL class BookContext extends ValidationContext with BookPackageScalaSupport { type Self = Class def invUniqueISBN = self.library.books forall { book => book != self implies book.isbn != self.isbn } } Scala
- 9. Common Infrastructure Support • Navigation • Modification self.getLibrary().getIsbn() self.library.isbn self.library.books collect { case Book(title, Author(author),_,_,_,_) => (title, author) } val sicp = Book(name = "SICP", copies = 2) sicp.author = library.authors find (_.name == "H. Abelson") with LibraryPackageScalaSupport • Generate a Scala support trait for each EMF package • Improving null handling • Multiplicity 0..1 is wrapped into Option[T]
- 10. Model Consistency Checking def invHasCapitalizedName = // guards guardedBy { // invariant dependency self satisfies invHasNonEmptyName } check { if (self.name.split(" ") forall (_(0).isUpper)) { Passed } else { // detailed error messages Error(s"Book ${self.name} does not have capitalized name") // with quick fixes .quickFix("Capitalize book name") { self.name = self.name.split(" ") map (_.capitalize) mkString (" ") } } } ✓ Context and invariant guards ✓ User feedback including quick fixes ✓ Invariant inheritance, modularity ✓ Different levels of severity
- 11. M2M Transformation class OO2DB extends M2M with OOPackageScalaSupport with DBPackageScalaSupport { def ruleClass2Table(cls: Class, tab: Table, pkey: Column) { tab.name = cls.name; tab.columns += pkey tab.columns ++= ~cls.properties pkey.name = "Id" pkey.dataType = "Int" } @Lazy def ruleProperty2Column(prop: Property, col: Column) = guardedBy { !prop.multi } transform { col.name = prop.name col.dataType = prop.type_.name } } Simple object-oriented model into relational model ✓ Hybrid M2M transformation ✓ Rule inheritance, modularity ✓ Matched rules, lazy rules, partial rules ✓ Unit testing
- 12. M2M Transformation class OO2DB extends M2M with OOPackageScalaSupport with DBPackageScalaSupport { def ruleClass2Table(cls: Class, tab: Table, pkey: Column) { tab.name = cls.name; tab.columns += pkey tab.columns ++= ~cls.properties pkey.name = "Id" pkey.dataType = "Int" } @Lazy def ruleProperty2Column(prop: Property, col: Column) = guardedBy { !prop.multi } transform { col.name = prop.name col.dataType = prop.type_.name } } Simple object-oriented model into relational model ✓ Hybrid M2M transformation ✓ Rule inheritance, modularity ✓ Matched rules, lazy rules, partial rules ✓ Unit testing
- 13. M2M Transformation class OO2DB extends M2M with OOPackageScalaSupport with DBPackageScalaSupport { def ruleClass2Table(cls: Class, tab: Table, pkey: Column) { tab.name = cls.name; tab.columns += pkey tab.columns ++= ~cls.properties pkey.name = "Id" pkey.dataType = "Int" } @Lazy def ruleProperty2Column(prop: Property, col: Column) = guardedBy { !prop.multi } transform { col.name = prop.name col.dataType = prop.type_.name } } Executes Simple object-oriented model into relational model ✓ Hybrid M2M transformation ✓ Rule inheritance, modularity ✓ Matched rules, lazy rules, partial rules ✓ Unit testing
- 14. M2T Transformation class OO2Java extends M2T with OOPackageScalaSupport { type Root = Class // input type for this transformation def main = !s"public class ${root.name}" curlyIndent { !endl // extra new line for (o <- root.operations) { genOperation(o) !endl // extra new line } } def genOperation(o: Operation) = !s"public ${o.returnType.name} ${o.name}()" curlyIndent { !s""" // TODO: should be implemented throw new UnsupportedOperationException("${o.name}"); """ } } Simple object-oriented model into Java code ✓ Template based, code-centric M2T ✓ Template inheritance, modularity ✓ Smart white space handling ✓ Unit testing
- 15. Further Work Beyond Shallow Embedding • Using Scala facilities for deep embedding • scala-virtualized https://github.com/TiarkRompf/scala-virtualized • lightweight modular staging http://scala-lms.github.io/ • For • formal analysis • domain-specific error checking • domain-specific optimization
- 16. Further Work Formal Reasoning • Translating invariant expression into first-order logic • To check invariant unsatisfiability1 library.books exists { book => book.pages > 300 } library.books forall { book => book.pages < 300 } 1Clavel, M., Egea, M., Garcia de Dios, M.A. (2009) Checking unsatisfiability for OCL constraints. OCL Workshop, MODELS 2009 • Automatic verification using SMT solvers
- 17. Further Work Domain-Specific error checking • Using ~ without corresponding rule yields compile time error @implicitNotFound("No conversion rule between ${Source} and ${Target}.") trait Rule[S <: EObject, T <: EObject] implicit class EListM2MSupport[A <: EObject: ClassTag](that: EList[A]) { def unary_~[B <: EObject](implicit rule: Rule[A, B]) = // ... } implicit val _ruleClass2Table = rule(ruleClass2Table _)
- 18. Further Work Faster M2M Transformations Translate declarative rules into imperative code source.eAllContents collect { case x: Class ⇒ ruleClass2Table(x, create[Table], create[Column]) case x: Property ⇒ ruleProperty2Column4(x, create[Column]) case x => logger warn (s"No rule to transform ${x}.") } class OO2DB extends M2M with OOPackageScalaSupport with DBPackageScalaSupport { def ruleClass2Table(cls: Class, tab: Table, pkey: Column) def ruleProperty2Column(prop: Property, col: Column) }
- 19. Further Work Even Faster M2M Transformations Translate declarative rules into imperative code class OO2DB extends M2M with OOPackageScalaSupport with DBPackageScalaSupport { def ruleClass2Table(cls: Class, tab: Table, pkey: Column) def ruleProperty2Column(prop: Property, col: Column) } val it = source.eAllContents while (it.hasNext) { val x = it.next if (x.isInstanceOf[Class]) ruleClass2Table(x.asInstanceOf[Class], create[Table], create[Column]) else if (x.isInstanceOf[Property]) ruleProperty2Column4(x.asInstanceOf[Property], create[Column]) else logger warn (s"No rule to transfrom ${x}.") }
- 20. ThankYou Filip Křikava filip.krikava@i3s.unice.fr https://fikovnik.github.io/Sigma The work is partly funded by the ANR SALTY project under contract ANR-09-SEGI-012. https://salty.unice.fr