Binding as sets of scopes

@article{Flatt2016BindingAS,
  title={Binding as sets of scopes},
  author={Matthew Flatt},
  journal={Proceedings of the 43rd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages},
  year={2016}
}
  • M. Flatt
  • Published 11 January 2016
  • Physics
  • Proceedings of the 43rd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages
Our new macro expander for Racket builds on a novel approach to hygiene. Instead of basing macro expansion on variable renamings that are mediated by expansion history, our new expander tracks binding through a set of scopes that an identifier acquires from both binding forms and macro expansions. The resulting model of macro expansion is simpler and more uniform than one based on renaming, and it is sufficiently compatible with Racket's old expander to be practical. 
Romeo: A system for more flexible binding-safe programming*
TLDR
Romeo is a language that respects α-equivalence on its values, and which has access to a rich specification language for binding, inspired by attribute grammars, which is a full-fledged binding-safe language like Pure FreshML.
Romeo: a system for more flexible binding-safe programming
TLDR
Romeo is a language that respects α-equivalence on its values, and which has access to a rich specification language for binding, inspired by attribute grammars, which is a full-fledged binding-safe language like Pure FreshML.
Dependent type systems as macros
TLDR
This paper explains the implementation details of Turnstile+, as well as how it may be used to create a wide-variety of dependently typed languages, from a lightweight one with indexed types, to a full spectrum proof assistant, complete with a tactic system and extensions for features like sized types and SMT interaction.
Inferring Scope through Syntactic Sugar ( Extended Version )
TLDR
This paper shows how to lift scoping rules defined on a core language to rules on the surface, a process of scope inference, and introduces a new representation of binding structure—scope as a preorder—and presents a theoretical advance: proving that a desugaring system preserves α-equivalence even though scoped rules have been provided only for the core language.
From Macros to DSLs: The Evolution of Racket
TLDR
This paper presents the evolution of Racket’s macro system, including a false start, and assesses its current state.
Inferring scope through syntactic sugar
TLDR
This paper shows how to lift scoping rules defined on a core language to rules on the surface, a process of scope inference, and introduces a new representation of binding structure---scope as a preorder---and presents a theoretical advance: proving that a desugaring system preserves α-equivalence even though scoped rules have been provided only for the core language.
Type systems as macros
TLDR
Turnstile critically depends on the idea of linguistic reuse and exploits a macro system in a novel way to simultaneously type check and rewrite a surface program into a target language.
Scopes as types
TLDR
It is shown that viewing scopes as types enables us to model the internal structure of types in a range of non-simple type systems using the generic representation of scopes, and that relations between such types can be expressed in terms of generalized scope graph queries.
Dependent Object Types
TLDR
A new type-theoretic foundation of Scala and languages like it: the Dependent Object Types (DOT) calculus, which normalizes Scala’s type system by unifying the constructs for type members and by providing classical intersection and union types which simplify greatest lower bound and least upper bound computations.
Flexible binding-safe programming
TLDR
This system has the expressive power of David Herman’s λm, but is a full-fledged programming system for any kind of metaprogramming, inspired by attribute grammars.
...
1
2
3
...

References

SHOWING 1-10 OF 24 REFERENCES
Hygienic macro expansion
TLDR
A change to the expansion algorithm is proposed so that macros will only violate the binding discipline when it is explicitly intended.
Romeo: a system for more flexible binding-safe programming
TLDR
Romeo is a language that respects α-equivalence on its values, and which has access to a rich specification language for binding, inspired by attribute grammars, which is a full-fledged binding-safe language like Pure FreshML.
Macros that Work Together
TLDR
This paper describes and models features of the Racket macro system, including support for general compile-time bindings, sub-form expansion and analysis, and environment management, and generalizes naturally to Racket's other extensions.
Extending the scope of syntactic abstraction
TLDR
This paper presents a system that seamlessly integrates modules and lexically scoped macros and shows that more dynamic module facilities are easily implemented at the source level in the extended language supported by the system.
Hygienic macros through explicit renaming
TLDR
The facility described here is based on explicit renaming of identifiers, and was developed for the first implementation of the hygienic macro expansion algorithm described in [2], and remains one of the easiest to understand.
Syntactic abstraction in scheme
TLDR
An efficient macro system is described that prevents inadvertent capturing while maintaining the correlation between source and object code.
A Theory of Name Resolution
TLDR
A resolution calculus is introduced as a concise, declarative, and languageindependent specification of name resolution and language-independent definitions of α-equivalence and rename refactoring are developed.
Nominal Logic: A First Order Theory of Names and Binding
TLDR
Nominal Logic is introduced, a version of first-order many-sorted logic with equality containing primitives for renaming via name-swapping and for freshness of names, from which a notion of binding can be derived.
Higher-order abstract syntax
TLDR
Higher-order abstract syntax incorporates name binding information in a uniform and language generic way and acts as a powerful link integrating diverse tools in program manipulation and other formal systems where matching and substitution or unification are central operations.
Debugging hygienic macros
...
1
2
3
...