new site

src/site/articles/emulating-functions/index.html

 ---
 layout: default
 title: "Emulating Functions in Dart"
 rel:
   author: gilad-bracha
 ---
 
 <h1> {{ page.title }}</h1>
 <em>Written by Gilad Bracha <br />
 January 2012</em>
 
 <section>
 <p>
 This document describes a refinement of the Dart programming language
 that allows user-defined classes that are substitutable for functions.
 </p>
 
-<aside class="note">
-<b>Note:</b>
-This functionality is <b>not yet implemented</b>,
-but is specified as part of version 0.07 of the
-<a href="http://www.dartlang.org/docs/spec/index.html">Dart
-Programming Language Specification</a>.
-Hopefully it will find its way into our implementations in due course,
-though it may be quite a while.
+<aside>
+  <div class="alert alert-info">
+    <strong>Note:</strong>
+    This functionality is <b>not yet implemented</b>,
+    but is specified as part of version 0.07 of the
+    <a href="http://www.dartlang.org/docs/spec/index.html">Dart
+    Programming Language Specification</a>.
+    Hopefully it will find its way into our implementations in due course,
+    though it may be quite a while.
+  </div>
 </aside>
 
 <section class="toc">
 <h4>Contents</h4>
 <ol class="toc">
   <li> <a href="#call">The call operator</a> </li>
   <li> <a href="#apply">The Function interface and apply() method</a> </li>
   <li> <a href="#types">Function types</a> </li>
   <li> <a href="#nosuchmethod">Interactions with noSuchMethod()</a> </li>
   <li> <a href="#summary">Summary</a> </li>
@@ skipping 33 matching lines @@
 If <code>x</code> supports a <b>call</b> operator with suitable arguments
 it gets called.
 Otherwise, <code>noSuchMethod()</code>
 (defined by <code>Object</code>) is called.
 The default implementation of <code>noSuchMethod()</code> checks to see
 whether it was called for method name <b>call</b>,
 and if so issues a helpful error message suggesting
 you might have wanted to use a closure.
 </p>
 
-<aside class="note">
-<b>Side note:</b>
+<p>
 Why do we insist on <b>call</b>? It might seem like
 
 <pre>operator () (int a) =&gt; a *2;</pre>
 
 could work instead of
 
 <pre>operator call (int a) =&gt; a * 2;</pre>
 
 However, as shown below,
 we need to be able to closurize the operator
 (for example, <code>f.call</code>), which doesn&rsquo;t work for <b>()</b>.
 (We don&rsquo;t allow <code>f.()</code>.
 It is clearly too error prone.)
-</aside>
+</p>
 
 <section>
 <h2 id="apply"> The Function interface and apply() method </h2>
 
 <p>
 Actual function objects have an <code>apply()</code> method
 whose signature is defined in the <code>Function</code> interface as:
 </p>
 
 {% highlight dart %}
@@ skipping 43 matching lines @@
 It is always possible to invoke such an object <code>f</code>
 as a function using an <code>ArgumentDescriptor</code>
 by closurizing its <code>call</code> method
 and calling <code><code>apply()</code></code> on it:
 </p>
 
 {% highlight dart %}
 f.call.apply(args);
 {% endhighlight %}
 <br>
-<aside class="note">
-<b>Side note:</b>
+
+<p>
 We could say that if you declare operator <b>call</b>,
 <code>apply()</code> gets created for you.
 However, this entails an undesirable degree of magic.
 One has to deal with interactions with
 user-defined <code>apply()</code> methods,
 whether locally declared or (worse) inherited.
 Debuggers need to know how to display
 these synthetic <code>apply()</code> methods,
 and so on.
-</aside>
+</p>
 </section>
 
 <section>
 <h2 id="types"> Function types </h2>
 
 <p>
 An additional issue is how
 user-defined function classes relate to the type system.
 To simulate functions properly,
 we want them to be members of the appropriate function type:
@@ skipping 35 matching lines @@
 (in this case, the result of <code>bar()</code>).
 The third line handles the case where you want to forward
 just the parameters to another function.
 If <code>baz</code> doesn't implement
 <code>Function</code> and <code>apply()</code>
 as we recommended above,
 then that code should instead be
 <code>baz.<b>call.</b>apply(msg.arguments)</code>.
 </p>
 
-<aside class="note">
-<b>Side note:</b>
+<p>
 The only argument to <code>noSuchMethod()</code>
 is an <code>InvocationMirror</code>,
 which is currently defined as follows:
+</p>
 
 {% highlight dart %}
 interface InvocationMirror {
 
   final String memberName;
   final ArgumentDescriptor arguments;
   final bool isGetter;
   final bool isSetter;
   final bool isMethod;
   final bool isAccessor;
@@ skipping 53 matching lines @@
 <p>
 It is important not to assume that <code>isMethod</code> means
 that a non-accessor was being looked up,
 since in fact, Dart semantics mean
 that we would have called <code>noSuchMethod()</code> only if
 neither a normal method nor a getter were found.
 Likewise, <code>isGetter</code> does not imply a getter was being looked up;
 if a method was present,
 it would be closurized and returned.
 </p>
-</aside>
+
 </section>
 
 
 <section>
 <h2 id="summary">Summary</h2>
 
 <p>
 The ability to declare user-defined classes whose instances can be
 treated like ordinary functions is coming to Dart.
 It isn&rsquo;t implemented yet,
@@ skipping 31 matching lines @@
 {% highlight dart %}
 apply(args) => this.call.apply(args);
 {% endhighlight %}
   </li>
 </ol>
 </section>
 
 </section>