2006 Scheme and Functional Programming Papers, University of

(term ’lam
(lambda (x)
(if (equal? x (Q 1)) (Q 2) (Q 3))))
but it is not a valid representation — there is no lambda term
that has this as its quotation. Briefly, the problem is that the
function is trying to inspect its values (it would have been a
valid representation had the whole if expression been quoted).
This means that we should not allow arbitrary functions into
the representation; indeed, major research efforts went into
formalizing types in various ways from permutations-based
approaches [15, 16, 17], to modal logic [4, 5] and category
theory [14]. In [1], another formalism is presented which is
of particular interest in the context of Scheme. It relies on a
predicative logic system, which corresponds to certain dynamic
run-time checks that can exclude formation of exotic terms.
This formalism is extended in [12].
Induction: another common problem is that the representation
contains functions (which puts a function type in a negative position),
and therefore does not easily lend itself to induction.
Several solutions for this problem exist. As previously demonstrated
[1], these functions behave in a way that makes them
directly correspond to concrete syntax. In Scheme, the quotation
macro can add the missing information — add the syntactic
information that contains enough hints to recover the structure
(but see [1] for why this is not straightforward).
As a side note, it is clear that using HOAS is very different in
its nature than using high-level Scheme macros. Instead of plain
pattern matching and template filling, we need to know and encode
the exact lexical structure of any binding form that we wish to
encode. Clearly, the code that is presented here is simplified as
it has just one binding form, but we would face such problems if
we would represent more binding constructs like let, let* and
letrec. This is not necessarily a negative feature, since lexical
scope needs to be specified in any case.
9. Conclusion
We have presented code that uses HOAS techniques in Scheme.
The technique is powerful enough to make it possible to write a
small evaluator that can evaluate itself, and — as we have shown
— be powerful enough to model different evaluation approaches.
In addition to being robust, the encoding is efficient enough to be
practical even at three levels of nested evaluators, or when using
lazy semantics. HOAS is therefore a useful tool in the Scheme
world in addition to the usual host of meta-level syntactic tools.
We plan on further work in this area, specifically, it is possible
that using a HOAS representation for PLT’s Reduction Semantics
[11] tool will result in a speed boost, and a cleaner solution to its
custom substitution specification language. Given that we’re using
Scheme bindings to represent bindings may make it possible to
use HOAS-based techniques combined with Scheme macros. For
example, we can represent a language in Scheme using Scheme
binders, allowing it to be extended via Scheme macros in a way
that still respects Scheme’s lexical scope rules.
References
[1] Eli Barzilay. Implementing Direct Reflection in Nuprl. PhD thesis,
Cornell University, Ithaca, NY, January 2006.
[2] Eli Barzilay and Stuart Allen. Reflecting higher-order abstract
syntax in Nuprl. In Victor A. Carreño, Cézar A. Muñoz, and
Sophiène Tahar, editors, Theorem Proving in Higher Order Logics;
Track B Proceedings of the 15th International Conference on
Theorem Proving in Higher Order Logics (TPHOLs 2002), Hampton,
VA, August 2002, pages 23–32. National Aeronautics and Space
Administration, 2002.
[3] R. L. Constable, S. F. Allen, H. M. Bromley, W. R. Cleaveland,
J. F. Cremer, R. W. Harper, D. J. Howe, T. B. Knoblock, N. P.
Mendler, P. Panangaden, J. T. Sasaki, and S. F. Smith. Implementing
Mathematics with the Nuprl Proof Development System. Prentice-
Hall, NJ, 1986.
[4] Rowan Davies and Frank Pfenning. A modal analysis of staged
computation. In Conf. Record 23rd ACM SIGPLAN/SIGACT Symp.
on Principles of Programming Languages, POPL’96, pages 258–270.
ACM Press, New York, 1996.
[5] Joëlle Despeyroux and Pierre Leleu. A modal lambda-calculus with
iteration and case constructs. In Proc. of the annual Types seminar,
March 1999.
[6] Robert Bruce Findler. PLT DrScheme: Programming environment
manual. Technical Report PLT-TR2006-3-v352, PLT Scheme Inc.,
2006. See also: Findler, R. B., J. Clements, C. Flanagan, M. Flatt, S.
Krishnamurthi, P. Steckler and M. Felleisen. DrScheme: A programming
environment for Scheme, Journal of Functional Programming,
12(2):159–182, March 2002. http://www.ccs.neu.edu/scheme/pubs/.
[7] Matthew Flatt. PLT MzScheme: Language manual. Technical
Report PLT-TR2006-1-v352, PLT Scheme Inc., 2006. http:
//www.plt-scheme.org/techreports/.
[8] Erik Hilsdale and Daniel P. Friedman. Writing macros in
continuation-passing style. In Scheme and Functional Programming
2000, page 53, September 2000.
[9] Martin Hofmann. Semantical analysis of higher-order abstract syntax.
In 14th Symposium on Logic in Computer Science, page 204. LICS,
July 1999.
[10] Oleg Kiselyov. Macros that compose: Systematic macro programming.
In Generative Programming and Component Engineering
(GPCE’02), 2002.
[11] Jacob Matthews, Robert Bruce Findler, Matthew Flatt, and Matthias
Felleisen. A visual environment for developing context-sensitive
term rewriting systems. In International Conference on Rewriting
Techniques and Applications, 2004.
[12] Aleksey Nogin, Alexei Kopylov, Xin Yu, and Jason Hickey. A
computational approach to reflective meta-reasoning about languages
with bindings. In MERLIN ’05: Proceedings of the 3rd ACM
SIGPLAN workshop on Mechanized reasoning about languages with
variable binding, pages 2–12, Tallinn, Estonia, September 2005.
ACM Press.
[13] Frank Pfenning and Conal Elliott. Higher-order abstract syntax. In
Proceedings of the ACM SIGPLAN ’88 Conference on Programming
Language Design and Implementation (PLDI), pages 199–208,
Atlanta, Georgia, June 1988. ACM Press.
[14] Carsten Schürmann. Recursion for higher-order encodings. In
Proceedings of Computer Science Logic (CSL 2001), pages 585–599,
2001.
[15] M. R. Shinwell, A. M. Pitts, and M. J. Gabbay. FreshML:
Programming with binders made simple. In Eighth ACM SIGPLAN
International Conference on Functional Programming (ICFP 2003),
Uppsala, Sweden, pages 263–274. ACM Press, August 2003.
[16] C. Urban, A. M. Pitts, and M. J. Gabbay. Nominal unification.
In M. Baaz, editor, Computer Science Logic and 8th Kurt Gödel
Colloquium (CSL’03 & KGC), Vienna, Austria. Proccedings, Lecture
Notes in Computer Science, pages 513–527. Springer-Verlag, Berlin,
2003.
[17] Christian Urban and Christine Tasson. Nominal reasoning techniques
in isabelle/hol. In Proceedings of the 20th Conference on Automated
Deduction (CADE 2005), volume 3632, pages 38–53, Tallinn,
Estonia, July 2005. Springer Verlag.
124 Scheme and Functional Programming, 2006