MetaFJig: a meta-circular composition language for Java-like classes
@article{Servetto2010MetaFJigAM, title={MetaFJig: a meta-circular composition language for Java-like classes}, author={Marco Servetto and Elena Zucca}, journal={Proceedings of the ACM international conference on Object oriented programming systems languages and applications}, year={2010} }
We propose a Java-like language where class definitions are first class values and new classes can be derived from existing ones by exploiting the full power of the language itself, used on top of a small set of primitive composition operators, instead of using a fixed mechanism like inheritance. Hence, compilation requires to perform (meta-)reduction steps, by a process that we call compile-time execution. This approach differs from meta-programming techniques available in mainstream languages…Â
10 Citations
A meta-circular language for active libraries
- Computer SciencePEPM '13
- 2013
A new Java-like language design coupling disciplined meta-programming features with a composition language that ensures an important property, called meta-level soundness, stating that typing errors never originate from already compiled (meta-)code, that is, programmers can safely use (active) libraries.
Modular composition of nested classes
- Computer Science
- 2012
A new language design which smoothly integrates modular composition and nesting of Java-like classes, inspired by Bracha's Jigsaw framework is presented, allowing, e.g., to solve the expression problem, encode basic AOP mechanisms, and bring some refactoring techniques at the language level.
DeepFJig: modular composition of nested classes
- Computer SciencePPPJ
- 2011
A new language design which smoothly integrates modular composition and nesting of Java-like classes, inspired by Bracha's Jigsaw framework is presented, allowing, e.g., to solve the expression problem, encode basic AOP mechanisms, and bring some refactoring techniques at the language level.
Featherweight Jigsaw - Replacing inheritance by composition in Java-like languages
- Computer ScienceInf. Comput.
- 2012
Meta C++: an extension layer for multi-stage generative metaprogramming
- Computer ScienceJ. Object Technol.
- 2019
MetaC++ is proposed, an extension layer supporting multi-stage generative metaprogramming for C++, offering the full-range of language constructs for implementing compile-time metaprograms and allowing them to share development practices with normal programs.
Contracts for First-Class Classes
- Computer ScienceTOPL
- 2013
This article presents the design and implementation of a contract system for first-class classes as well as a two-pronged evaluation that proves a “blame correctness” theorem for a model of the language and demonstrates the need for the rich contract language.
Towards Practical Gradual Typing
- Computer ScienceECOOP
- 2015
This paper presents an implementation of a gradual type system for a full-featured class-based language as well as a novel performance evaluation framework for gradual typing.
A Survey of Metaprogramming Languages
- Computer ScienceACM Comput. Surv.
- 2020
A taxonomy of metaprogramming languages is introduced and a survey of metalanguage languages and systems based on the taxonomy is presented, based on a model adopted by the language, the phase of the meetaprogram evaluation, the metapprogram source location, and the relation between the metalanguage and the object language.
References
SHOWING 1-10 OF 111 REFERENCES
A Lightweight Approach to Customizable Composition Operators for Java-like Classes
- Computer ScienceElectron. Notes Theor. Comput. Sci.
- 2010
Customizable composition operators for Java-like classes
- Computer ScienceICTCS
- 2009
This paper illustrates a lightweight solution which enriches compile-time execution by partial typechecking steps, and proposes a formal framework for extending a class-based language, equipped with a given class composition mechanism, to allow programmers to define their own derived composition operators.
Customizable composition operators for Java-like classes ( extended abstract )
- Computer Science
- 2009
This paper illustrates a lightweight solution which enriches compile-time execution by partial typechecking steps, and proposes a formal framework for extending a class-based language, equipped with a given class composition mechanism, to allow programmers to define their own derived composition operators.
Flexible Type-Safe Linking of Components for Java-Like Languages
- Computer ScienceJMLC
- 2006
A framework of components based on Java-like languages, where components are binary mixin modules, which achieves great flexibility in reusing components for two reasons: (1) type constraints generated for a single component exactly capture all possible contexts where it can be safely used; and (2) composition of components is not limited to conventional linking, but is achieved by means of a set of powerful operators typical ofMixin modules.
Featherweight Jigsaw - Replacing inheritance by composition in Java-like languages
- Computer ScienceInf. Comput.
- 2012
Metaprogramming with Traits
- Computer ScienceECOOP
- 2007
A lightweight mechanism for specifying and reusing member-level structure in Java programs by introducing a hybrid structural/nominal type system that extends Java's type system.
MetaML and multi-stage programming with explicit annotations
- Computer ScienceTheor. Comput. Sci.
- 2000
MultiJava: Design rationale, compiler implementation, and applications
- Computer ScienceTOPL
- 2006
The design of MultiJava is illustrated and motivates and its modular static typechecking and modular compilation strategies are described, allowing users to express desired programming idioms in a way that is declarative and supports static type checking, in contrast to the tedious and type-unsafe workarounds required in Java.
Eliminating distinctions of class: using prototypes to model virtual classes
- Computer ScienceOOPSLA '06
- 2006
It is proved that prototypes are type-safe but undecidable, and briefly outline a decidable semi-algorithm for dealing with them, which blur the distinction between compile-time and run-time.
Variant path types for scalable extensibility
- Computer ScienceOOPSLA
- 2007
The mechanism of variant path types is introduced, which provide a flexible means to express intra-group relationship that has to be preserved through extension, and features the new notions of exact and inexact qualifications, providing rich abstractions to express various kinds of set of objects.