PLDI '88 Proceedings of the ACM SIGPLAN 1988 conference on Programming Language design and Implementation
FPCA '89 Proceedings of the fourth international conference on Functional programming languages and computer architecture
Functional programming with bananas, lenses, envelopes and barbed wire
Proceedings of the 5th ACM conference on Functional programming languages and computer architecture
Bananas in space: extending fold and unfold to exponential types
FPCA '95 Proceedings of the seventh international conference on Functional programming languages and computer architecture
Revisiting catamorphisms over datatypes with embedded functions (or, programs from outer space)
POPL '96 Proceedings of the 23rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Fully reflexive intensional type analysis
ICFP '00 Proceedings of the fifth ACM SIGPLAN international conference on Functional programming
A modal analysis of staged computation
Journal of the ACM (JACM)
Primitive recursion for higher-order abstract syntax
Theoretical Computer Science
A Hybrid Approach to Online and Offline Partial Evaluation
Higher-Order and Symbolic Computation
Meta-programming with names and necessity
Proceedings of the seventh ACM SIGPLAN international conference on Functional programming
POPL '03 Proceedings of the 30th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Guarded recursive datatype constructors
POPL '03 Proceedings of the 30th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A Generalization of Short-Cut Fusion and its Correctness Proof
Higher-Order and Symbolic Computation
Higher-Order Abstract Syntax in Coq
TLCA '95 Proceedings of the Second International Conference on Typed Lambda Calculi and Applications
Combining Higher Order Abstract Syntax with Tactical Theorem Proving and (Co)Induction
TPHOLs '02 Proceedings of the 15th International Conference on Theorem Proving in Higher Order Logics
Definable Operation in General Algebras, and the Theory of Automata and Flowcharts
Programming Languages and Their Definition - Hans Bekic (1936-1982)
A Metalanguage for Programming with Bound Names Modulo Renaming
MPC '00 Proceedings of the 5th International Conference on Mathematics of Program Construction
Boxes go bananas: encoding higher-order abstract syntax with parametric polymorphism
ICFP '03 Proceedings of the eighth ACM SIGPLAN international conference on Functional programming
A judgmental reconstruction of modal logic
Mathematical Structures in Computer Science
Recursion over objects of functional type
Mathematical Structures in Computer Science
A Sequent Calculus for Nominal Logic
LICS '04 Proceedings of the 19th Annual IEEE Symposium on Logic in Computer Science
A proof theory for generic judgments
ACM Transactions on Computational Logic (TOCL)
Type-safe run-time polytypic programming
Journal of Functional Programming
Practical type inference for arbitrary-rank types
Journal of Functional Programming
Proceedings of the 35th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Parametric higher-order abstract syntax for mechanized semantics
Proceedings of the 13th ACM SIGPLAN international conference on Functional programming
Proceedings of the 2009 ACM SIGPLAN conference on Programming language design and implementation
Syntax for Free: Representing Syntax with Binding Using Parametricity
TLCA '09 Proceedings of the 9th International Conference on Typed Lambda Calculi and Applications
Higher-order abstract syntax in classical higher-order logic
Proceedings of the Fourth International Workshop on Logical Frameworks and Meta-Languages: Theory and Practice
Unembedding domain-specific languages
Proceedings of the 2nd ACM SIGPLAN symposium on Haskell
Finally tagless, partially evaluated: Tagless staged interpreters for simpler typed languages
Journal of Functional Programming
A verified compiler for an impure functional language
Proceedings of the 37th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Modular domain-specific language components in scala
GPCE '10 Proceedings of the ninth international conference on Generative programming and component engineering
Journal of Automated Reasoning
Functional programming with structured graphs
Proceedings of the 17th ACM SIGPLAN international conference on Functional programming
Typed tagless final interpreters
SSGIP'10 Proceedings of the 2010 international spring school conference on Generic and Indexed Programming
Compiling contextual objects: bringing higher-order abstract syntax to programmers
PLPV '13 Proceedings of the 7th workshop on Programming languages meets program verification
Formalizing a correctness property of a type-directed partial evaluator
Proceedings of the ACM SIGPLAN 2014 Workshop on Programming Languages meets Program Verification
Hi-index | 0.00 |
Higher-order abstract syntax is a simple technique for implementing languages with functional programming. Object variables and binders are implemented by variables and binders in the host language. By using this technique, one can avoid implementing common and tricky routines dealing with variables, such as capture-avoiding substitution. However, despite the advantages this technique provides, it is not commonly used because it is difficult to write sound elimination forms (such as folds or catamorphisms) for higher-order abstract syntax. To fold over such a data type, one must either simultaneously define an inverse operation (which may not exist) or show that all functions embedded in the data type are parametric. In this paper, we show how first-class polymorphism can be used to guarantee the parametricity of functions embedded in higher-order abstract syntax. With this restriction, we implement a library of iteration operators over data structures containing functionals. From this implementation, we derive “fusion laws” that functional programmers may use to reason about the iteration operator. Finally, we show how this use of parametric polymorphism corresponds to the Schürmann, Despeyroux and Pfenning method of enforcing parametricity through modal types. We do so by using this library to give a sound and complete encoding of their calculus into System . This encoding can serve as a starting point for reasoning about higher-order structures in polymorphic languages.