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}
}
  • M. Servetto, E. Zucca
  • Published 17 October 2010
  • Computer Science
  • Proceedings of the ACM international conference on Object oriented programming systems languages and applications
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… 

Figures from this paper

A meta-circular language for active libraries
A meta-circular language for active libraries
TLDR
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
TLDR
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
TLDR
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.
Meta C++: an extension layer for multi-stage generative metaprogramming
TLDR
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
TLDR
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
TLDR
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
TLDR
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
Customizable composition operators for Java-like classes
TLDR
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 )
TLDR
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
TLDR
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.
Metaprogramming with Traits
TLDR
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
MultiJava: Design rationale, compiler implementation, and applications
TLDR
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
TLDR
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
TLDR
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.
...
1
2
3
4
5
...