Scala for generic programmers

Oliveira, Bruno C. d. S.; Gibbons, Jeremy

doi:10.1017/s0956796810000171

Cited by 18 publications

(14 citation statements)

References 49 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…DGP can be viewed as an advanced form of generic programming in which the structure of types is used to derive generic algorithms. Oliveira and Gibbons (2008) show that Scala is particularly well-suited for DGP and that it is, in some ways, better than Haskell. This is partly due to the flexibility of implicits in comparison with type classes.…”

Section: Real-world Applicationsmentioning

confidence: 98%

“…Several authors noted that Haskell type classes can be limiting for certain applications due to the impossibility of explicitly passing arguments and abstracting over type classes (Dijkstra and Swierstra 2005;Hughes 1999;Kahl and Scheffczyk 2001;Lämmel and Jones 2005;Oliveira and Gibbons 2008;Oliveira and Sulzmann 2008). Thus, there have been a number of proposals aimed at lifting some of these restrictions (Dijkstra and Swierstra 2005;Kahl and Scheffczyk 2001;Orchard and Schrijvers 2010).…”

Section: Type Classes Javagi and Conceptsmentioning

confidence: 99%

See 1 more Smart Citation

Type classes as objects and implicits

2010

View full text Add to dashboard Cite

Type classes were originally developed in Haskell as a disciplined alternative to ad-hoc polymorphism. Type classes have been shown to provide a type-safe solution to important challenges in software engineering and programming languages such as, for example, retroactive extension of programs. They are also recognized as a good mechanism for concept-based generic programming and, more recently, have evolved into a mechanism for type-level computation.This paper presents a lightweight approach to type classes in object-oriented (OO) languages with generics using the CONCEPT pattern and implicits (a type-directed implicit parameter passing mechanism). This paper also shows how Scala's type system conspires with implicits to enable, and even surpass, many common extensions of the Haskell type class system, making Scala ideally suited for generic programming in the large.

show abstract

Section: Real-world Applicationsmentioning

confidence: 98%

Section: Type Classes Javagi and Conceptsmentioning

confidence: 99%

Type classes as objects and implicits

2010

View full text Add to dashboard Cite

show abstract

“…Higher-rank polymorphism (i.e. polymorphism over type constructors) allows more forms of generic programming [24]. We believe both extensions to be important in the future, and like the other features mentioned, Virgil's core design has done nothing to preclude them.…”

Section: Future Workmentioning

confidence: 99%

Harmonizing classes, functions, tuples, and type parameters in virgil iii

Titzer

2013

Proceedings of the 34th ACM SIGPLAN Conference on Programming Language Design and Implementation

View full text Add to dashboard Cite

Languages are becoming increasingly multi-paradigm. Subtype polymorphism in statically-typed object-oriented languages is being supplemented with parametric polymorphism in the form of generics. Features like first-class functions and lambdas are appearing everywhere. Yet existing languages like Java, C#, C++, D, and Scala seem to accrete ever more complexity when they reach beyond their original paradigm into another; inevitably older features have some rough edges that lead to nonuniformity and pitfalls. Given a fresh start, a new language designer is faced with a daunting array of potential features. Where to start? What is important to get right first, and what can be added later? What features must work together, and what features are orthogonal? We report on our experience with Virgil III, a practical language with a careful balance of classes, functions, tuples and type parameters. Virgil intentionally lacks many advanced features, yet we find its core feature set enables new species of design patterns that bridge multiple paradigms and emulate features not directly supported such as interfaces, abstract data types, ad hoc polymorphism, and variant types. Surprisingly, we find variance for function types and tuple types often replaces the need for other kinds of type variance when libraries are designed in a more functional style.

show abstract

“…Aspects [23] and open-classes [17] are powerful generic programming techniques for adapting programs by augmenting their behavior in existing classes [24,25]. Other languages that provide support for generic programming are Haskell and Scala [26]. The use of Haskell has been investigated [27] to specify refactorings based on highlevel graph algorithms that could be generic accross a variety of languages (XML, Pascal, Java), but its applicability does not seem to go beyond a proof of concept.…”

Section: Related Workmentioning

confidence: 99%

Reusable model transformations

et al. 2010

View full text Add to dashboard Cite

Model transformations written for an input metamodel may often apply to other metamodels that share similar concepts. For example, a transformation written to refactor Java models can be applicable to refactoring UML class diagrams as both languages share concepts such as classes, methods, attributes, inheritance. Deriving motivation from this example, we present an approach to make model transformations reusable such that they function correctly across several similar metamodels. Our approach relies on these principal steps: (1) We analyze a transformation to obtain an effective subset of used concepts. We prune the input metamodel of the transformation to obtain an effective input metamodel containing the effective subset. The effective input metamodel represents the true input domain of transformation. (2) We adapt a target input metamodel by weaving it with aspects such as properties derived from the effective input metamodel to ultimately make it a subtype of the effective input metamodel. The subtype property ensures that the transformation can process models conforming to the target input metamodel without any change in the transformation itself. We validate our approach by adapting well-known refactoring transformations (Encapsulate Field, Move Method, and Pull Up Method) written for an in-house domain-specific modelling language (DSML) to three different industry standard metamodels (Java, MOF, and UML).

show abstract

Scala for generic programmers

Cited by 18 publications

References 49 publications

Type classes as objects and implicits

Type classes as objects and implicits

Harmonizing classes, functions, tuples, and type parameters in virgil iii

Reusable model transformations

Contact Info

Product

Resources

About