1086 lines
136 KiB
XML
1086 lines
136 KiB
XML
<?xml version="1.0" encoding="utf-8"?>
|
||
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="en">
|
||
<title type="text">Alexis King's Blog: Posts tagged 'macros'</title>
|
||
<link rel="self" href="http://lexi-lambda.github.io/feeds/macros.atom.xml" />
|
||
<link href="http://lexi-lambda.github.io/tags/macros.html" />
|
||
<id>urn:http-lexi-lambda-github-io:-tags-macros-html</id>
|
||
<updated>2016-02-18T18:48:32Z</updated>
|
||
<entry>
|
||
<title type="text">Simple, safe multimethods in Racket</title>
|
||
<link rel="alternate" href="http://lexi-lambda.github.io/blog/2016/02/18/simple-safe-multimethods-in-racket/?utm_source=macros&utm_medium=Atom" />
|
||
<id>urn:http-lexi-lambda-github-io:-blog-2016-02-18-simple-safe-multimethods-in-racket</id>
|
||
<published>2016-02-18T18:48:32Z</published>
|
||
<updated>2016-02-18T18:48:32Z</updated>
|
||
<author>
|
||
<name>Alexis King</name></author>
|
||
<content type="html"><html>
|
||
<p>Racket ships with <code>racket/generic</code>, a system for defining <em>generic methods</em>, functions that work differently depending on what sort of value they are supplied. I have made heavy use of this feature in my collections library, and it has worked well for my needs, but that system does have a bit of a limitation: it only supports <em>single dispatch</em>. Method implementations may only be chosen based on a single argument, so multiple dispatch is impossible.</p>
|
||
<!-- more-->
|
||
|
||
<h1 id="motivating-multiple-dispatch">Motivating multiple dispatch</h1>
|
||
|
||
<p>What is multiple dispatch and why is it necessary? Well, in most cases, it <em>isn’t</em> necessary at all. <a href="http://dl.acm.org/citation.cfm?doid=1449764.1449808">It has been shown that multiple dispatch is much rarer than single dispatch in practice.</a> However, when actually needed, having multiple dispatch in the toolbox is a valuable asset.</p>
|
||
|
||
<p>A classic example of multiple dispatch is multiplication over both scalars and vectors. Ideally, all of the following operations should work:</p>
|
||
|
||
<pre><code>2 × 3 = 6
|
||
2 × ⟨3, 4⟩ = ⟨6, 8⟩
|
||
⟨3, 4⟩ × 2 = ⟨6, 8⟩</code></pre>
|
||
|
||
<p>In practice, most languages do not support such flexible dispatch rules without fairly complicated branching constructs to handle each permutation of input types. Furthermore, since most languages only support single dispatch (such as most object-oriented languages), it is nearly impossible to add support for a new combination of types to an existing method.</p>
|
||
|
||
<p>To illustrate the above, even if a language supported operator overloading <em>and</em> it included a <code>Vector</code> class that overloaded multiplication to properly work with numbers and vectors, it might not implement matrix multiplication. If a user defines a <code>Matrix</code> class, they may overload <em>its</em> multiplication to support numbers, vectors, and matrices, but it is impossible to extend the multiplication implementation for the <code>Vector</code> class. That method is now completely set in stone, unless it is edited directly (and the programmer may not have access to <code>Vector</code>’s implementation).</p>
|
||
|
||
<p>Multiple dispatch solves all of these problems. Rather than specify implementations of functions for singular types, it is possible to specify implementations for sets of types. In the above example, a programmer would be able to define a new function that operates on <code>Vector</code> and <code>Matrix</code> arguments. Since each definition does not “belong” to any given type, extending this set of operations is trivial.</p>
|
||
|
||
<h1 id="multiple-dispatch-in-racket">Multiple dispatch in Racket</h1>
|
||
|
||
<p>This blog post is somewhat long and technical, so before proceeding any further, I want to show some real code that actually works so you can get a feel for what I’m talking about. As a proof-of-concept, I have created <a href="https://github.com/lexi-lambda/racket-multimethod">a very simple implementation of multiple dispatch in Racket</a>. The above example would look like this in Racket using my module:</p>
|
||
|
||
<div class="brush: racket">
|
||
<table class="sourcetable">
|
||
<tbody>
|
||
<tr>
|
||
<td class="linenos">
|
||
<div class="linenodiv">
|
||
<pre> 1
|
||
2
|
||
3
|
||
4
|
||
5
|
||
6
|
||
7
|
||
8
|
||
9
|
||
10
|
||
11
|
||
12
|
||
13
|
||
14
|
||
15
|
||
16
|
||
17
|
||
18
|
||
19
|
||
20
|
||
21</pre></div></td>
|
||
<td class="code">
|
||
<div class="source">
|
||
<pre><span></span><span class="kn">#lang </span><span class="nn">racket</span>
|
||
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/require.html#(form._((lib._racket/private/base..rkt)._require))" style="color: inherit">require</a></span> <span class="n">multimethod</span><span class="p">)</span>
|
||
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/require.html#(form._((lib._racket/private/base..rkt)._provide))" style="color: inherit">provide</a></span> <span class="n">mul</span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/require.html#(form._((lib._racket/private/base..rkt)._struct-out))" style="color: inherit">struct-out</a></span> <span class="n">num</span><span class="p">)</span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/require.html#(form._((lib._racket/private/base..rkt)._struct-out))" style="color: inherit">struct-out</a></span> <span class="n">vals</span><span class="p">))</span>
|
||
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit">struct</a></span> <span class="n">num</span> <span class="p">(</span><span class="n">val</span><span class="p">))</span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit">struct</a></span> <span class="n">vec</span> <span class="p">(</span><span class="n">vals</span><span class="p">))</span>
|
||
|
||
<span class="p">(</span><span class="n">define-generic</span> <span class="p">(</span><span class="n">mul</span> <span class="n">a</span> <span class="n">b</span><span class="p">))</span>
|
||
|
||
<span class="p">(</span><span class="n">define-instance</span> <span class="p">((</span><span class="n">mul</span> <span class="n">num</span> <span class="n">num</span><span class="p">)</span> <span class="n">x</span> <span class="n">y</span><span class="p">)</span>
|
||
<span class="p">(</span><span class="n">num</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._*))" style="color: inherit">*</a></span> <span class="p">(</span><span class="n">num-val</span> <span class="n">x</span><span class="p">)</span> <span class="p">(</span><span class="n">num-val</span> <span class="n">y</span><span class="p">))))</span>
|
||
|
||
<span class="p">(</span><span class="n">define-instance</span> <span class="p">((</span><span class="n">mul</span> <span class="n">num</span> <span class="n">vec</span><span class="p">)</span> <span class="n">n</span> <span class="n">v</span><span class="p">)</span>
|
||
<span class="p">(</span><span class="n">vec</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/pairs.html#(def._((lib._racket/private/map..rkt)._map))" style="color: inherit">map</a></span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/procedures.html#(def._((lib._racket/function..rkt)._curry))" style="color: inherit">curry</a></span> <span class="nb"><a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._*))" style="color: inherit">*</a></span> <span class="p">(</span><span class="n">num-val</span> <span class="n">n</span><span class="p">))</span> <span class="p">(</span><span class="n">vec-vals</span> <span class="n">v</span><span class="p">))))</span>
|
||
|
||
<span class="p">(</span><span class="n">define-instance</span> <span class="p">((</span><span class="n">mul</span> <span class="n">vec</span> <span class="n">num</span><span class="p">)</span> <span class="n">v</span> <span class="n">n</span><span class="p">)</span>
|
||
<span class="p">(</span><span class="n">mul</span> <span class="n">n</span> <span class="n">v</span><span class="p">))</span>
|
||
</pre></div>
|
||
</td></tr></tbody></table>
|
||
</div>
|
||
|
||
<p>Pardon the somewhat clunky syntax, but the functionality is there. Using the above code works as expected:</p>
|
||
|
||
<pre><code>&gt; (mul (num 2) (num 3))
|
||
(num 6)
|
||
&gt; (mul (num 2) (vec '(3 4)))
|
||
(vec '(6 8))
|
||
&gt; (mul (vec '(3 4)) (num 2))
|
||
(vec '(6 8))</code></pre>
|
||
|
||
<p>Making the above snippet work is not particularly hard. In fact, it’s likely that most competent Racketeers could do it without much thought. However, there’s a tiny bit more going on behind the scenes than it may seem.</p>
|
||
|
||
<h1 id="the-problem-with-multiple-dispatch">The problem with multiple dispatch</h1>
|
||
|
||
<p>The single-dispatch design limitation of <code>racket/generic</code> comes directly from a desire to avoid what has been described as “spooky action at a distance”, a problem that is prevalent in many systems that support methods with multiple dispatch (aka <em>multimethods</em>). Specifically, the issue arises when new method implementations are defined for existing datatypes, which can have far-reaching effects throughout a program because the method table is global state. Both CLOS and Clojure suffer from this shortcoming.</p>
|
||
|
||
<p>Interestingly, Haskell with multi-parameter typeclasses (a nonstandard but highly useful extension) makes it quite trivial to create constructs similar to multiple dispatch (though the overload resolution is done at compile-time). The similarities are significant: Haskell <em>also</em> suffers from the possibility of a certain sort of “spooky action”. However, Haskell’s static typing and resolution allows the compiler to catch these potential issues, known as “orphan instances”, at compile time. Even though Racket does not support the same sort of static typing, the same idea can be used to keep multiple dispatch safe using the macro system.</p>
|
||
|
||
<h1 id="safe-dynamically-typed-multiple-dispatch">Safe, dynamically-typed multiple dispatch</h1>
|
||
|
||
<p>In order to make multiple dispatch safe, we first need to determine exactly what is unsafe. Haskell has rules for determining what constitutes an “orphan instance”, and these rules are equally applicable for determining dangerous multimethod implementations. Specifically, a definition can be considered unsafe if <em>both</em> of the following conditions are true:</p>
|
||
|
||
<ol>
|
||
<li>The multimethod that is being implemented was declared in a different module from the implementation.</li>
|
||
<li><em>All</em> of the types used for dispatch in the multimethod instance were declared in a different module from the implementation.</li></ol>
|
||
|
||
<p>Conversely, a multimethod implementation is safe if <em>either</em> of the following conditions are true:</p>
|
||
|
||
<ol>
|
||
<li>The multimethod that is being implemented is declared in the same module as the implementation.</li>
|
||
<li><em>Any</em> of the types used for dispatch in the multimethod instance are declared in the same module as the implementation.</li></ol>
|
||
|
||
<p>Why do these two rules provide a strong enough guarantee to eliminate the dangers created by global state? Well, to understand that, we need to understand what can go wrong if these rules are ignored.</p>
|
||
|
||
<h2 id="multimethods-and-dangerous-instances">Multimethods and dangerous instances</h2>
|
||
|
||
<p>What exactly is this dangerous-sounding “spooky action”, and what causes it? Well, the trouble stems from the side-effectful nature of multimethod instance definitions. Consider the Racket module from earlier, which defines multiplication instances for scalars and vectors:</p>
|
||
|
||
<div class="brush: racket">
|
||
<table class="sourcetable">
|
||
<tbody>
|
||
<tr>
|
||
<td class="linenos">
|
||
<div class="linenodiv">
|
||
<pre> 1
|
||
2
|
||
3
|
||
4
|
||
5
|
||
6
|
||
7
|
||
8
|
||
9
|
||
10
|
||
11
|
||
12
|
||
13
|
||
14
|
||
15
|
||
16
|
||
17</pre></div></td>
|
||
<td class="code">
|
||
<div class="source">
|
||
<pre><span></span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/require.html#(form._((lib._racket/private/base..rkt)._provide))" style="color: inherit">provide</a></span> <span class="n">mul</span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/require.html#(form._((lib._racket/private/base..rkt)._struct-out))" style="color: inherit">struct-out</a></span> <span class="n">num</span><span class="p">)</span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/require.html#(form._((lib._racket/private/base..rkt)._struct-out))" style="color: inherit">struct-out</a></span> <span class="n">vals</span><span class="p">))</span>
|
||
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit">struct</a></span> <span class="n">num</span> <span class="p">(</span><span class="n">val</span><span class="p">))</span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit">struct</a></span> <span class="n">vec</span> <span class="p">(</span><span class="n">vals</span><span class="p">))</span>
|
||
|
||
<span class="p">(</span><span class="n">define-generic</span> <span class="p">(</span><span class="n">mul</span> <span class="n">a</span> <span class="n">b</span><span class="p">))</span>
|
||
|
||
<span class="p">(</span><span class="n">define-instance</span> <span class="p">((</span><span class="n">mul</span> <span class="n">num</span> <span class="n">num</span><span class="p">)</span> <span class="n">x</span> <span class="n">y</span><span class="p">)</span>
|
||
<span class="p">(</span><span class="n">num</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._*))" style="color: inherit">*</a></span> <span class="p">(</span><span class="n">num-val</span> <span class="n">x</span><span class="p">)</span> <span class="p">(</span><span class="n">num-val</span> <span class="n">y</span><span class="p">))))</span>
|
||
|
||
<span class="p">(</span><span class="n">define-instance</span> <span class="p">((</span><span class="n">mul</span> <span class="n">num</span> <span class="n">vec</span><span class="p">)</span> <span class="n">n</span> <span class="n">v</span><span class="p">)</span>
|
||
<span class="p">(</span><span class="n">vec</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/pairs.html#(def._((lib._racket/private/map..rkt)._map))" style="color: inherit">map</a></span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/procedures.html#(def._((lib._racket/function..rkt)._curry))" style="color: inherit">curry</a></span> <span class="nb"><a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._*))" style="color: inherit">*</a></span> <span class="p">(</span><span class="n">num-val</span> <span class="n">n</span><span class="p">))</span> <span class="p">(</span><span class="n">vec-vals</span> <span class="n">v</span><span class="p">))))</span>
|
||
|
||
<span class="p">(</span><span class="n">define-instance</span> <span class="p">((</span><span class="n">mul</span> <span class="n">vec</span> <span class="n">num</span><span class="p">)</span> <span class="n">v</span> <span class="n">n</span><span class="p">)</span>
|
||
<span class="p">(</span><span class="n">mul</span> <span class="n">n</span> <span class="n">v</span><span class="p">))</span>
|
||
</pre></div>
|
||
</td></tr></tbody></table>
|
||
</div>
|
||
|
||
<p>Note that there is not actually a <code>(mul vec vec)</code> implementation. This is intentional: there are <em>two</em> ways to take the product of two vectors, so no default implementation is provided. However, it is possible that another module might desire an instance for <code>mul</code> that takes the dot product, and the programmer might write the following definition:</p>
|
||
|
||
<div class="brush: racket">
|
||
<table class="sourcetable">
|
||
<tbody>
|
||
<tr>
|
||
<td class="linenos">
|
||
<div class="linenodiv">
|
||
<pre>1
|
||
2</pre></div></td>
|
||
<td class="code">
|
||
<div class="source">
|
||
<pre><span></span><span class="p">(</span><span class="n">define-instance</span> <span class="p">((</span><span class="n">mul</span> <span class="n">vec</span> <span class="n">vec</span><span class="p">)</span> <span class="n">x</span> <span class="n">y</span><span class="p">)</span>
|
||
<span class="p">(</span><span class="n">num</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/pairs.html#(def._((lib._racket/private/list..rkt)._foldl))" style="color: inherit">foldl</a></span> <span class="nb"><a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._+))" style="color: inherit">+</a></span> <span class="mi">0</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/pairs.html#(def._((lib._racket/private/map..rkt)._map))" style="color: inherit">map</a></span> <span class="nb"><a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._*))" style="color: inherit">*</a></span> <span class="p">(</span><span class="n">vec-vals</span> <span class="n">x</span><span class="p">)</span> <span class="p">(</span><span class="n">vec-vals</span> <span class="n">y</span><span class="p">)))))</span>
|
||
</pre></div>
|
||
</td></tr></tbody></table>
|
||
</div>
|
||
|
||
<p>However, there is something fishy about the above definition: it doesn’t need to be exported with <code>provide</code> to work! Since instances don’t create new bindings, they only add dispatch options, they don’t ever need to <code>provide</code> anything. This is problematic, though: it means that a program could continue to happily compile <em>even if</em> the module containing the dot product instance was never loaded with <code>require</code>, but an attempt to multiply two vectors would fail at runtime, claiming that there was no <code>(mul vec vec)</code> implementation. This drastic change of behavior violates Racket programmers’ assumptions about the guarantees made by modules (<code>require</code> should not cause any side-effects if the module’s bindings are not used).</p>
|
||
|
||
<p>Of course, while this seems potentially unexpected, it is workable: just be careful to <code>require</code> modules containing instances. Unfortunately, it gets much worse—what if a different library defines <em>its own</em> <code>(mul vec vec)</code> instance? What if that instance takes the cross product instead? That library may function entirely properly on its own, but when loaded alongside the program that defines a dot product instance, it is impossible to determine which instance should be used where. Because <code>define-instance</code> operates by modifying the aforementioned global state, the implementations clash, and the two systems <em>cannot</em> continue to operate together as written.</p>
|
||
|
||
<p>This is pretty bad. Defining extra instances is a reasonable use-case for multiple dispatch, but if these instances can break <em>third-party code</em>, how can they be trusted? This sort of problem can make multiple dispatch difficult to reason about and even more difficult to trust.</p>
|
||
|
||
<h2 id="what-determines-safety">What determines safety?</h2>
|
||
|
||
<p>With those problems in mind, we can turn back to the two rules for <em>safe</em> multiple dispatch. How do they prevent the above issues? Well, let’s take them one at a time.</p>
|
||
|
||
<p>Remember that an instance can be unequivocally determined to be safe if either of the two conditions are true, so we can consider them entirely independently. The first one is simple—an instance is safe if the following condition holds:</p>
|
||
|
||
<blockquote>
|
||
<p>The multimethod that is being implemented is declared in the same module as the implementation.</p></blockquote>
|
||
|
||
<p>This one is pretty obvious. It is impossible to create a “bad” instance of a method declared in the same module because it is impossible to import the method without also bringing in the instance. Furthermore, a conflicting instance cannot be defined at the place where the types themselves are defined because that would require a circular module dependency, which Racket does not permit.</p>
|
||
|
||
<p>With the above explanation in mind, the second condition should make sense, too:</p>
|
||
|
||
<blockquote>
|
||
<p><em>Any</em> of the types used for dispatch in the multimethod instance are declared in the same module as the implementation.</p></blockquote>
|
||
|
||
<p>The same argument for the first point holds for the second, but with the parties swapped. Again, it is impossible to use the instance without somehow requiring the module that defines the datatype itself, so the instance would always be required, anyway. The most interesting aspect of this condition is that it demonstrates that instances can be defined for existing datatypes (that are defined in other modules) just so long as <em>at least one</em> of the datatypes is defined in the same module. This continues to permit the important use-case of extending the interfaces of existing types.</p>
|
||
|
||
<h2 id="encoding-the-safety-rules-into-rackets-macro-system">Encoding the safety rules into Racket’s macro system</h2>
|
||
|
||
<p>In order to keep track of which methods and instances are defined where, I leveraged a technique based on the one <a href="http://www.ccs.neu.edu/racket/pubs/scheme2007-ctf.pdf">used by Typed Racket to keep track of whether or not a typed identifier is used in a typed or untyped context</a>. However, instead of using a simple mutable boolean flag, I used a mutable <a href="http://docs.racket-lang.org/syntax/syntax-helpers.html#%28tech._identifier._set%29">free identifier set</a>, which keeps track of the identifiers within a given module that should be considered “privileged”.</p>
|
||
|
||
<div class="brush: racket">
|
||
<table class="sourcetable">
|
||
<tbody>
|
||
<tr>
|
||
<td class="linenos">
|
||
<div class="linenodiv">
|
||
<pre> 1
|
||
2
|
||
3
|
||
4
|
||
5
|
||
6
|
||
7
|
||
8
|
||
9
|
||
10
|
||
11
|
||
12
|
||
13
|
||
14</pre></div></td>
|
||
<td class="code">
|
||
<div class="source">
|
||
<pre><span></span><span class="kn">#lang </span><span class="nn">racket/base</span>
|
||
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/require.html#(form._((lib._racket/private/base..rkt)._require))" style="color: inherit">require</a></span> <span class="n">syntax/id-set</span><span class="p">)</span>
|
||
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/require.html#(form._((lib._racket/private/base..rkt)._provide))" style="color: inherit">provide</a></span> <span class="n">mark-id-as-privileged!</span>
|
||
<span class="n">id-privileged?</span><span class="p">)</span>
|
||
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit">define</a></span> <span class="n">privileged-ids</span> <span class="p">(</span><span class="n">mutable-free-id-set</span><span class="p">))</span>
|
||
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit">define</a></span> <span class="p">(</span><span class="n">mark-id-as-privileged!</span> <span class="n"><a href="http://docs.racket-lang.org/syntax/Library_Syntax_Classes_and_Literal_Sets.html#(form._((lib._syntax/parse..rkt)._id))" style="color: inherit">id</a></span><span class="p">)</span>
|
||
<span class="p">(</span><span class="n">free-id-set-add!</span> <span class="n">privileged-ids</span> <span class="n"><a href="http://docs.racket-lang.org/syntax/Library_Syntax_Classes_and_Literal_Sets.html#(form._((lib._syntax/parse..rkt)._id))" style="color: inherit">id</a></span><span class="p">))</span>
|
||
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit">define</a></span> <span class="p">(</span><span class="n">id-privileged?</span> <span class="n"><a href="http://docs.racket-lang.org/syntax/Library_Syntax_Classes_and_Literal_Sets.html#(form._((lib._syntax/parse..rkt)._id))" style="color: inherit">id</a></span><span class="p">)</span>
|
||
<span class="p">(</span><span class="n">free-id-set-member?</span> <span class="n">privileged-ids</span> <span class="n"><a href="http://docs.racket-lang.org/syntax/Library_Syntax_Classes_and_Literal_Sets.html#(form._((lib._syntax/parse..rkt)._id))" style="color: inherit">id</a></span><span class="p">))</span>
|
||
</pre></div>
|
||
</td></tr></tbody></table>
|
||
</div>
|
||
|
||
<p>Making this work with <code>define-generic</code> is obvious: just invoke <code>mark-id-as-privileged!</code> on the method name to note that the method is “privileged” in the scope of the current module. Keeping track of privileged structs is similarly straightforward, though it is a little more devious: the <code>multimethod</code> module provides a custom <code>struct</code> macro that just expands to <code>struct</code> from <code>racket/base</code>, but adds privilege information.</p>
|
||
|
||
<p>The <code>define-instance</code> macro does all the heavy lifting to ensure that only privileged identifiers can be used in instance definitions. A simple check for the identifier annotations is performed before proceeding with macro expansion:</p>
|
||
|
||
<div class="brush: racket">
|
||
<table class="sourcetable">
|
||
<tbody>
|
||
<tr>
|
||
<td class="linenos">
|
||
<div class="linenodiv">
|
||
<pre>1
|
||
2</pre></div></td>
|
||
<td class="code">
|
||
<div class="source">
|
||
<pre><span></span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/when_unless.html#(form._((lib._racket/private/letstx-scheme..rkt)._unless))" style="color: inherit">unless</a></span> <span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/if.html#(form._((lib._racket/private/letstx-scheme..rkt)._or))" style="color: inherit">or</a></span> <span class="n">privileged?</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/pairs.html#(def._((lib._racket/private/map..rkt)._ormap))" style="color: inherit">ormap</a></span> <span class="n">id-privileged?</span> <span class="n">types</span><span class="p">))</span>
|
||
<span class="p">(</span><span class="n">assert-privileged-struct!</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/pairs.html#(def._((lib._racket/list..rkt)._first))" style="color: inherit">first</a></span> <span class="n">types</span><span class="p">)))</span>
|
||
</pre></div>
|
||
</td></tr></tbody></table>
|
||
</div>
|
||
|
||
<p>When the privilege checks fail, an error is raised:</p>
|
||
|
||
<div class="brush: racket">
|
||
<table class="sourcetable">
|
||
<tbody>
|
||
<tr>
|
||
<td class="linenos">
|
||
<div class="linenodiv">
|
||
<pre>1
|
||
2
|
||
3
|
||
4
|
||
5</pre></div></td>
|
||
<td class="code">
|
||
<div class="source">
|
||
<pre><span></span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit">define</a></span> <span class="p">(</span><span class="n">assert-privileged-struct!</span> <span class="n"><a href="http://docs.racket-lang.org/syntax/Library_Syntax_Classes_and_Literal_Sets.html#(form._((lib._syntax/parse..rkt)._id))" style="color: inherit">id</a></span><span class="p">)</span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/when_unless.html#(form._((lib._racket/private/letstx-scheme..rkt)._unless))" style="color: inherit">unless</a></span> <span class="p">(</span><span class="n">id-privileged?</span> <span class="n"><a href="http://docs.racket-lang.org/syntax/Library_Syntax_Classes_and_Literal_Sets.html#(form._((lib._syntax/parse..rkt)._id))" style="color: inherit">id</a></span><span class="p">)</span>
|
||
<span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/exns.html#(def._((quote._~23~25kernel)._raise-syntax-error))" style="color: inherit">raise-syntax-error</a></span> <span class="o">'</span><span class="ss">define-instance</span>
|
||
<span class="s2">"expected name of <a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit">struct</a> defined in current module"</span>
|
||
<span class="n"><a href="http://docs.racket-lang.org/syntax/Library_Syntax_Classes_and_Literal_Sets.html#(form._((lib._syntax/parse..rkt)._id))" style="color: inherit">id</a></span><span class="p">)))</span>
|
||
</pre></div>
|
||
</td></tr></tbody></table>
|
||
</div>
|
||
|
||
<p>With the above safeguards in place, the dangerous dot product implementation from above <strong>would not be allowed</strong>. The checks manage to encode both of the safety rules into the macro system such that invalid instances will fail <em>at compile time</em>, preventing dangerous uses of multimethods from ever slipping by unnoticed.</p>
|
||
|
||
<h2 id="actually-implementing-multiple-dispatch">Actually implementing multiple dispatch</h2>
|
||
|
||
<p>The rest of the multimethod implementation is relatively straightforward and is not even particularly robust. If anything, it is the bare minimum of what would be needed to allow the safety mechanisms above to work. Lots of features that would likely be needed in a real implementation are not included, and graceful error handling is largely ignored.</p>
|
||
|
||
<p>Multimethods themselves are implemented as Racket <a href="http://docs.racket-lang.org/guide/proc-macros.html#%28tech._transformer._binding%29">transformer bindings</a> containing custom data, including a reference to the multimethod’s arity and dispatch table. The custom datatype includes a <code>prop:procedure</code> structure type property, which allows such bindings to also function as macros. The macro procedure expands to an operation that looks up the proper instance to use in the multimethod’s dispatch table and invokes it with the supplied arguments.</p>
|
||
|
||
<p>The relevant code for defining multimethods is reproduced below:</p>
|
||
|
||
<div class="brush: racket">
|
||
<table class="sourcetable">
|
||
<tbody>
|
||
<tr>
|
||
<td class="linenos">
|
||
<div class="linenodiv">
|
||
<pre> 1
|
||
2
|
||
3
|
||
4
|
||
5
|
||
6
|
||
7
|
||
8
|
||
9
|
||
10
|
||
11
|
||
12
|
||
13
|
||
14
|
||
15
|
||
16
|
||
17
|
||
18
|
||
19</pre></div></td>
|
||
<td class="code">
|
||
<div class="source">
|
||
<pre><span></span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin-for-syntax))" style="color: inherit">begin-for-syntax</a></span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit">struct</a></span> <span class="n">multimethod</span> <span class="p">(</span><span class="n">arity</span> <span class="n">dispatch-table</span><span class="p">)</span>
|
||
<span class="kd">#:property</span> <span class="nb"><a href="http://docs.racket-lang.org/reference/procedures.html#(def._((lib._racket/private/base..rkt)._prop~3aprocedure))" style="color: inherit">prop:procedure</a></span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/lambda.html#(form._((lib._racket/private/base..rkt)._~ce~bb))" style="color: inherit">λ</a></span> <span class="p">(</span><span class="n">method</span> <span class="n">stx</span><span class="p">)</span>
|
||
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/Parsing_Syntax.html#(form._((lib._syntax/parse..rkt)._syntax-parse))" style="color: inherit">syntax-parse</a></span> <span class="n">stx</span>
|
||
<span class="p">[(</span><span class="n">method</span> <span class="n">arg</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">)</span>
|
||
<span class="o">#'</span><span class="p">(</span><span class="n">apply-multimethod</span> <span class="n">method</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/pairs.html#(def._((quote._~23~25kernel)._list))" style="color: inherit">list</a></span> <span class="n">arg</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">))]</span>
|
||
<span class="p">[</span><span class="n">method</span>
|
||
<span class="o">#'</span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/lambda.html#(form._((lib._racket/private/base..rkt)._~ce~bb))" style="color: inherit">λ</a></span> <span class="n">args</span> <span class="p">(</span><span class="n">apply-multimethod</span> <span class="n">method</span> <span class="n">args</span><span class="p">))]))))</span>
|
||
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define-syntax))" style="color: inherit">define-syntax</a></span> <span class="n">define-generic</span>
|
||
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/Parsing_Syntax.html#(form._((lib._syntax/parse..rkt)._syntax-parser))" style="color: inherit">syntax-parser</a></span>
|
||
<span class="p">[(</span><span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt).__))" style="color: inherit">_</a></span> <span class="p">(</span><span class="n">method:id</span> <span class="n">arg:id</span> <span class="n"><a href="http://docs.racket-lang.org/syntax/stxparse-patterns.html#(form._((lib._syntax/parse..rkt)._......+))" style="color: inherit">...+</a></span><span class="p">))</span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._with-syntax))" style="color: inherit">with-syntax</a></span> <span class="p">([</span><span class="n">arity</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/pairs.html#(def._((quote._~23~25kernel)._length))" style="color: inherit">length</a></span> <span class="p">(</span><span class="n">attribute</span> <span class="n">arg</span><span class="p">))]</span>
|
||
<span class="p">[</span><span class="n">dispatch-table</span> <span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/reference/syntax-util.html#(def._((lib._racket/syntax..rkt)._generate-temporary))" style="color: inherit">generate-temporary</a></span> <span class="o">#'</span><span class="n">method</span><span class="p">)])</span>
|
||
<span class="p">(</span><span class="n">mark-id-as-privileged!</span> <span class="o">#'</span><span class="n">method</span><span class="p">)</span>
|
||
<span class="o">#'</span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin))" style="color: inherit">begin</a></span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit">define</a></span> <span class="n">dispatch-table</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/hashtables.html#(def._((quote._~23~25kernel)._make-hash))" style="color: inherit">make-hash</a></span><span class="p">))</span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define-syntax))" style="color: inherit">define-syntax</a></span> <span class="n">method</span> <span class="p">(</span><span class="n">multimethod</span> <span class="n">arity</span> <span class="o">#'</span><span class="n">dispatch-table</span><span class="p">))))]))</span>
|
||
</pre></div>
|
||
</td></tr></tbody></table>
|
||
</div>
|
||
|
||
<p>The dispatch tables are implemented entirely in terms of Racket’s structure types, so while they can be defined on arbitrary structure types (including ones defined in the Racket standard library), they <em>cannot</em> be defined on primitives such as pairs or vectors. Implementations are registered in the dispatch table using the compile-time information associated with structs’ transformer bindings, and the same information is retrieved from struct instances at runtime to look up the proper implementation to call. Notably, this only works if the struct is <code>#:transparent</code>, or more generally and accurately, if the calling code has access to the struct’s inspector. All structs defined by the <code>struct</code> form from the <code>multimethod</code> module are automatically marked as <code>#:transparent</code>.</p>
|
||
|
||
<p>The following code implements defining multimethod instances:</p>
|
||
|
||
<div class="brush: racket">
|
||
<table class="sourcetable">
|
||
<tbody>
|
||
<tr>
|
||
<td class="linenos">
|
||
<div class="linenodiv">
|
||
<pre> 1
|
||
2
|
||
3
|
||
4
|
||
5
|
||
6
|
||
7
|
||
8
|
||
9
|
||
10
|
||
11
|
||
12
|
||
13
|
||
14
|
||
15
|
||
16
|
||
17
|
||
18
|
||
19
|
||
20
|
||
21
|
||
22
|
||
23</pre></div></td>
|
||
<td class="code">
|
||
<div class="source">
|
||
<pre><span></span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin-for-syntax))" style="color: inherit">begin-for-syntax</a></span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit">define</a></span> <span class="p">(</span><span class="n">assert-privileged-struct!</span> <span class="n"><a href="http://docs.racket-lang.org/syntax/Library_Syntax_Classes_and_Literal_Sets.html#(form._((lib._syntax/parse..rkt)._id))" style="color: inherit">id</a></span><span class="p">)</span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/when_unless.html#(form._((lib._racket/private/letstx-scheme..rkt)._unless))" style="color: inherit">unless</a></span> <span class="p">(</span><span class="n">id-privileged?</span> <span class="n"><a href="http://docs.racket-lang.org/syntax/Library_Syntax_Classes_and_Literal_Sets.html#(form._((lib._syntax/parse..rkt)._id))" style="color: inherit">id</a></span><span class="p">)</span>
|
||
<span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/exns.html#(def._((quote._~23~25kernel)._raise-syntax-error))" style="color: inherit">raise-syntax-error</a></span> <span class="o">'</span><span class="ss">define-instance</span>
|
||
<span class="s2">"expected name of <a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit">struct</a> defined in current module"</span>
|
||
<span class="n"><a href="http://docs.racket-lang.org/syntax/Library_Syntax_Classes_and_Literal_Sets.html#(form._((lib._syntax/parse..rkt)._id))" style="color: inherit">id</a></span><span class="p">))))</span>
|
||
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define-syntax))" style="color: inherit">define-syntax</a></span> <span class="n">define-instance</span>
|
||
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/Parsing_Syntax.html#(form._((lib._syntax/parse..rkt)._syntax-parser))" style="color: inherit">syntax-parser</a></span>
|
||
<span class="c1">; standard (define (proc ...) ...) shorthand</span>
|
||
<span class="p">[(</span><span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt).__))" style="color: inherit">_</a></span> <span class="p">((</span><span class="n">method</span> <span class="n">type:id</span> <span class="n"><a href="http://docs.racket-lang.org/syntax/stxparse-patterns.html#(form._((lib._syntax/parse..rkt)._......+))" style="color: inherit">...+</a></span><span class="p">)</span> <span class="o">.</span> <span class="n">args</span><span class="p">)</span> <span class="n">body:expr</span> <span class="n"><a href="http://docs.racket-lang.org/syntax/stxparse-patterns.html#(form._((lib._syntax/parse..rkt)._......+))" style="color: inherit">...+</a></span><span class="p">)</span>
|
||
<span class="o">#'</span><span class="p">(</span><span class="n">define-instance</span> <span class="p">(</span><span class="n">method</span> <span class="n">type</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">)</span> <span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/lambda.html#(form._((lib._racket/private/base..rkt)._~ce~bb))" style="color: inherit">λ</a></span> <span class="n">args</span> <span class="n">body</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">))]</span>
|
||
<span class="c1">; full (define proc lambda-expr) notation</span>
|
||
<span class="p">[(</span><span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt).__))" style="color: inherit">_</a></span> <span class="p">(</span><span class="n">method</span> <span class="n">type:id</span> <span class="n"><a href="http://docs.racket-lang.org/syntax/stxparse-patterns.html#(form._((lib._syntax/parse..rkt)._......+))" style="color: inherit">...+</a></span><span class="p">)</span> <span class="n">proc:expr</span><span class="p">)</span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/let.html#(form._((lib._racket/private/letstx-scheme..rkt)._let*))" style="color: inherit">let*</a></span> <span class="p">([</span><span class="n">multimethod</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/stxtrans.html#(def._((quote._~23~25kernel)._syntax-local-value))" style="color: inherit">syntax-local-value</a></span> <span class="o">#'</span><span class="n">method</span><span class="p">)]</span>
|
||
<span class="p">[</span><span class="n">privileged?</span> <span class="p">(</span><span class="n">id-privileged?</span> <span class="o">#'</span><span class="n">method</span><span class="p">)])</span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/when_unless.html#(form._((lib._racket/private/letstx-scheme..rkt)._unless))" style="color: inherit">unless</a></span> <span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/if.html#(form._((lib._racket/private/letstx-scheme..rkt)._or))" style="color: inherit">or</a></span> <span class="n">privileged?</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/pairs.html#(def._((lib._racket/private/map..rkt)._ormap))" style="color: inherit">ormap</a></span> <span class="n">id-privileged?</span> <span class="p">(</span><span class="n">attribute</span> <span class="n">type</span><span class="p">)))</span>
|
||
<span class="p">(</span><span class="n">assert-privileged-struct!</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/pairs.html#(def._((lib._racket/list..rkt)._first))" style="color: inherit">first</a></span> <span class="p">(</span><span class="n">attribute</span> <span class="n">type</span><span class="p">))))</span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._with-syntax))" style="color: inherit">with-syntax</a></span> <span class="p">([</span><span class="n">dispatch-table</span> <span class="p">(</span><span class="n">multimethod-dispatch-table</span> <span class="n">multimethod</span><span class="p">)]</span>
|
||
<span class="p">[(</span><span class="n">struct-type-id</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">)</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/pairs.html#(def._((lib._racket/private/map..rkt)._map))" style="color: inherit">map</a></span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/procedures.html#(def._((lib._racket/private/list..rkt)._compose1))" style="color: inherit">compose1</a></span> <span class="nb"><a href="http://docs.racket-lang.org/reference/pairs.html#(def._((lib._racket/list..rkt)._first))" style="color: inherit">first</a></span> <span class="n"><a href="http://docs.racket-lang.org/reference/structinfo.html#(def._((lib._racket/struct-info..rkt)._extract-struct-info))" style="color: inherit">extract-struct-info</a></span> <span class="nb"><a href="http://docs.racket-lang.org/reference/stxtrans.html#(def._((quote._~23~25kernel)._syntax-local-value))" style="color: inherit">syntax-local-value</a></span><span class="p">)</span>
|
||
<span class="p">(</span><span class="n">attribute</span> <span class="n">type</span><span class="p">))])</span>
|
||
<span class="o">#'</span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/let.html#(form._((lib._racket/private/letstx-scheme..rkt)._let))" style="color: inherit">let</a></span> <span class="p">([</span><span class="n">struct-types</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/pairs.html#(def._((quote._~23~25kernel)._list))" style="color: inherit">list</a></span> <span class="n">struct-type-id</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">)])</span>
|
||
<span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/hashtables.html#(def._((quote._~23~25kernel)._hash-set!))" style="color: inherit">hash-set!</a></span> <span class="n">dispatch-table</span> <span class="n">struct-types</span> <span class="n">proc</span><span class="p">))))]))</span>
|
||
</pre></div>
|
||
</td></tr></tbody></table>
|
||
</div>
|
||
|
||
<p>The resulting implementation is a useful, if certainly incomplete implementation of multimethods in Racket that does not sacrifice the safety provided by <code>racket/generic</code>’s single-dispatch approach.</p>
|
||
|
||
<h1 id="related-work-advantages-and-disadvantages-and-areas-for-future-improvement">Related work, advantages and disadvantages, and areas for future improvement</h1>
|
||
|
||
<p>As previously mentioned, this implementation of multiple dispatch was inspired by the types of APIs offered by CLOS and Clojure while also maintaining the safety of <code>racket/generic</code>. The inspiration for the safety rules came from GHC’s detection of orphan instances. Although most of the ideas presented above exist in other places, I am unsure if the concept of safety checking has been used before in any dynamically-typed programming languages.</p>
|
||
|
||
<p>The primary advantage offered over Racket’s existing generics system is obvious: multiple dispatch. Furthermore, this system can supersede many uses of <code>racket/generic</code> simply by dispatching on a single type. However, the current implementation does <em>not</em> support all of the features of <code>racket/generic</code>, such as supporting non-structure types and allowing fallback implementations. While those are well within the realm of possibility, other things like attaching structure type properties are probably not possible with this approach, so it is unlikely that the existing system could be subsumed by one like this one.</p>
|
||
|
||
<p>Additionally, this implementation would almost certainly need numerous improvements before being useful to most programmers:</p>
|
||
|
||
<ul>
|
||
<li>
|
||
<p><strong>Good error reporting for failure cases.</strong> Right now, even something obvious like calling a method on values that do not implement it simply fails with an error produced by <code>hash-ref</code>. In a more interesting sense, using the arity to generate compile-time error messages for <code>define-instance</code> would be a nice improvement.</p></li>
|
||
<li>
|
||
<p><strong>Support for Racket primitive data types.</strong> This might require some cooperation from Racket itself to permit an elegant implementation, but they could also just be special-cased. So long as lookup for primitives was done <em>after</em> consulting the main dispatch table, there wouldn’t be any performance hit for non-primitive types.</p></li>
|
||
<li>
|
||
<p><strong>Option to supply fallback implementations.</strong> This wouldn’t be too hard at all, though it’s questionable whether or not it would be useful without method groupings like <code>define/generic</code> provides. There would likely also need to be some sort of way to check if a set of values implements a particular method.</p></li>
|
||
<li>
|
||
<p><strong>Better cooperation with structure inspectors to alleviate the need for all structures to be transparent.</strong> It’s currently unclear to me how exactly this works and how it <em>should</em> work. There might be a better way to do this without mucking with inspectors.</p></li>
|
||
<li>
|
||
<p><strong>Much more flexible argument lists, including the ability to specify arguments that are not used for dispatch.</strong> This is really a pretty fundamental requirement, but the parsing required was significant enough for me to put it off for this initial prototype.</p></li>
|
||
<li>
|
||
<p><strong>Scribble forms to document generic methods and their instances.</strong> This is something <code>racket/generic</code> <em>doesn’t</em> have, and it has suffered for it. It would be very nice to have easy documentation forms for multimethods.</p></li>
|
||
<li>
|
||
<p><strong>Proper consideration of struct subtyping.</strong> Racket structs support subtyping, which I have not given much thought for this prototype. It is possible that subtyping violates constraints I had assumed would hold, so reviewing the existing code with that context would be useful.</p></li></ul>
|
||
|
||
<p>I’m not sure how much effort is involved in most of the above ideas, and in fact I’m not even completely sure how useful this system is to begin with. I have not found myself reaching much for multiple dispatch in my time as a Racket programmer, but that could simply be because it was previously unavailable. It will be interesting to see if that changes now that I have built this system, even if it is a bit rough around the edges.</p>
|
||
|
||
<h1 id="conclusion">Conclusion</h1>
|
||
|
||
<p>Despite the lack of need for multiple dispatch to solve most problems, as indicated by its general lack of support in mainstream programming languages, it’s a nice tool to have in the toolbox, and it <em>is</em> asked for in the Racket community from time to time (perhaps due to its familiarity in other parts of the Lisp world). Time will tell if pointing people to something like this will create or stifle interest in multiple dispatch for Racket.</p>
|
||
|
||
<p>The source for the <a href="https://github.com/lexi-lambda/racket-multimethod"><code>multimethod</code> package can be found here</a> if you are at all interested in playing with it yourself.</p></html></content></entry>
|
||
<entry>
|
||
<title type="text">ADTs in Typed Racket with macros</title>
|
||
<link rel="alternate" href="http://lexi-lambda.github.io/blog/2015/12/21/adts-in-typed-racket-with-macros/?utm_source=macros&utm_medium=Atom" />
|
||
<id>urn:http-lexi-lambda-github-io:-blog-2015-12-21-adts-in-typed-racket-with-macros</id>
|
||
<published>2015-12-21T17:57:07Z</published>
|
||
<updated>2015-12-21T17:57:07Z</updated>
|
||
<author>
|
||
<name>Alexis King</name></author>
|
||
<content type="html"><html>
|
||
<p>Macros are one of Racket&rsquo;s flagship features, and its macro system really is state of the art. Of course, it can sometimes be difficult to demonstrate <em>why</em> macros are so highly esteemed, in part because it can be hard to find self-contained examples of using macros in practice. Of course, one thing that macros are perfect for is filling a &ldquo;hole&rdquo; in the language by introducing a feature a language lacks, and one of those features in Typed Racket is <strong>ADTs</strong>.</p>
|
||
<!-- more-->
|
||
|
||
<h1 id="warning-this-is-not-a-macro-tutorial">Warning: this is not a macro tutorial</h1>
|
||
|
||
<p>First, a disclaimer: this post assumes at least some knowledge of Scheme/Racket macros. Ideally, you would be familiar with Racket itself. But if you aren&rsquo;t, fear not: if you get lost, don&rsquo;t worry. Hold on to the bigger picture, and you&rsquo;ll likely learn more than someone who knows enough to follow all the way through. If you <em>are</em> interested in learning about macros, I must recommend Greg Hendershott&rsquo;s <a href="http://www.greghendershott.com/fear-of-macros/">Fear of Macros</a>. It is good. This is not that.</p>
|
||
|
||
<p>Now, with that out of the way, let&rsquo;s get started.</p>
|
||
|
||
<h1 id="what-were-building">What we&rsquo;re building</h1>
|
||
|
||
<p><a href="https://en.wikipedia.org/wiki/Algebraic_data_type">Algebraic data types</a>, or <em>ADTs</em>, are a staple of the ML family of functional programming languages. I won&rsquo;t go into detail here—I want to focus on the implementation—but they&rsquo;re a very descriptive way of modeling data that encourages designing functions in terms of pattern-matching, something that Racket is already good at.</p>
|
||
|
||
<p>Racket also already has a facility for creating custom data structures in the form of <em>structs</em>, which are extremely flexible, but also a little verbose. Racket structs are more powerful than we need, but that means we can implement our ADTs in terms of Racket&rsquo;s struct system.</p>
|
||
|
||
<p>With that in mind, what should our syntax look like? Well, let&rsquo;s consider a quintessential example of ADTs: modeling a simple tree. For now, let&rsquo;s just consider a tree of integers. For reference, the Haskell syntax for such a data structure would look like this:</p>
|
||
|
||
<div class="brush: haskell">
|
||
<table class="sourcetable">
|
||
<tbody>
|
||
<tr>
|
||
<td class="linenos">
|
||
<div class="linenodiv">
|
||
<pre>1
|
||
2
|
||
3</pre></div></td>
|
||
<td class="code">
|
||
<div class="source">
|
||
<pre><span></span><span class="kr">data</span> <span class="kt">Tree</span> <span class="ow">=</span> <span class="kt">Empty</span>
|
||
<span class="o">|</span> <span class="kt">Leaf</span> <span class="kt">Int</span>
|
||
<span class="o">|</span> <span class="kt">Node</span> <span class="kt">Tree</span> <span class="kt">Tree</span>
|
||
</pre></div>
|
||
</td></tr></tbody></table>
|
||
</div>
|
||
|
||
<p>This already demonstrates a few of the core things we&rsquo;ll need to build:</p>
|
||
|
||
<ol>
|
||
<li>Each ADT has a <em>data type</em>, in this case <code>Tree</code>. This name only exists in the world of types, it isn&rsquo;t a value.</li>
|
||
<li>Each ADT has various <em>data constructors</em>, in this case <code>Leaf</code> and <code>Node</code>.</li>
|
||
<li>Each data constructor may accept any number of arguments, each of which have a specific type.</li>
|
||
<li>The types that data constructors may accept include the ADT&rsquo;s datatype itself—that is, definitions can be recursive.</li></ol>
|
||
|
||
<p>Of course, there&rsquo;s one more important feature we&rsquo;re missing: polymorphism. Our definition of a tree is overly-specific, and really, it should be able to hold any kind of data, not just integers. In Haskell, we can do that by adding a type parameter:</p>
|
||
|
||
<div class="brush: haskell">
|
||
<table class="sourcetable">
|
||
<tbody>
|
||
<tr>
|
||
<td class="linenos">
|
||
<div class="linenodiv">
|
||
<pre>1
|
||
2
|
||
3</pre></div></td>
|
||
<td class="code">
|
||
<div class="source">
|
||
<pre><span></span><span class="kr">data</span> <span class="kt">Tree</span> <span class="n">a</span> <span class="ow">=</span> <span class="kt">Empty</span>
|
||
<span class="o">|</span> <span class="kt">Leaf</span> <span class="n">a</span>
|
||
<span class="o">|</span> <span class="kt">Node</span> <span class="p">(</span><span class="kt">Tree</span> <span class="n">a</span><span class="p">)</span> <span class="p">(</span><span class="kt">Tree</span> <span class="n">a</span><span class="p">)</span>
|
||
</pre></div>
|
||
</td></tr></tbody></table>
|
||
</div>
|
||
|
||
<p>With this in mind, we can add a fifth and final point to our list:</p>
|
||
|
||
<p>
|
||
<ol start="5">
|
||
<li>ADTs must be able to be parametrically polymorphic.</li></ol></p>
|
||
|
||
<p>That covers all of our requirements for basic ADTs. Now we&rsquo;re ready to port this idea to Racket.</p>
|
||
|
||
<h2 id="describing-adts-in-racket">Describing ADTs in Racket</h2>
|
||
|
||
<p>How should we take the Haskell syntax for an ADT definition and adapt it to Racket&rsquo;s parenthetical s-expressions? By taking some cues from the Haskell implementation, Typed Racket&rsquo;s type syntax, and Racket&rsquo;s naming conventions, a fairly logical syntax emerges:</p>
|
||
|
||
<div class="brush: racket">
|
||
<table class="sourcetable">
|
||
<tbody>
|
||
<tr>
|
||
<td class="linenos">
|
||
<div class="linenodiv">
|
||
<pre>1
|
||
2
|
||
3
|
||
4</pre></div></td>
|
||
<td class="code">
|
||
<div class="source">
|
||
<pre><span></span><span class="p">(</span><span class="n">define-datatype</span> <span class="p">(</span><span class="n">Tree</span> <span class="n">a</span><span class="p">)</span>
|
||
<span class="n">Empty</span>
|
||
<span class="p">(</span><span class="n">Leaf</span> <span class="n">a</span><span class="p">)</span>
|
||
<span class="p">(</span><span class="n">Node</span> <span class="p">(</span><span class="n">Tree</span> <span class="n">a</span><span class="p">)</span> <span class="p">(</span><span class="n">Tree</span> <span class="n">a</span><span class="p">)))</span>
|
||
</pre></div>
|
||
</td></tr></tbody></table>
|
||
</div>
|
||
|
||
<p>This looks pretty good. Just like with the Haskell implementation, <code>Tree</code> should only exist at the type level, and <code>Empty</code>, <code>Leaf</code>, and <code>Node</code> should be constructor functions. Our syntax mirrors Racket function application, too—the proper way to create a leaf would be <code>(Leaf 7)</code>.</p>
|
||
|
||
<p>Now that we can create ADT values, how should we extract the values from them? Well, just like in ML-likes, we can use pattern-matching. We don&rsquo;t need to reinvent the wheel for this one; we should be able to just use Racket&rsquo;s <code><a href="http://docs.racket-lang.org/reference/match.html#(form._((lib._racket/match..rkt)._match))" style="color: inherit">match</a></code> with our datatypes. For example, a function that sums all the values in a tree might look like this:</p>
|
||
|
||
<div class="brush: racket">
|
||
<table class="sourcetable">
|
||
<tbody>
|
||
<tr>
|
||
<td class="linenos">
|
||
<div class="linenodiv">
|
||
<pre>1
|
||
2
|
||
3
|
||
4
|
||
5
|
||
6
|
||
7</pre></div></td>
|
||
<td class="code">
|
||
<div class="source">
|
||
<pre><span></span><span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit">:</a></span> <span class="n">tree-sum</span> <span class="p">((</span><span class="n">Tree</span> <span class="n"><a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Integer))" style="color: inherit">Integer</a></span><span class="p">)</span> <span class="k"><a href="http://docs.racket-lang.org/reference/function-contracts.html#(form._((lib._racket/contract/base..rkt)._-~3e))" style="color: inherit">-&gt;</a></span> <span class="n"><a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Integer))" style="color: inherit">Integer</a></span><span class="p">))</span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit">define</a></span> <span class="p">(</span><span class="n">tree-sum</span> <span class="n">tree</span><span class="p">)</span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/match.html#(form._((lib._racket/match..rkt)._match))" style="color: inherit">match</a></span> <span class="n">tree</span>
|
||
<span class="p">[(</span><span class="n">Empty</span><span class="p">)</span> <span class="mi">0</span> <span class="p">]</span>
|
||
<span class="p">[(</span><span class="n">Leaf</span> <span class="n">n</span><span class="p">)</span> <span class="n">n</span> <span class="p">]</span>
|
||
<span class="p">[(</span><span class="n">Node</span> <span class="n">l</span> <span class="n">r</span><span class="p">)</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._+))" style="color: inherit">+</a></span> <span class="p">(</span><span class="n">tree-sum</span> <span class="n">l</span><span class="p">)</span>
|
||
<span class="p">(</span><span class="n">tree-sum</span> <span class="n">r</span><span class="p">))]))</span>
|
||
</pre></div>
|
||
</td></tr></tbody></table>
|
||
</div>
|
||
|
||
<p>Given that Racket&rsquo;s <code>struct</code> form automatically produces identifiers that cooperate with <code>match</code>, this shouldn&rsquo;t be hard at all. And with our syntax settled, we&rsquo;re ready to begin implementation.</p>
|
||
|
||
<h1 id="implementing-adts-as-syntax">Implementing ADTs as syntax</h1>
|
||
|
||
<p>Now for the fun part. To implement our ADT syntax, we&rsquo;ll employ Racket&rsquo;s industrial-strength macro DSL, <a href="http://docs.racket-lang.org/syntax/stxparse.html"><code>syntax/parse</code></a>. The <code>syntax/parse</code> library works like the traditional Scheme <code>syntax-case</code> on steroids, and one of the most useful features is the ability to define &ldquo;syntax classes&rdquo; that encapsulate reusable parsing rules into declarative components.</p>
|
||
|
||
<p>Since this is not a macro tutorial, the following implementation assumes you already know how to use <code>syntax/parse</code>. However, all of the concepts here are well within the reaches of any intermediate macrologist, so don&rsquo;t be intimidated by some of the more complex topics at play.</p>
|
||
|
||
<h2 id="parsing-types-with-a-syntax-class">Parsing types with a syntax class</h2>
|
||
|
||
<p>To implement ADTs, we&rsquo;re going to want to define exactly one syntax class, a class that describes the grammar for a type. As we&rsquo;ve seen, types can be bare identifiers, like <code>Tree</code>, or they can be identifiers with parameters, like <code>(Tree a)</code>. We&rsquo;ll want to cover both cases.</p>
|
||
|
||
<div class="brush: racket">
|
||
<table class="sourcetable">
|
||
<tbody>
|
||
<tr>
|
||
<td class="linenos">
|
||
<div class="linenodiv">
|
||
<pre>1
|
||
2
|
||
3
|
||
4</pre></div></td>
|
||
<td class="code">
|
||
<div class="source">
|
||
<pre><span></span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin-for-syntax))" style="color: inherit">begin-for-syntax</a></span>
|
||
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._define-syntax-class))" style="color: inherit">define-syntax-class</a></span> <span class="n">type</span>
|
||
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._pattern))" style="color: inherit">pattern</a></span> <span class="n">name:id</span> <span class="kd">#:attr</span> <span class="p">[</span><span class="n">param</span> <span class="mi">1</span><span class="p">]</span> <span class="o">'</span><span class="p">())</span>
|
||
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._pattern))" style="color: inherit">pattern</a></span> <span class="p">(</span><span class="n">name:id</span> <span class="n">param</span> <span class="n"><a href="http://docs.racket-lang.org/syntax/stxparse-patterns.html#(form._((lib._syntax/parse..rkt)._......+))" style="color: inherit">...+</a></span><span class="p">))))</span>
|
||
</pre></div>
|
||
</td></tr></tbody></table>
|
||
</div>
|
||
|
||
<p>This syntax class has two rules, one that&rsquo;s a bare identifier, and one that&rsquo;s a list. The ellipsis followed by a plus (<code>...+</code>) in the second example means &ldquo;one or more&rdquo;, so parsing those parameters will automatically be handled for us. In the bare identifier example, we use <code>#:attr</code> to give the <code>param</code> attribute the default value of an empty list, so this syntax class will actually <em>normalize</em> the input we get in addition to actually parsing it.</p>
|
||
|
||
<h2 id="a-first-attempt-at-define-datatype">A first attempt at <code>define-datatype</code></h2>
|
||
|
||
<p>Now we can move on to actually implementing <code>define-datatype</code>. The rules are simple: we need to generate a structure type for each one of the data constructors, and we need to generate a type definition for the parent type itself. This is pretty simple to implement using <code>syntax-parser</code>, which actually does the parsing for our macro.</p>
|
||
|
||
<div class="brush: racket">
|
||
<table class="sourcetable">
|
||
<tbody>
|
||
<tr>
|
||
<td class="linenos">
|
||
<div class="linenodiv">
|
||
<pre>1
|
||
2
|
||
3
|
||
4</pre></div></td>
|
||
<td class="code">
|
||
<div class="source">
|
||
<pre><span></span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define-syntax))" style="color: inherit">define-syntax</a></span> <span class="n">define-datatype</span>
|
||
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/Parsing_Syntax.html#(form._((lib._syntax/parse..rkt)._syntax-parser))" style="color: inherit">syntax-parser</a></span>
|
||
<span class="p">[(</span><span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt).__))" style="color: inherit">_</a></span> <span class="n">type-name:type</span> <span class="n">data-constructor:type</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">)</span>
|
||
<span class="p">]))</span>
|
||
</pre></div>
|
||
</td></tr></tbody></table>
|
||
</div>
|
||
|
||
<p>This definition will do all the parsing we need. It parses the entire macro &ldquo;invocation&rdquo;, ignoring the first datum with <code>_</code> (which will just be the identifier <code>define-datatype</code>), then expecting a <code>type-name</code>, which uses the <code>type</code> syntax class we defined above. Next, we expect zero or more <code>data-constructor</code>s, which also use the <code>type</code> syntax class. That&rsquo;s all we have to do for parsing. We now have all the information we need to actually output the expansion for the macro.</p>
|
||
|
||
<p>Of course, it won&rsquo;t be that easy: this is the difficult part. The first step is to generate a Racket struct for each data constructor. We can do this pretty easily with some simple use of Racket&rsquo;s syntax templating facility. A naïve attempt would look like this:</p>
|
||
|
||
<div class="brush: racket">
|
||
<table class="sourcetable">
|
||
<tbody>
|
||
<tr>
|
||
<td class="linenos">
|
||
<div class="linenodiv">
|
||
<pre>1
|
||
2
|
||
3
|
||
4
|
||
5
|
||
6</pre></div></td>
|
||
<td class="code">
|
||
<div class="source">
|
||
<pre><span></span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define-syntax))" style="color: inherit">define-syntax</a></span> <span class="n">define-datatype</span>
|
||
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/Parsing_Syntax.html#(form._((lib._syntax/parse..rkt)._syntax-parser))" style="color: inherit">syntax-parser</a></span>
|
||
<span class="p">[(</span><span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt).__))" style="color: inherit">_</a></span> <span class="n">type-name:type</span> <span class="n">data-constructor:type</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">)</span>
|
||
<span class="o">#'</span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin))" style="color: inherit">begin</a></span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit">struct</a></span> <span class="n">data-constructor.name</span> <span class="p">([</span><span class="n">f</span> <span class="n"><a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit">:</a></span> <span class="n">data-constructor.param</span><span class="p">]</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">)</span>
|
||
<span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">))]))</span>
|
||
</pre></div>
|
||
</td></tr></tbody></table>
|
||
</div>
|
||
|
||
<p>This is actually really close to being correct. This will generate a struct definition for each <code>data-constructor</code>, where each struct has the name of the data constructor and the same number of fields as arguments provided. The trouble is that in Racket structs, all of the fields have <em>names</em>, but in our ADTs, all the fields are anonymous and by-position. Currently, we&rsquo;re just using the same name for <em>all</em> the fields, <code>f</code>, so if any data constructor has two or more fields, we&rsquo;ll get an error.</p>
|
||
|
||
<p>Since we don&rsquo;t care about the field names, what we want to do is just generate random names for every field. To do this, we can use a Racket function called <code>generate-temporary</code>, which generates random identifiers. Our next attempt might look like this:</p>
|
||
|
||
<div class="brush: racket">
|
||
<table class="sourcetable">
|
||
<tbody>
|
||
<tr>
|
||
<td class="linenos">
|
||
<div class="linenodiv">
|
||
<pre>1
|
||
2
|
||
3
|
||
4</pre></div></td>
|
||
<td class="code">
|
||
<div class="source">
|
||
<pre><span></span><span class="o">#`</span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin))" style="color: inherit">begin</a></span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit">struct</a></span> <span class="n">data-constructor.name</span>
|
||
<span class="p">([</span><span class="o">#,</span><span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/reference/syntax-util.html#(def._((lib._racket/syntax..rkt)._generate-temporary))" style="color: inherit">generate-temporary</a></span><span class="p">)</span> <span class="n"><a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit">:</a></span> <span class="n">data-constructor.param</span><span class="p">]</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">)</span>
|
||
<span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">))</span>
|
||
</pre></div>
|
||
</td></tr></tbody></table>
|
||
</div>
|
||
|
||
<p>The <code>#,</code> lets us &ldquo;escape&rdquo; from the template to execute <code>(generate-temporary)</code> and interpolate its result into the syntax. Unfortunately, this doesn&rsquo;t work. We <em>do</em> generate a random field name, but the ellipsis will re-use the same generated value when it repeats the fields, rendering our whole effort pointless. We need to generate the field names once per type.</p>
|
||
|
||
<h2 id="more-leveraging-syntax-classes">More leveraging syntax classes</h2>
|
||
|
||
<p>As it turns out, this is <em>also</em> easy to do with syntax classes. We can add an extra attribute to our <code>type</code> syntax class to generate a random identifier with each one. Again, we can use <code>#:attr</code> to do that automatically. Our new definition for <code>type</code> will look like this:</p>
|
||
|
||
<div class="brush: racket">
|
||
<table class="sourcetable">
|
||
<tbody>
|
||
<tr>
|
||
<td class="linenos">
|
||
<div class="linenodiv">
|
||
<pre>1
|
||
2
|
||
3
|
||
4
|
||
5
|
||
6
|
||
7</pre></div></td>
|
||
<td class="code">
|
||
<div class="source">
|
||
<pre><span></span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin-for-syntax))" style="color: inherit">begin-for-syntax</a></span>
|
||
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._define-syntax-class))" style="color: inherit">define-syntax-class</a></span> <span class="n">type</span>
|
||
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._pattern))" style="color: inherit">pattern</a></span> <span class="n">name:id</span>
|
||
<span class="kd">#:attr</span> <span class="p">[</span><span class="n">param</span> <span class="mi">1</span><span class="p">]</span> <span class="o">'</span><span class="p">()</span>
|
||
<span class="kd">#:attr</span> <span class="p">[</span><span class="n">field-id</span> <span class="mi">1</span><span class="p">]</span> <span class="o">'</span><span class="p">())</span>
|
||
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._pattern))" style="color: inherit">pattern</a></span> <span class="p">(</span><span class="n">name:id</span> <span class="n">param</span> <span class="n"><a href="http://docs.racket-lang.org/syntax/stxparse-patterns.html#(form._((lib._syntax/parse..rkt)._......+))" style="color: inherit">...+</a></span><span class="p">)</span>
|
||
<span class="kd">#:attr</span> <span class="p">[</span><span class="n">field-id</span> <span class="mi">1</span><span class="p">]</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/stxops.html#(def._((lib._racket/private/stxcase-scheme..rkt)._generate-temporaries))" style="color: inherit">generate-temporaries</a></span> <span class="o">#'</span><span class="p">(</span><span class="n">param</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">)))))</span>
|
||
</pre></div>
|
||
</td></tr></tbody></table>
|
||
</div>
|
||
|
||
<p>Here we&rsquo;re using <code>generate-temporaries</code> instead of <code>generate-temporary</code>, which will conveniently generate a new identifier for each of the elements in the list we provide it. This way, we&rsquo;ll get a fresh identifier for each <code>param</code>.</p>
|
||
|
||
<p>We can now fix our macro to use this <code>field-id</code> attribute instead of the static field name:</p>
|
||
|
||
<div class="brush: racket">
|
||
<table class="sourcetable">
|
||
<tbody>
|
||
<tr>
|
||
<td class="linenos">
|
||
<div class="linenodiv">
|
||
<pre>1
|
||
2
|
||
3
|
||
4</pre></div></td>
|
||
<td class="code">
|
||
<div class="source">
|
||
<pre><span></span><span class="o">#'</span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin))" style="color: inherit">begin</a></span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit">struct</a></span> <span class="n">data-constructor.name</span>
|
||
<span class="p">([</span><span class="n">data-constructor.field-id</span> <span class="n"><a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit">:</a></span> <span class="n">data-constructor.param</span><span class="p">]</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">))</span>
|
||
<span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">)</span>
|
||
</pre></div>
|
||
</td></tr></tbody></table>
|
||
</div>
|
||
|
||
<h2 id="creating-the-supertype">Creating the supertype</h2>
|
||
|
||
<p>We&rsquo;re almost done—now we just need to implement our overall type, the one defined by <code>type-name</code>. This is implemented as a trivial type alias, but we need to ensure that polymorphic types are properly handled. For example, a non-polymorphic type would need to be handled like this:</p>
|
||
|
||
<div class="brush: racket">
|
||
<table class="sourcetable">
|
||
<tbody>
|
||
<tr>
|
||
<td class="linenos">
|
||
<div class="linenodiv">
|
||
<pre>1</pre></div></td>
|
||
<td class="code">
|
||
<div class="source">
|
||
<pre><span></span><span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed/racket/base..rkt)._define-type))" style="color: inherit">define-type</a></span> <span class="n">Tree</span> <span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types-extra..rkt)._.U))" style="color: inherit">U</a></span> <span class="n">Empty</span> <span class="n">Leaf</span> <span class="n">Node</span><span class="p">))</span>
|
||
</pre></div>
|
||
</td></tr></tbody></table>
|
||
</div>
|
||
|
||
<p>However, a polymorphic type alias would need to include the type parameters in each subtype, like this:</p>
|
||
|
||
<div class="brush: racket">
|
||
<table class="sourcetable">
|
||
<tbody>
|
||
<tr>
|
||
<td class="linenos">
|
||
<div class="linenodiv">
|
||
<pre>1</pre></div></td>
|
||
<td class="code">
|
||
<div class="source">
|
||
<pre><span></span><span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed/racket/base..rkt)._define-type))" style="color: inherit">define-type</a></span> <span class="p">(</span><span class="n">Tree</span> <span class="n">a</span><span class="p">)</span> <span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types-extra..rkt)._.U))" style="color: inherit">U</a></span> <span class="p">(</span><span class="n">Empty</span> <span class="n">a</span><span class="p">)</span> <span class="p">(</span><span class="n">Leaf</span> <span class="n">a</span><span class="p">)</span> <span class="p">(</span><span class="n">Node</span> <span class="n">a</span><span class="p">)))</span>
|
||
</pre></div>
|
||
</td></tr></tbody></table>
|
||
</div>
|
||
|
||
<p>How can we do this? Well, so far, we&rsquo;ve been very declarative by using syntax patterns, templates, and classes. However, this is a more pernicious problem to solve with our declarative tools. Fortunately, it&rsquo;s very easy to fall back to using <strong>procedural macros</strong>.</p>
|
||
|
||
<p>To build each properly-instantiated type, we&rsquo;ll use a combination of <code>define/with-syntax</code> and Racket&rsquo;s list comprehensions, <code>for/list</code>. The <code>define/with-syntax</code> form binds values to pattern identifiers, which can be used within syntax patterns just like the ones bound by <code>syntax-parser</code>. This will allow us to break up our result into multiple steps. Technically, <code>define/with-syntax</code> is not strictly necessary—we could just use <code>#`</code> and <code>#,</code>—but it&rsquo;s cleaner to work with.</p>
|
||
|
||
<p>We&rsquo;ll start by defining a set of instantiated data constructor types, one per <code>data-constructor</code>:</p>
|
||
|
||
<div class="brush: racket">
|
||
<table class="sourcetable">
|
||
<tbody>
|
||
<tr>
|
||
<td class="linenos">
|
||
<div class="linenodiv">
|
||
<pre>1
|
||
2
|
||
3</pre></div></td>
|
||
<td class="code">
|
||
<div class="source">
|
||
<pre><span></span><span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/reference/syntax-util.html#(form._((lib._racket/syntax..rkt)._define/with-syntax))" style="color: inherit">define/with-syntax</a></span> <span class="p">[</span><span class="n">data-type</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">]</span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/for.html#(form._((lib._racket/private/base..rkt)._for/list))" style="color: inherit">for/list</a></span> <span class="p">([</span><span class="n">name</span> <span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/unstable/sequence.html#(def._((lib._unstable/sequence..rkt)._in-syntax))" style="color: inherit">in-syntax</a></span> <span class="o">#'</span><span class="p">(</span><span class="n">data-constructor.name</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">))])</span>
|
||
<span class="p">))</span>
|
||
</pre></div>
|
||
</td></tr></tbody></table>
|
||
</div>
|
||
|
||
<p>Now we can fill in the body with any code we&rsquo;d like, so long as each body returns a syntax object. We can use some trivial branching logic to determine which form we need:</p>
|
||
|
||
<div class="brush: racket">
|
||
<table class="sourcetable">
|
||
<tbody>
|
||
<tr>
|
||
<td class="linenos">
|
||
<div class="linenodiv">
|
||
<pre>1
|
||
2
|
||
3
|
||
4
|
||
5</pre></div></td>
|
||
<td class="code">
|
||
<div class="source">
|
||
<pre><span></span><span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/reference/syntax-util.html#(form._((lib._racket/syntax..rkt)._define/with-syntax))" style="color: inherit">define/with-syntax</a></span> <span class="p">[</span><span class="n">data-type</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">]</span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/for.html#(form._((lib._racket/private/base..rkt)._for/list))" style="color: inherit">for/list</a></span> <span class="p">([</span><span class="n">name</span> <span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/unstable/sequence.html#(def._((lib._unstable/sequence..rkt)._in-syntax))" style="color: inherit">in-syntax</a></span> <span class="o">#'</span><span class="p">(</span><span class="n">data-constructor.name</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">))])</span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/if.html#(form._((quote._~23~25kernel)._if))" style="color: inherit">if</a></span> <span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/syntax-helpers.html#(def._((lib._syntax/stx..rkt)._stx-null~3f))" style="color: inherit">stx-null?</a></span> <span class="o">#'</span><span class="p">(</span><span class="n">type-name.param</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">))</span>
|
||
<span class="n">name</span>
|
||
<span class="o">#`</span><span class="p">(</span><span class="o">#,</span><span class="n">name</span> <span class="n">type-name.param</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">))))</span>
|
||
</pre></div>
|
||
</td></tr></tbody></table>
|
||
</div>
|
||
|
||
<p>Now with our definition for <code>data-type</code>, we can implement our type alias for the supertype extremely easily:</p>
|
||
|
||
<div class="brush: racket">
|
||
<table class="sourcetable">
|
||
<tbody>
|
||
<tr>
|
||
<td class="linenos">
|
||
<div class="linenodiv">
|
||
<pre>1</pre></div></td>
|
||
<td class="code">
|
||
<div class="source">
|
||
<pre><span></span><span class="o">#'</span><span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed/racket/base..rkt)._define-type))" style="color: inherit">define-type</a></span> <span class="n">type-name</span> <span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types-extra..rkt)._.U))" style="color: inherit">U</a></span> <span class="n">data-type</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">))</span>
|
||
</pre></div>
|
||
</td></tr></tbody></table>
|
||
</div>
|
||
|
||
<h2 id="putting-it-all-together">Putting it all together</h2>
|
||
|
||
<p>There&rsquo;s just one more thing to do before we can call this macro finished: we need to ensure that all the type parameters defined by <code>type-name</code> are in scope for each data constructor&rsquo;s structure definition. We can do this by making use of <code>type-name.param</code> within each produced struct definition, resulting in this:</p>
|
||
|
||
<div class="brush: racket">
|
||
<table class="sourcetable">
|
||
<tbody>
|
||
<tr>
|
||
<td class="linenos">
|
||
<div class="linenodiv">
|
||
<pre>1
|
||
2
|
||
3
|
||
4</pre></div></td>
|
||
<td class="code">
|
||
<div class="source">
|
||
<pre><span></span><span class="o">#'</span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin))" style="color: inherit">begin</a></span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit">struct</a></span> <span class="n">data-constructor.name</span> <span class="p">(</span><span class="n">type-name.param</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">)</span>
|
||
<span class="p">([</span><span class="n">data-constructor.field-id</span> <span class="n"><a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit">:</a></span> <span class="n">data-constructor.param</span><span class="p">]</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">))</span>
|
||
<span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">)</span>
|
||
</pre></div>
|
||
</td></tr></tbody></table>
|
||
</div>
|
||
|
||
<p>And we&rsquo;re done! The final macro, now completed, looks like this:</p>
|
||
|
||
<div class="brush: racket">
|
||
<table class="sourcetable">
|
||
<tbody>
|
||
<tr>
|
||
<td class="linenos">
|
||
<div class="linenodiv">
|
||
<pre> 1
|
||
2
|
||
3
|
||
4
|
||
5
|
||
6
|
||
7
|
||
8
|
||
9
|
||
10
|
||
11
|
||
12
|
||
13
|
||
14
|
||
15
|
||
16
|
||
17
|
||
18
|
||
19
|
||
20
|
||
21
|
||
22</pre></div></td>
|
||
<td class="code">
|
||
<div class="source">
|
||
<pre><span></span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin-for-syntax))" style="color: inherit">begin-for-syntax</a></span>
|
||
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._define-syntax-class))" style="color: inherit">define-syntax-class</a></span> <span class="n">type</span>
|
||
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._pattern))" style="color: inherit">pattern</a></span> <span class="n">name:id</span>
|
||
<span class="kd">#:attr</span> <span class="p">[</span><span class="n">param</span> <span class="mi">1</span><span class="p">]</span> <span class="o">'</span><span class="p">()</span>
|
||
<span class="kd">#:attr</span> <span class="p">[</span><span class="n">field-id</span> <span class="mi">1</span><span class="p">]</span> <span class="o">'</span><span class="p">())</span>
|
||
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._pattern))" style="color: inherit">pattern</a></span> <span class="p">(</span><span class="n">name:id</span> <span class="n">param</span> <span class="n"><a href="http://docs.racket-lang.org/syntax/stxparse-patterns.html#(form._((lib._syntax/parse..rkt)._......+))" style="color: inherit">...+</a></span><span class="p">)</span>
|
||
<span class="kd">#:attr</span> <span class="p">[</span><span class="n">field-id</span> <span class="mi">1</span><span class="p">]</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/stxops.html#(def._((lib._racket/private/stxcase-scheme..rkt)._generate-temporaries))" style="color: inherit">generate-temporaries</a></span> <span class="o">#'</span><span class="p">(</span><span class="n">param</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">)))))</span>
|
||
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define-syntax))" style="color: inherit">define-syntax</a></span> <span class="n">define-datatype</span>
|
||
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/Parsing_Syntax.html#(form._((lib._syntax/parse..rkt)._syntax-parser))" style="color: inherit">syntax-parser</a></span>
|
||
<span class="p">[(</span><span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt).__))" style="color: inherit">_</a></span> <span class="n">type-name:type</span> <span class="n">data-constructor:type</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">)</span>
|
||
|
||
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/reference/syntax-util.html#(form._((lib._racket/syntax..rkt)._define/with-syntax))" style="color: inherit">define/with-syntax</a></span> <span class="p">[</span><span class="n">data-type</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">]</span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/for.html#(form._((lib._racket/private/base..rkt)._for/list))" style="color: inherit">for/list</a></span> <span class="p">([</span><span class="n">name</span> <span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/unstable/sequence.html#(def._((lib._unstable/sequence..rkt)._in-syntax))" style="color: inherit">in-syntax</a></span> <span class="o">#'</span><span class="p">(</span><span class="n">data-constructor.name</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">))])</span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/if.html#(form._((quote._~23~25kernel)._if))" style="color: inherit">if</a></span> <span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/syntax-helpers.html#(def._((lib._syntax/stx..rkt)._stx-null~3f))" style="color: inherit">stx-null?</a></span> <span class="o">#'</span><span class="p">(</span><span class="n">type-name.param</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">))</span>
|
||
<span class="n">name</span>
|
||
<span class="o">#`</span><span class="p">(</span><span class="o">#,</span><span class="n">name</span> <span class="n">type-name.param</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">))))</span>
|
||
|
||
<span class="o">#'</span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin))" style="color: inherit">begin</a></span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit">struct</a></span> <span class="p">(</span><span class="n">type-name.param</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">)</span> <span class="n">data-constructor.name</span>
|
||
<span class="p">([</span><span class="n">data-constructor.field-id</span> <span class="n"><a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit">:</a></span> <span class="n">data-constructor.param</span><span class="p">]</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">))</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span>
|
||
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed/racket/base..rkt)._define-type))" style="color: inherit">define-type</a></span> <span class="n">type-name</span> <span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types-extra..rkt)._.U))" style="color: inherit">U</a></span> <span class="n">data-type</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">)))]))</span>
|
||
</pre></div>
|
||
</td></tr></tbody></table>
|
||
</div>
|
||
|
||
<p>It&rsquo;s a little bit dense, certainly, but it is not as complicated or scary as it might seem. It&rsquo;s a simple, mostly declarative, powerful way to transform a DSL into ordinary Typed Racket syntax, and now all we have to do is put it to use.</p>
|
||
|
||
<h1 id="using-our-adts">Using our ADTs</h1>
|
||
|
||
<p>With the macro built, we can now actually use our ADTs using the syntax we described! The following is now <em>valid code</em>:</p>
|
||
|
||
<div class="brush: racket">
|
||
<table class="sourcetable">
|
||
<tbody>
|
||
<tr>
|
||
<td class="linenos">
|
||
<div class="linenodiv">
|
||
<pre>1
|
||
2
|
||
3
|
||
4
|
||
5
|
||
6
|
||
7
|
||
8</pre></div></td>
|
||
<td class="code">
|
||
<div class="source">
|
||
<pre><span></span><span class="p">(</span><span class="n">define-datatype</span> <span class="p">(</span><span class="n">Tree</span> <span class="n">a</span><span class="p">)</span>
|
||
<span class="n">Empty</span>
|
||
<span class="p">(</span><span class="n">Leaf</span> <span class="n">a</span><span class="p">)</span>
|
||
<span class="p">(</span><span class="n">Node</span> <span class="p">(</span><span class="n">Tree</span> <span class="n">a</span><span class="p">)</span> <span class="p">(</span><span class="n">Tree</span> <span class="n">a</span><span class="p">)))</span>
|
||
|
||
<span class="nb"><a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._~3e))" style="color: inherit">&gt;</a></span> <span class="p">(</span><span class="n">Node</span> <span class="p">(</span><span class="n">Leaf</span> <span class="mi">3</span><span class="p">)</span> <span class="p">(</span><span class="n">Node</span> <span class="p">(</span><span class="n">Empty</span><span class="p">)</span> <span class="p">(</span><span class="n">Leaf</span> <span class="mi">7</span><span class="p">)))</span>
|
||
<span class="nb"><a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._-))" style="color: inherit">-</a></span> <span class="n"><a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit">:</a></span> <span class="p">(</span><span class="n">Node</span> <span class="n"><a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Positive-.Byte))" style="color: inherit">Positive-Byte</a></span><span class="p">)</span>
|
||
<span class="p">(</span><span class="n">Node</span> <span class="p">(</span><span class="n">Leaf</span> <span class="mi">3</span><span class="p">)</span> <span class="p">(</span><span class="n">Node</span> <span class="p">(</span><span class="n">Empty</span><span class="p">)</span> <span class="p">(</span><span class="n">Leaf</span> <span class="mi">7</span><span class="p">)))</span>
|
||
</pre></div>
|
||
</td></tr></tbody></table>
|
||
</div>
|
||
|
||
<p>We can use this to define common data types, such as Haskell&rsquo;s <code>Maybe</code>:</p>
|
||
|
||
<div class="brush: racket">
|
||
<table class="sourcetable">
|
||
<tbody>
|
||
<tr>
|
||
<td class="linenos">
|
||
<div class="linenodiv">
|
||
<pre> 1
|
||
2
|
||
3
|
||
4
|
||
5
|
||
6
|
||
7
|
||
8
|
||
9
|
||
10
|
||
11
|
||
12
|
||
13
|
||
14
|
||
15</pre></div></td>
|
||
<td class="code">
|
||
<div class="source">
|
||
<pre><span></span><span class="p">(</span><span class="n">define-datatype</span> <span class="p">(</span><span class="n">Maybe</span> <span class="n">a</span><span class="p">)</span>
|
||
<span class="p">(</span><span class="n">Just</span> <span class="n">a</span><span class="p">)</span>
|
||
<span class="n"><a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Nothing))" style="color: inherit">Nothing</a></span><span class="p">)</span>
|
||
|
||
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit">:</a></span> <span class="n">maybe-default</span> <span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types-extra..rkt)._.All))" style="color: inherit">All</a></span> <span class="p">[</span><span class="n">a</span><span class="p">]</span> <span class="p">(</span><span class="n">Maybe</span> <span class="n">a</span><span class="p">)</span> <span class="n">a</span> <span class="k"><a href="http://docs.racket-lang.org/reference/function-contracts.html#(form._((lib._racket/contract/base..rkt)._-~3e))" style="color: inherit">-&gt;</a></span> <span class="n">a</span><span class="p">))</span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit">define</a></span> <span class="p">(</span><span class="n">maybe-default</span> <span class="n">m</span> <span class="n">v</span><span class="p">)</span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/match.html#(form._((lib._racket/match..rkt)._match))" style="color: inherit">match</a></span> <span class="n">m</span>
|
||
<span class="p">[(</span><span class="n">Just</span> <span class="n">a</span><span class="p">)</span> <span class="n">a</span><span class="p">]</span>
|
||
<span class="p">[(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Nothing))" style="color: inherit">Nothing</a></span><span class="p">)</span> <span class="n">v</span><span class="p">]))</span>
|
||
|
||
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit">:</a></span> <span class="n">maybe-then</span> <span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types-extra..rkt)._.All))" style="color: inherit">All</a></span> <span class="p">[</span><span class="n">a</span><span class="p">]</span> <span class="p">(</span><span class="n">Maybe</span> <span class="n">a</span><span class="p">)</span> <span class="p">(</span><span class="n">a</span> <span class="k"><a href="http://docs.racket-lang.org/reference/function-contracts.html#(form._((lib._racket/contract/base..rkt)._-~3e))" style="color: inherit">-&gt;</a></span> <span class="p">(</span><span class="n">Maybe</span> <span class="n">a</span><span class="p">))</span> <span class="k"><a href="http://docs.racket-lang.org/reference/function-contracts.html#(form._((lib._racket/contract/base..rkt)._-~3e))" style="color: inherit">-&gt;</a></span> <span class="p">(</span><span class="n">Maybe</span> <span class="n">a</span><span class="p">)))</span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit">define</a></span> <span class="p">(</span><span class="n">maybe-then</span> <span class="n">m</span> <span class="n">f</span><span class="p">)</span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/match.html#(form._((lib._racket/match..rkt)._match))" style="color: inherit">match</a></span> <span class="n">m</span>
|
||
<span class="p">[(</span><span class="n">Just</span> <span class="n">a</span><span class="p">)</span> <span class="p">(</span><span class="n">f</span> <span class="n">a</span><span class="p">)]</span>
|
||
<span class="p">[(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Nothing))" style="color: inherit">Nothing</a></span><span class="p">)</span> <span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Nothing))" style="color: inherit">Nothing</a></span><span class="p">)]))</span>
|
||
</pre></div>
|
||
</td></tr></tbody></table>
|
||
</div>
|
||
|
||
<p>And of course, we can also use it to define ADTs that use concrete types rather that type parameters, if we so desire. This implements a small mathematical language, along with a trivial interpreter:</p>
|
||
|
||
<div class="brush: racket">
|
||
<table class="sourcetable">
|
||
<tbody>
|
||
<tr>
|
||
<td class="linenos">
|
||
<div class="linenodiv">
|
||
<pre> 1
|
||
2
|
||
3
|
||
4
|
||
5
|
||
6
|
||
7
|
||
8
|
||
9
|
||
10
|
||
11
|
||
12
|
||
13
|
||
14
|
||
15
|
||
16
|
||
17
|
||
18
|
||
19
|
||
20</pre></div></td>
|
||
<td class="code">
|
||
<div class="source">
|
||
<pre><span></span><span class="p">(</span><span class="n">define-datatype</span> <span class="n">Expr</span>
|
||
<span class="p">(</span><span class="n">Value</span> <span class="n"><a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Number))" style="color: inherit">Number</a></span><span class="p">)</span>
|
||
<span class="p">(</span><span class="n">Add</span> <span class="n">Expr</span> <span class="n">Expr</span><span class="p">)</span>
|
||
<span class="p">(</span><span class="n">Subtract</span> <span class="n">Expr</span> <span class="n">Expr</span><span class="p">)</span>
|
||
<span class="p">(</span><span class="n">Multiply</span> <span class="n">Expr</span> <span class="n">Expr</span><span class="p">)</span>
|
||
<span class="p">(</span><span class="n">Divide</span> <span class="n">Expr</span> <span class="n">Expr</span><span class="p">))</span>
|
||
|
||
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit">:</a></span> <span class="n">evaluate</span> <span class="p">(</span><span class="n">Expr</span> <span class="k"><a href="http://docs.racket-lang.org/reference/function-contracts.html#(form._((lib._racket/contract/base..rkt)._-~3e))" style="color: inherit">-&gt;</a></span> <span class="n"><a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Number))" style="color: inherit">Number</a></span><span class="p">))</span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit">define</a></span> <span class="p">(</span><span class="n">evaluate</span> <span class="n">e</span><span class="p">)</span>
|
||
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/match.html#(form._((lib._racket/match..rkt)._match))" style="color: inherit">match</a></span> <span class="n">e</span>
|
||
<span class="p">[(</span><span class="n">Value</span> <span class="n">x</span><span class="p">)</span> <span class="n">x</span> <span class="p">]</span>
|
||
<span class="p">[(</span><span class="n">Add</span> <span class="n">a</span> <span class="n">b</span><span class="p">)</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._+))" style="color: inherit">+</a></span> <span class="p">(</span><span class="n">evaluate</span> <span class="n">a</span><span class="p">)</span> <span class="p">(</span><span class="n">evaluate</span> <span class="n">b</span><span class="p">))]</span>
|
||
<span class="p">[(</span><span class="n">Subtract</span> <span class="n">a</span> <span class="n">b</span><span class="p">)</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._-))" style="color: inherit">-</a></span> <span class="p">(</span><span class="n">evaluate</span> <span class="n">a</span><span class="p">)</span> <span class="p">(</span><span class="n">evaluate</span> <span class="n">b</span><span class="p">))]</span>
|
||
<span class="p">[(</span><span class="n">Multiply</span> <span class="n">a</span> <span class="n">b</span><span class="p">)</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._*))" style="color: inherit">*</a></span> <span class="p">(</span><span class="n">evaluate</span> <span class="n">a</span><span class="p">)</span> <span class="p">(</span><span class="n">evaluate</span> <span class="n">b</span><span class="p">))]</span>
|
||
<span class="p">[(</span><span class="n">Divide</span> <span class="n">a</span> <span class="n">b</span><span class="p">)</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._/))" style="color: inherit">/</a></span> <span class="p">(</span><span class="n">evaluate</span> <span class="n">a</span><span class="p">)</span> <span class="p">(</span><span class="n">evaluate</span> <span class="n">b</span><span class="p">))]))</span>
|
||
|
||
<span class="nb"><a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._~3e))" style="color: inherit">&gt;</a></span> <span class="p">(</span><span class="n">evaluate</span> <span class="p">(</span><span class="n">Add</span> <span class="p">(</span><span class="n">Value</span> <span class="mi">1</span><span class="p">)</span>
|
||
<span class="p">(</span><span class="n">Multiply</span> <span class="p">(</span><span class="n">Divide</span> <span class="p">(</span><span class="n">Value</span> <span class="mi">1</span><span class="p">)</span> <span class="p">(</span><span class="n">Value</span> <span class="mi">2</span><span class="p">))</span>
|
||
<span class="p">(</span><span class="n">Value</span> <span class="mi">7</span><span class="p">))))</span>
|
||
<span class="mi">4</span> <span class="m">1/2</span>
|
||
</pre></div>
|
||
</td></tr></tbody></table>
|
||
</div>
|
||
|
||
<p>There&rsquo;s all the power of ADTs, right in Racket, all implemented in 22 lines of code. If you&rsquo;d like to see all the code together in a runnable form, <a href="https://gist.github.com/lexi-lambda/18cf7a9156f743a1317e">I&rsquo;ve put together a gist here</a>.</p>
|
||
|
||
<h1 id="conclusions-and-credit">Conclusions and credit</h1>
|
||
|
||
<p>This isn&rsquo;t the simplest macro to create, nor is it the most complex. The code examples might not even make much sense until you try it out yourself. Macros, like any difficult concept, are not always easy to pick up, but they certainly <em>are</em> powerful. The ability to extend the language in such a way, in the matter of minutes, is unparalleled in languages other than Lisp.</p>
|
||
|
||
<p>This is, of course, a blessing and a curse. Lisps reject some of the syntactic landmarks that often aid in readability for the power to abstract programs into their bare components. In the end, is this uniform conciseness more or less readable? That&rsquo;s an incredibly subjective question, one that has prompted powerfully impassioned discussions, and I will not attempt to argue one way or the other here.</p>
|
||
|
||
<p>That said, I think it&rsquo;s pretty cool.</p>
|
||
|
||
<p>Finally, I must give credit where credit is due. Thanks to <a href="http://andmkent.com">Andrew M. Kent</a> for the creation of the <a href="https://github.com/andmkent/datatype">datatype</a> package, which served as the inspiration for this blog post. Many thanks to <a href="http://www.ccs.neu.edu/home/samth/">Sam Tobin-Hochstadt</a> for his work creating Typed Racket, as well as helping me dramatically simplify the implementation used in this blog post. Also thanks to <a href="http://www.ccs.neu.edu/home/ryanc/">Ryan Culpepper</a> and <a href="http://www.ccs.neu.edu/home/matthias/">Matthias Felleisen</a> for their work on creating <code>syntax/parse</code>, which is truly a marvelous tool for exploring the world of macros, and, of course, a big thanks to <a href="http://www.cs.utah.edu/~mflatt/">Matthew Flatt</a> for his implementation of hygiene in Racket, as well as much of the rest of Racket itself. Not to mention the entire legacy of those who formulated the foundations of the Scheme macro system and created the framework for all of this to be possible so many decades later.</p>
|
||
|
||
<p>Truly, working in Racket feels like standing on the shoulders of giants. If you&rsquo;re intrigued, give it a shot. It&rsquo;s a fun feeling.</p></html></content></entry></feed> |