From b14dcef86c30499535c8dd059d496231a6edea67 Mon Sep 17 00:00:00 2001
From: ben <benjaminlgreenman@gmail.com>
Date: Mon, 14 Mar 2016 19:58:15 -0400
Subject: [PATCH] [icfp] other macro systems, in conclusion

---
 icfp-2016/bib.rkt          | 24 ++++++++++++++++++++++++
 icfp-2016/conclusion.scrbl | 36 ++++++++++++++++--------------------
 2 files changed, 40 insertions(+), 20 deletions(-)

diff --git a/icfp-2016/bib.rkt b/icfp-2016/bib.rkt
index ea2caf1..f40fd64 100644
--- a/icfp-2016/bib.rkt
+++ b/icfp-2016/bib.rkt
@@ -30,6 +30,7 @@
 (define/short icfp "ICFP" (string-append ACM International Conference "on Functional Programming"))
 (define/short pldi "PLDI" (string-append ACM Conference "on Programming Language Design and Implementation"))
 (define/short popl "POPL" (string-append ACM Symposium "on Principles of Programming Languages"))
+(define/short plpv "PLPV" (string-append ACM Workshop "Programming Languages meets Program Verification"))
 (define/short icse "ICSE" "International Conference on Software Engineering")
 (define/short lncs "LNCS" "Lecture Notes in Computer Science")
 (define/short sigmod "SIGMOD" (string-append ACM "SIGMOD " International Conference "on Management of Data"))
@@ -57,6 +58,7 @@
 (define/short tlca "TLCA" (string-append International Conference "Typed Lambda Calculi and Applications"))
 (define/short i&c "Info. & Comp." "Information and Computation")
 (define/short haskell "Haskell Workshop")
+(define/short scala "SCALA" (string-append "Workshop on Scala"))
 (define/short tcs "Theoretical Computer Science")
 (define/short tacs (string-append International Symposium "Theoretical Aspects of Computer Science"))
 (define/short ml-workshop "ML Workshop")
@@ -1144,3 +1146,25 @@
    #:author "Richard A. Eisenberg and Stephanie Weirich"
    #:location (proceedings-location haskell #:pages '(117 130))
    #:date 2012))
+
+(define ks-plpv-2006
+  (make-bib
+   #:title "Lightweight static capabilities"
+   #:author "Oleg Kiselyov and Chung-chieh Shan"
+   #:location (proceedings-location plpv)
+   #:date 2006))
+
+(define b-scala-2013
+  (make-bib
+   #:title "Scala Macros: Let our Powers Combine!"
+   #:author "Eugene Burmako"
+   #:location (proceedings-location scala)
+   #:date 2013))
+
+(define ro-gpce-2010
+  (make-bib
+   #:title "Lightweight Modular Staging: A Pragmatic Approach to Runtime Code Generation and Compiled DSLs"
+   #:author (authors "Tiark Rompf" "Martin Odersky")
+   #:location (proceedings-location gpce)
+   #:date 2010))
+
diff --git a/icfp-2016/conclusion.scrbl b/icfp-2016/conclusion.scrbl
index 3579b1d..091251e 100644
--- a/icfp-2016/conclusion.scrbl
+++ b/icfp-2016/conclusion.scrbl
@@ -18,39 +18,35 @@ Each application in @Secref{sec:usage} is a way that constant data
 
 A key thesis behind this work is that the analysis can be implemented
  in a variety of languages using their existing type and syntax extension
- systems. Indeed:
+ systems.
+Indeed:
+@; TODO shorten this
 
 @parag{Typed Clojure} has a flexible macro system derived from Common Lisp.
 Built-in functions @tt{macroexpand} and @tt{with-meta} correspond to Racket's
  @racket[local-expand] and @racket[syntax-property]; with help from a library
  implementing identifier macros,@note{@url["https://github.com/clojure/tools.macro"]}
- we were able to implement a basic prototype in untyped Clojure.
-
-@todo{does TC have macros? can I use macros from untyped code if I type them?}
+ we were able to implement a basic prototype untyped Clojure.
 
 
-@parag{Haskell} Template Haskell
-
+@parag{Template Haskell} could reproduce all the examples in @Secref{sec:usage}
+ as they are written, with constants in-line at each call site.
+We are less sure how to associate and retrieve data regarding bound variables
+ at compile-time, idiomatically.
 
 @parag{OCaml} ppx
 
 
-@parag{Rust} has a stable, pattern-based macro system which unfortunately
- seems too weak to reimplement our analysis.
-As of Rust 1.7,@note{@url["https://doc.rust-lang.org/reference.html"]}
- the basic macros can only specify input/output pairs.
-There is no way to do complex branching within a condition,
- such as throwing an exception if a format string is given too many arguments.
-Just parsing the format string would be challenging.
-
-However Rust also has an interface for writing arbitrarily powerful compiler
- plugins.
-It would be interesting to reproduce our results as a plugin.
+@parag{Rust} has a stable, pattern-based macro system and a powerful API
+ for writing compiler plugins.
+The macro system appears too weak to reimplement our analyses,
+ but it would be interesting to explore the plugin API and try reimplementing
+ ideas like syntax classes and rename transformers.
 
 
-@parag{Scala} users have a few macro systems to choose from.
-@; We investigated Scala Macros and TODO.
-@; https://doc.rust-lang.org/book/compiler-plugins.html
+@parag{Scala} users have at least two macro systems to choose from.
+Both Scala Macros@~cite[b-scala-2013] and Lightweight Modular Staging@~cite[ro-gpce-2010]
+ 
 
 
 With out last words, we look to the future.