Programming languages are embracing both functional and object-oriented paradigms. A key diference between the two paradigms is the way of achieving data abstraction. That is, how to organize data with associated operations. There are essential tradeofs between functional and object-oriented decomposition regarding extensibility and expressiveness. Unfortunately, programmers are usually forced to select a particular decomposition style in the early stage of programming. Once the wrong design decision has been made, the price for switching to the other decomposition style could be rather high since pervasive manual refactoring is often needed. In this talk, we show a bidirectional transformation system between functional and object-oriented decomposition. We formalize the core of the system in the FOOD calculus, which captures the essence of functional and object-oriented decomposition. We prove that the transformation preserves the type and semantics of the original program. We further implement FOOD in Scala as a translation tool called Cook and conduct several case studies to demonstrate the applicability and efectiveness of Cook.
expressions. Besides extensibility, object-oriented and functional decomposition have diferent expressive power. Object-oriented decomposition facilitates code reuse through inheritance and enables interoperability between diferent implementations of the same interface whereas functional decomposition allows inspection on the internal representation of data through (nested) pattern matching, simplifying abstract syntax tree transformations.
Unfortunately, programmers are forced to decide a decomposition style in the early stage of programming. A proper choice, however, requires predictions on the extensibility dimension and kinds of operations to model, which may not be feasible in practice. Once the wrong design decision was made, the price for switching to the other decomposition style could be rather high since pervasive manual refactoring is often needed.
A better way, however, allows programmers to choose a decomposition style for prototyping without regret. When the design choice becomes inappropriate, a tool automatically transforms their code into another style without afecting the semantics. Even at later stages, such a automatic translation tool could be used to make extensions of data variants or operations easier by momentarily switching the decomposition, adding the extension, and then transforming the program back to the original decomposition. Furthermore, studying the transformation between the two styles can provide a theoretical foundation for compiling multi-paradigm languages into single-paradigm ones. From an educational perspective, the tool can help novice programmers to understand both decomposition styles better.
To address this issue, we propose a bidirectional transformation between functional and
object-oriented decomposition based on the observation that restricted forms of functional
and object-oriented decomposition are symmetric. We formalize an automatic, type-directed
transformation in the core calculus FOOD, which captures the essence of Functional and
ObjectOriented Decomposition. We prove that the transformation preserves the type and semantics of
the original program. We further implement FOOD in Scala as a translation tool called Cook
and conduct several case studies to demonstrate the applicability of Cook. Interested readers
may want to consult the full paper for more details [