projects / dygraphs.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Add a thin wrapper that directly supports the gviz API. This resolves issue 1.
[dygraphs.git] / mochikit_v14 / doc / html / MochiKit / Base.html
CommitLineData
6a1aa64f
DV		 1<?xml version="1.0" encoding="utf-8" ?>
2<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
3
4<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
5<head>
6<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
7<meta name="generator" content="Docutils 0.4: http://docutils.sourceforge.net/" />
8<title>MochiKit.Base - functional programming and useful comparisons</title>
9
10<link rel="stylesheet" href="../../../include/css/documentation.css" type="text/css" />
11<script type="text/javascript" src="../../../packed/MochiKit/MochiKit.js"></script>
12<script type="text/javascript" src="../../js/toc.js"></script>
13</head>
14<body>
15<div class="document">
16<div class="section">
17<h1><a id="name" name="name">Name</a></h1>
18<p>MochiKit.Base - functional programming and useful comparisons</p>
19</div>
20<div class="section">
21<h1><a id="synopsis" name="synopsis">Synopsis</a></h1>
22<pre class="literal-block">
23myObjectRepr = function () {
24 // gives a nice, stable string representation for objects,
25 // ignoring any methods
26 var keyValuePairs = [];
27 for (var k in this) {
28 var v = this[k];
29 if (typeof(v) != 'function') {
30 keyValuePairs.push([k, v]);
31 }
32 };
33 keyValuePairs.sort(compare);
34 return &quot;{&quot; + map(
35 function (pair) {
36 return map(repr, pair).join(&quot;:&quot;);
37 },
38 keyValuePairs
39 ).join(&quot;, &quot;) + &quot;}&quot;;
40};
41
42// repr() will look for objects that have a repr method
43myObjectArray = [
44 {&quot;a&quot;: 3, &quot;b&quot;: 2, &quot;repr&quot;: myObjectRepr},
45 {&quot;a&quot;: 1, &quot;b&quot;: 2, &quot;repr&quot;: myObjectRepr}
46];
47
48// sort it by the &quot;a&quot; property, check to see if it matches
49myObjectArray.sort(keyComparator(&quot;a&quot;));
50expectedRepr = '[{&quot;a&quot;: 1, &quot;b&quot;: 2}, {&quot;a&quot;: 3, &quot;b&quot;: 2}]';
51assert( repr(myObjectArray) == expectedRepr );
52
53// get just the &quot;a&quot; values out into an array
54sortedAValues = map(itemgetter(&quot;a&quot;), myObjectArray);
55assert( compare(sortedAValues, [1, 3]) == 0 );
56
57// serialize an array as JSON, unserialize it, expect something equivalent
58myArray = [1, 2, &quot;3&quot;, null, undefined];
59assert( objEqual(evalJSON(serializeJSON(myArray)), myArray) );
60</pre>
61</div>
62<div class="section">
63<h1><a id="description" name="description">Description</a></h1>
64<p><a class="mochiref reference" href="Base.html">MochiKit.Base</a> is the foundation for the MochiKit suite.
65It provides:</p>
66<ul class="simple">
67<li>An extensible comparison facility
68(<a class="mochiref reference" href="#fn-compare">compare</a>, <a class="mochiref reference" href="#fn-registercomparator">registerComparator</a>)</li>
69<li>An extensible programmer representation facility
70(<a class="mochiref reference" href="#fn-repr">repr</a>, <a class="mochiref reference" href="#fn-registerrepr">registerRepr</a>)</li>
71<li>An extensible JSON <a class="footnote-reference" href="#id7" id="id1" name="id1">[1]</a> serialization and evaluation facility
72(<a class="mochiref reference" href="#fn-serializejson">serializeJSON</a>, <a class="mochiref reference" href="#fn-evaljson">evalJSON</a>,
73<a class="mochiref reference" href="#fn-registerjson">registerJSON</a>)</li>
74<li>A simple adaptation facility (<a class="mochiref reference" href="#fn-adapterregistry">AdapterRegistry</a>)</li>
75<li>Convenience functions for manipulating objects and Arrays
76(<a class="mochiref reference" href="#fn-update">update</a>, <a class="mochiref reference" href="#fn-setdefault">setdefault</a>, <a class="mochiref reference" href="#fn-extend">extend</a>, etc.)</li>
77<li>Array-based functional programming
78(<a class="mochiref reference" href="#fn-map">map</a>, <a class="mochiref reference" href="#fn-filter">filter</a>, etc.)</li>
79<li>Bound and partially applied functions
80(<a class="mochiref reference" href="#fn-bind">bind</a>, <a class="mochiref reference" href="#fn-method">method</a>, <a class="mochiref reference" href="#fn-partial">partial</a>)</li>
81</ul>
82<p>Python users will feel at home with <a class="mochiref reference" href="Base.html">MochiKit.Base</a>, as the
83facilities are quite similar to those available as part of Python and
84the Python standard library.</p>
85</div>
86<div class="section">
87<h1><a id="dependencies" name="dependencies">Dependencies</a></h1>
88<p>None.</p>
89</div>
90<div class="section">
91<h1><a id="overview" name="overview">Overview</a></h1>
92<div class="section">
93<h2><a id="comparison" name="comparison">Comparison</a></h2>
94<p>The comparators (operators for comparison) in JavaScript are deeply
95broken, and it is not possible to teach them new tricks.</p>
96<p>MochiKit exposes an extensible comparison facility as a simple
97<a class="mochiref reference" href="#fn-compare">compare(a, b)</a> function, which should be used in lieu of
98JavaScript's operators whenever comparing objects other than numbers
99or strings (though you can certainly use <a class="mochiref reference" href="#fn-compare">compare</a> for
100those, too!).</p>
101<p>The <a class="mochiref reference" href="#fn-compare">compare</a> function has the same signature and return
102value as a sort function for <tt class="docutils literal"><span class="pre">Array.prototype.sort</span></tt>, and is often
103used in that context.</p>
104<p>Defining new comparators for the <a class="mochiref reference" href="#fn-compare">compare</a> function to use
105is done by adding an entry to its <a class="mochiref reference" href="#fn-adapterregistry">AdapterRegistry</a> with the
106<a class="mochiref reference" href="#fn-registercomparator">registerComparator</a> function.</p>
107</div>
108<div class="section">
109<h2><a id="programmer-representation" name="programmer-representation">Programmer Representation</a></h2>
110<p>JavaScript's default representation mechanism, <tt class="docutils literal"><span class="pre">toString</span></tt>, is
111notorious for having terrible default behavior. It's also very unwise
112to change that default, as other JavaScript code you may be using may
113depend on it.</p>
114<p>It's also useful to separate the concept of a &quot;string representation&quot;
115and a &quot;string representation for programmers&quot;, much like Python does
116with its str and repr protocols.</p>
117<p><a class="mochiref reference" href="#fn-repr">repr</a> provides this programmer representation for
118JavaScript, in a way that doesn't require object prototype hacking:
119using an <a class="mochiref reference" href="#fn-adapterregistry">AdapterRegistry</a>.</p>
120<p>Objects that implement the repr protocol can either implement a
121<tt class="docutils literal"><span class="pre">.repr()</span></tt> or <tt class="docutils literal"><span class="pre">.__repr__()</span></tt> method, or they can simply have an
122adapter setup to generate programmer representations. By default, the
123registry provides nice representations for <tt class="docutils literal"><span class="pre">null</span></tt>, <tt class="docutils literal"><span class="pre">undefined</span></tt>,
124<tt class="docutils literal"><span class="pre">Array</span></tt>, and objects or functions with a <tt class="docutils literal"><span class="pre">NAME</span></tt> attribute that use
125the default <tt class="docutils literal"><span class="pre">toString</span></tt>. For objects that <tt class="docutils literal"><span class="pre">repr</span></tt> doesn't already
126understand, it simply defaults to <tt class="docutils literal"><span class="pre">toString</span></tt>, so it will integrate
127seamlessly with code that implements the idiomatic JavaScript
128<tt class="docutils literal"><span class="pre">toString</span></tt> method!</p>
129<p>To define a programmer representation for your own objects, simply add
130a <tt class="docutils literal"><span class="pre">.repr()</span></tt> or <tt class="docutils literal"><span class="pre">.__repr__()</span></tt> method that returns a string. For
131objects that you didn't create (e.g., from a script you didn't write,
132or a built-in object), it is instead recommended that you create an
133adapter with <a class="mochiref reference" href="#fn-registerrepr">registerRepr</a>.</p>
134</div>
135<div class="section">
136<h2><a id="json-serialization" name="json-serialization">JSON Serialization</a></h2>
137<p>JSON <a class="footnote-reference" href="#id7" id="id2" name="id2">[1]</a>, JavaScript Object Notation, is a widely used serialization
138format in the context of web development. It's extremely simple,
139lightweight, and fast. In its essence, JSON is a restricted subset of
140JavaScript syntax suitable for sending over the wire that can be
141unserialized with a simple eval. It's often used as an alternative to
142XML in &quot;AJAX&quot; contexts because it is compact, fast, and much simpler
143to use for most purposes.</p>
144<p>To create a JSON serialization of any object, simply call
145<a class="mochiref reference" href="#fn-serializejson">serializeJSON()</a> with that object. To unserialize a JSON
146string, simply call <a class="mochiref reference" href="#fn-evaljson">evalJSON()</a> with the serialization.</p>
147<p>In order of precedence, <a class="mochiref reference" href="#fn-serializejson">serializeJSON</a> coerces the given
148argument into a JSON serialization:</p>
149<ol class="arabic simple">
150<li>Primitive types are returned as their JSON representation:
151<tt class="docutils literal"><span class="pre">string</span></tt>, <tt class="docutils literal"><span class="pre">number</span></tt>, <tt class="docutils literal"><span class="pre">boolean</span></tt>, <tt class="docutils literal"><span class="pre">null</span></tt>.</li>
152<li>If the object has a <tt class="docutils literal"><span class="pre">__json__</span></tt> or <tt class="docutils literal"><span class="pre">json</span></tt> method, then it is
153called with no arguments. If the result of this method is not the
154object itself, then the new object goes through rule processing
155again (e.g. it may return a string, which is then serialized in
156JSON format).</li>
157<li>If the object is <tt class="docutils literal"><span class="pre">Array</span></tt>-like (has a <tt class="docutils literal"><span class="pre">length</span></tt> property that is
158a number, and is not a function), then it is serialized as a JSON
159array. Each element will be processed according to these rules in
160order. Elements that can not be serialized (e.g. functions) will
161be replaced with <tt class="docutils literal"><span class="pre">undefined</span></tt>.</li>
162<li>The <tt class="docutils literal"><span class="pre">jsonRegistry</span></tt> <a class="mochiref reference" href="#fn-adapterregistry">AdapterRegistry</a> is consulted for
163an adapter for this object. JSON adapters take one argument (the
164object), and are expected to behave like a <tt class="docutils literal"><span class="pre">__json__</span></tt> or
165<tt class="docutils literal"><span class="pre">json</span></tt> method (return another object to be serialized, or
166itself).</li>
167<li>If the object is <tt class="docutils literal"><span class="pre">undefined</span></tt>, a <tt class="docutils literal"><span class="pre">TypeError</span></tt> is thrown. If you
168wish to serialize <tt class="docutils literal"><span class="pre">undefined</span></tt> as <tt class="docutils literal"><span class="pre">null</span></tt> or some other value, you
169should create an adapter to do so.</li>
170<li>If no adapter is available, the object is enumerated and
171serialized as a JSON object (name:value pairs). All names are
172expected to be strings. Each value is serialized according to
173these rules, and if it can not be serialized (e.g. methods), then
174that name:value pair will be skipped.</li>
175</ol>
176</div>
177<div class="section">
178<h2><a id="adapter-registries" name="adapter-registries">Adapter Registries</a></h2>
179<p>MochiKit makes extensive use of adapter registries, which enable you
180to implement object-specific behaviors for objects that you do not
181necessarily want to modify, such as built-in objects. This is
182especially useful because JavaScript does not provide a method for
183hiding user-defined properties from <tt class="docutils literal"><span class="pre">for</span> <span class="pre">propName</span> <span class="pre">in</span> <span class="pre">obj</span></tt>
184enumeration.</p>
185<p><a class="mochiref reference" href="#fn-adapterregistry">AdapterRegistry</a> is simply an encapsulation for an ordered
186list of &quot;check&quot; and &quot;wrap&quot; function pairs. Each
187<a class="mochiref reference" href="#fn-adapterregistry">AdapterRegistry</a> instance should perform one function, but
188may have multiple ways to achieve that function based upon the
189arguments. One way to think of it is as a poor man's generic function,
190or multiple dispatch (on arbitrary functions, not just type!).</p>
191<p>Check functions take one or more arguments, and return <tt class="docutils literal"><span class="pre">true</span></tt> if the
192argument list is suitable for the wrap function. Check functions
193should perform &quot;cheap&quot; checks of an object's type or contents, before
194the &quot;expensive&quot; wrap function is called.</p>
195<p>Wrap functions take the same arguments as check functions and do some
196operation, such as creating a programmer representation or comparing
197both arguments.</p>
198</div>
199<div class="section">
200<h2><a id="convenience-functions" name="convenience-functions">Convenience Functions</a></h2>
201<p>Much of <a class="mochiref reference" href="Base.html">MochiKit.Base</a> is there to simply remove the grunt
202work of doing generic JavaScript programming.</p>
203<p>Need to take every property from one object and set them on another?
204No problem, just call <a class="mochiref reference" href="#fn-update">update(dest, src)</a>! What if you just
205wanted to update keys that weren't already set? Look no further than
206<a class="mochiref reference" href="#fn-setdefault">setdefault(dest, src[, ...])</a>.</p>
207<p>Want to return a mutable object, but don't want to suffer the
208consequences if the user mutates it? Just <a class="mochiref reference" href="#fn-clone">clone(it)</a> and
209you'll get a copy-on-write clone. Cheaper than a copy!</p>
210<p>Need to extend an <tt class="docutils literal"><span class="pre">Array</span></tt> with another array? Or even an
211<tt class="docutils literal"><span class="pre">Array</span></tt>-like object such as a <tt class="docutils literal"><span class="pre">NodeList</span></tt> or the special
212<tt class="docutils literal"><span class="pre">arguments</span></tt> object? Even if you need to skip the first few elements
213of the source <tt class="docutils literal"><span class="pre">Array</span></tt>-like object, it's no problem with
214<a class="mochiref reference" href="#fn-extend">extend(dstArray, srcArrayLike[, skip])</a>!</p>
215<p>Wouldn't it be convenient to have all of the JavaScript operators were
216available as functions somewhere? That's what the
217<a class="mochiref reference" href="#fn-operators">operators</a> table is for, and it even comes with additional
218operators based on the <a class="mochiref reference" href="#fn-compare">compare</a> function.</p>
219<p>Need to walk some tree of objects and manipulate or find something in
220it? A DOM element tree perhaps? Use <a class="mochiref reference" href="#fn-nodewalk">nodeWalk(node,
221visitor)</a>!</p>
222<p>There's plenty more, so check out the <a class="reference" href="#api-reference">API Reference</a> below.</p>
223</div>
224<div class="section">
225<h2><a id="functional-programming" name="functional-programming">Functional Programming</a></h2>
226<p>Functional programming constructs such as <a class="mochiref reference" href="#fn-map">map</a> and
227<a class="mochiref reference" href="#fn-filter">filter</a> can save you a lot of time, because JavaScript
228iteration is error-prone and arduous. Writing less code is the best
229way to prevent bugs, and functional programming can help you do that.</p>
230<p><a class="mochiref reference" href="Base.html">MochiKit.Base</a> ships with a few simple Array-based
231functional programming constructs, namely <a class="mochiref reference" href="#fn-map">map</a> and
232<a class="mochiref reference" href="#fn-filter">filter</a>, and their &quot;extended&quot; brethren, <a class="mochiref reference" href="#fn-xmap">xmap</a>
233and <a class="mochiref reference" href="#fn-xfilter">xfilter</a>.</p>
234<p><a class="mochiref reference" href="#fn-map">map(func, arrayLike[, ...])</a> takes a function and an
235<tt class="docutils literal"><span class="pre">Array</span></tt>-like object, and creates a new <tt class="docutils literal"><span class="pre">Array</span></tt>. The new <tt class="docutils literal"><span class="pre">Array</span></tt>
236is the result of <tt class="docutils literal"><span class="pre">func(element)</span></tt> for every element of <tt class="docutils literal"><span class="pre">arrayLike</span></tt>,
237much like the <tt class="docutils literal"><span class="pre">Array.prototype.map</span></tt> extension in Mozilla. However,
238<a class="mochiref reference" href="Base.html">MochiKit.Base</a> takes that a step further and gives you the
239full blown Python version of <a class="mochiref reference" href="#fn-map">map</a>, which will take several
240<tt class="docutils literal"><span class="pre">Array</span></tt>-like objects, and calls the function with one argument per
241given <tt class="docutils literal"><span class="pre">Array</span></tt>-like, e.g.:</p>
242<pre class="literal-block">
243var arrayOne = [1, 2, 3, 4, 5];
244var arrayTwo = [1, 5, 2, 4, 3];
245var arrayThree = [5, 2, 1, 3, 4];
246var biggestElements = map(objMax, arrayOne, arrayTwo, arrayThree);
247assert( objEqual(biggestElements, [5, 5, 3, 4, 5]) );
248</pre>
249<p><a class="mochiref reference" href="#fn-filter">filter(func, arrayLike[, self])</a> takes a function and an
250<tt class="docutils literal"><span class="pre">Array</span></tt>-like object, and returns a new <tt class="docutils literal"><span class="pre">Array</span></tt>. This is basically
251identical to the <tt class="docutils literal"><span class="pre">Array.prototype.filter</span></tt> extension in
252Mozilla. self, if given, will be used as <tt class="docutils literal"><span class="pre">this</span></tt> in the context of
253func when called.</p>
254<p><a class="mochiref reference" href="#fn-xmap">xmap</a> and <a class="mochiref reference" href="#fn-xfilter">xfilter</a> are just special forms of
255<a class="mochiref reference" href="#fn-map">map</a> and <a class="mochiref reference" href="#fn-filter">filter</a> that accept a function as the
256first argument, and use the extra arguments as the <tt class="docutils literal"><span class="pre">Array</span></tt>-like. Not
257terribly interesting, but a definite time-saver in some cases.</p>
258<p>If you appreciate the functional programming facilities here, you
259should definitely check out <a class="mochiref reference" href="Iter.html">MochiKit.Iter</a>, which provides
260full blown iterators, <a class="mochiref reference" href="Iter.html#fn-range">MochiKit.Iter.range</a>,
261<a class="mochiref reference" href="Iter.html#fn-reduce">MochiKit.Iter.reduce</a>, and a near-complete port of Python's
262itertools <a class="footnote-reference" href="#id8" id="id3" name="id3">[2]</a> module, with some extra stuff thrown in for good
263measure!</p>
264</div>
265<div class="section">
266<h2><a id="bound-and-partial-functions" name="bound-and-partial-functions">Bound and Partial Functions</a></h2>
267<p>JavaScript's method-calling special form and lack of bound functions
268(functions that know what <tt class="docutils literal"><span class="pre">this</span></tt> should be) are one of the first
269stumbling blocks that programmers new to JavaScript face. The
270<a class="mochiref reference" href="#fn-bind">bind(func, self)</a> method fixes that right up by returning a
271new function that calls func with the right <tt class="docutils literal"><span class="pre">this</span></tt>.</p>
272<p>In order to take real advantage of all this fancy functional
273programming stuff, you're probably going to want partial
274application. This allows you to create a new function from an existing
275function that remembers some of the arguments. For example, if you
276wanted to compare a given object to a slew of other objects, you could
277do something like this:</p>
278<pre class="literal-block">
279compareWithOne = partial(compare, 1);
280results = map(compareWithOne, [0, 1, 2, 3]);
281assert( objEqual(results, [-1, 0, 1, 1]) );
282</pre>
283<p>One of the better uses of partial functions is in
284<a class="mochiref reference" href="DOM.html">MochiKit.DOM</a>, which is certainly a must-see for those of
285you creating lots of DOM elements with JavaScript!</p>
286</div>
287</div>
288<div class="section">
289<h1><a id="api-reference" name="api-reference">API Reference</a></h1>
290<div class="section">
291<h2><a id="errors" name="errors">Errors</a></h2>
292<p>
293<a name="fn-notfound"></a>
294<a class="mochidef reference" href="#fn-notfound">NotFound</a>:</p>
295<blockquote>
296<p>A singleton error raised when no suitable adapter is found</p>
297<dl class="docutils">
298<dt><em>Availability</em>:</dt>
299<dd>Available in MochiKit 1.3.1+</dd>
300</dl>
301</blockquote>
302</div>
303<div class="section">
304<h2><a id="constructors" name="constructors">Constructors</a></h2>
305<p>
306<a name="fn-adapterregistry"></a>
307<a class="mochidef reference" href="#fn-adapterregistry">AdapterRegistry</a>:</p>
308<blockquote>
309<p>A registry to facilitate adaptation.</p>
310<p>All <tt class="docutils literal"><span class="pre">check</span></tt>/<tt class="docutils literal"><span class="pre">wrap</span></tt> function pairs in a given registry should
311take the same number of arguments.</p>
312<dl class="docutils">
313<dt><em>Availability</em>:</dt>
314<dd>Available in MochiKit 1.3.1+</dd>
315</dl>
316</blockquote>
317<p>
318<a name="fn-adapterregistry.prototype.register"></a>
319<a class="mochidef reference" href="#fn-adapterregistry.prototype.register">AdapterRegistry.prototype.register(name, check, wrap[, override])</a>:</p>
320<blockquote>
321<dl class="docutils">
322<dt><tt class="docutils literal"><span class="pre">name</span></tt>:</dt>
323<dd>a unique identifier used to identify this adapter so that it
324may be unregistered.</dd>
325<dt><tt class="docutils literal"><span class="pre">check</span></tt>:</dt>
326<dd>function that should return <tt class="docutils literal"><span class="pre">true</span></tt> if the given arguments
327are appropriate for the <tt class="docutils literal"><span class="pre">wrap</span></tt> function.</dd>
328<dt><tt class="docutils literal"><span class="pre">wrap</span></tt>:</dt>
329<dd>function that takes the same parameters as <tt class="docutils literal"><span class="pre">check</span></tt> and does
330the adaptation. Every <tt class="docutils literal"><span class="pre">wrap</span></tt>/<tt class="docutils literal"><span class="pre">check</span></tt> function pair in the
331registry should have the same number of arguments.</dd>
332<dt><tt class="docutils literal"><span class="pre">override</span></tt>:</dt>
333<dd>if <tt class="docutils literal"><span class="pre">true</span></tt>, the <tt class="docutils literal"><span class="pre">check</span></tt> function will be
334given highest priority. Otherwise, the lowest.</dd>
335<dt><em>Availability</em>:</dt>
336<dd>Available in MochiKit 1.3.1+</dd>
337</dl>
338</blockquote>
339<p>
340<a name="fn-adapterregistry.prototype.match"></a>
341<a class="mochidef reference" href="#fn-adapterregistry.prototype.match">AdapterRegistry.prototype.match(obj[, ...])</a>:</p>
342<blockquote>
343<p>Find an adapter for the given arguments by calling every <tt class="docutils literal"><span class="pre">check</span></tt>
344function until one returns <tt class="docutils literal"><span class="pre">true</span></tt>.</p>
345<p>If no suitable adapter is found, throws <a class="mochiref reference" href="#fn-notfound">NotFound</a>.</p>
346<dl class="docutils">
347<dt><em>Availability</em>:</dt>
348<dd>Available in MochiKit 1.3.1+</dd>
349</dl>
350</blockquote>
351<p>
352<a name="fn-adapterregistry.prototype.unregister"></a>
353<a class="mochidef reference" href="#fn-adapterregistry.prototype.unregister">AdapterRegistry.prototype.unregister(name)</a>:</p>
354<blockquote>
355<p>Remove a named adapter from the registry</p>
356<dl class="docutils">
357<dt><em>Availability</em>:</dt>
358<dd>Available in MochiKit 1.3.1+</dd>
359</dl>
360</blockquote>
361<p>
362<a name="fn-namederror"></a>
363<a class="mochidef reference" href="#fn-namederror">NamedError</a>:</p>
364<blockquote>
365<p>Convenience constructor for creating new errors
366(e.g. <a class="mochiref reference" href="#fn-notfound">NotFound</a>)</p>
367<dl class="docutils">
368<dt><em>Availability</em>:</dt>
369<dd>Available in MochiKit 1.3.1+</dd>
370</dl>
371</blockquote>
372</div>
373<div class="section">
374<h2><a id="functions" name="functions">Functions</a></h2>
375<p>
376<a name="fn-arrayequal"></a>
377<a class="mochidef reference" href="#fn-arrayequal">arrayEqual(self, arr)</a>:</p>
378<blockquote>
379<p>Compare the arrays <tt class="docutils literal"><span class="pre">self</span></tt> and <tt class="docutils literal"><span class="pre">arr</span></tt> for equality using
380<tt class="docutils literal"><span class="pre">compare</span></tt> on each element. Uses a fast-path for length
381differences.</p>
382<dl class="docutils">
383<dt><em>Availability</em>:</dt>
384<dd>Available in MochiKit 1.3.1+</dd>
385</dl>
386</blockquote>
387<p>
388<a name="fn-average"></a>
389<a class="mochidef reference" href="#fn-average">average(lst[, ...])</a>:</p>
390<blockquote>
391<p>This function is an alias of <a class="mochiref reference" href="#fn-mean">mean()</a>.</p>
392<dl class="docutils">
393<dt><em>Availability</em>:</dt>
394<dd>Available in MochiKit 1.3.1+</dd>
395</dl>
396</blockquote>
397<p>
398<a name="fn-bind"></a>
399<a class="mochidef reference" href="#fn-bind">bind(func, self[, arg, ...])</a>:</p>
400<blockquote>
401<p>Return a copy of <tt class="docutils literal"><span class="pre">func</span></tt> bound to <tt class="docutils literal"><span class="pre">self</span></tt>. This means whenever
402and however the returned function is called, <tt class="docutils literal"><span class="pre">this</span></tt> will always
403reference the given <tt class="docutils literal"><span class="pre">self</span></tt>. <tt class="docutils literal"><span class="pre">func</span></tt> may be either a function
404object, or a string. If it is a string, then <tt class="docutils literal"><span class="pre">self[func]</span></tt> will
405be used, making these two statements equivalent:</p>
406<pre class="literal-block">
407bind(&quot;method&quot;, self);
408bind(self.method, self);
409</pre>
410<p>Calling <a class="mochiref reference" href="#fn-bind">bind(func, self)</a> on an already bound function
411will return a new function that is bound to the new <tt class="docutils literal"><span class="pre">self</span></tt>! If
412<tt class="docutils literal"><span class="pre">self</span></tt> is <tt class="docutils literal"><span class="pre">undefined</span></tt>, then the previous <tt class="docutils literal"><span class="pre">self</span></tt> is used. If
413<tt class="docutils literal"><span class="pre">self</span></tt> is <tt class="docutils literal"><span class="pre">null</span></tt>, then the <tt class="docutils literal"><span class="pre">this</span></tt> object is used (which may
414or may not be the global object). To force binding to the global
415object, you should pass it explicitly.</p>
416<p>Additional arguments, if given, will be partially applied to the
417function. These three expressions are equivalent and return
418equally efficient functions (<a class="mochiref reference" href="#fn-bind">bind</a> and
419<a class="mochiref reference" href="#fn-partial">partial</a> share the same code path):</p>
420<ul class="simple">
421<li><a class="mochiref reference" href="#fn-bind">bind(oldfunc, self, arg1, arg2)</a></li>
422<li><a class="mochiref reference" href="#fn-bind">bind(partial(oldfunc, arg1, arg2), self)</a></li>
423<li><a class="mochiref reference" href="#fn-partial">partial(bind(oldfunc, self), arg1, arg2)</a></li>
424</ul>
425<dl class="docutils">
426<dt><em>Availability</em>:</dt>
427<dd>Available in MochiKit 1.3.1+</dd>
428</dl>
429</blockquote>
430<p>
431<a name="fn-bindmethods"></a>
432<a class="mochidef reference" href="#fn-bindmethods">bindMethods(self)</a>:</p>
433<blockquote>
434<p>Replace all functions <tt class="docutils literal"><span class="pre">meth</span></tt> on <tt class="docutils literal"><span class="pre">self</span></tt> with
435<a class="mochiref reference" href="#fn-bind">bind(meth, self)</a>. This emulates Python's bound
436instance methods, where there is no need to worry about preserving
437<tt class="docutils literal"><span class="pre">this</span></tt> when the method is used as a callback.</p>
438<dl class="docutils">
439<dt><em>Availability</em>:</dt>
440<dd>Available in MochiKit 1.3.1+</dd>
441</dl>
442</blockquote>
443<p>
444<a name="fn-camelize"></a>
445<a class="mochidef reference" href="#fn-camelize">camelize(str)</a>:</p>
446<blockquote>
447<p>Converts hyphenated strings to camelCase:</p>
448<pre class="literal-block">
449assert( camelize(&quot;border-left&quot;) == &quot;borderLeft&quot; );
450</pre>
451<dl class="docutils">
452<dt><em>Availability</em>:</dt>
453<dd>Available in MochiKit 1.4+</dd>
454</dl>
455</blockquote>
456<p>
457<a name="fn-clone"></a>
458<a class="mochidef reference" href="#fn-clone">clone(obj)</a>:</p>
459<blockquote>
460<p>Return a new object using <tt class="docutils literal"><span class="pre">obj</span></tt> as its prototype. Use this if
461you want to return a mutable object (e.g. instance state), but
462don't want the user to mutate it. If they do, it won't have any
463effect on the original <tt class="docutils literal"><span class="pre">obj</span></tt>.</p>
464<p>Note that this is a shallow clone, so mutable properties will have
465to be cloned separately if you want to &quot;protect&quot; them.</p>
466<dl class="docutils">
467<dt><em>Availability</em>:</dt>
468<dd>Available in MochiKit 1.3.1+</dd>
469</dl>
470</blockquote>
471<p>
472<a name="fn-compare"></a>
473<a class="mochidef reference" href="#fn-compare">compare(a, b)</a>:</p>
474<blockquote>
475<p>Compare two objects in a sensible manner. Currently this is:</p>
476<ol class="arabic simple">
477<li><tt class="docutils literal"><span class="pre">undefined</span></tt> and <tt class="docutils literal"><span class="pre">null</span></tt> compare equal to each other</li>
478<li><tt class="docutils literal"><span class="pre">undefined</span></tt> and <tt class="docutils literal"><span class="pre">null</span></tt> are less than anything else</li>
479<li>If JavaScript says <tt class="docutils literal"><span class="pre">a</span> <span class="pre">==</span> <span class="pre">b</span></tt>, then we trust it</li>
480<li>comparators registered with registerComparator are used to
481find a good comparator. Built-in comparators are currently
482available for <tt class="docutils literal"><span class="pre">Array</span></tt>-like and <tt class="docutils literal"><span class="pre">Date</span></tt>-like objects.</li>
483<li>Otherwise hope that the built-in comparison operators do
484something useful, which should work for numbers and strings.</li>
485<li>If neither <tt class="docutils literal"><span class="pre">a</span> <span class="pre">&lt;</span> <span class="pre">b</span></tt> or <tt class="docutils literal"><span class="pre">a</span> <span class="pre">&gt;</span> <span class="pre">b</span></tt>, then throw a <tt class="docutils literal"><span class="pre">TypeError</span></tt></li>
486</ol>
487<p>Returns what one would expect from a comparison function:</p>
488<table border="1" class="docutils">
489<colgroup>
490<col width="42%" />
491<col width="58%" />
492</colgroup>
493<tbody valign="top">
494<tr><td>Value</td>
495<td>Condition</td>
496</tr>
497<tr><td><tt class="docutils literal"><span class="pre">0</span></tt></td>
498<td><tt class="docutils literal"><span class="pre">a</span> <span class="pre">==</span> <span class="pre">b</span></tt></td>
499</tr>
500<tr><td><tt class="docutils literal"><span class="pre">1</span></tt></td>
501<td><tt class="docutils literal"><span class="pre">a</span> <span class="pre">&gt;</span> <span class="pre">b</span></tt></td>
502</tr>
503<tr><td><tt class="docutils literal"><span class="pre">-1</span></tt></td>
504<td><tt class="docutils literal"><span class="pre">a</span> <span class="pre">&lt;</span> <span class="pre">b</span></tt></td>
505</tr>
506</tbody>
507</table>
508<dl class="docutils">
509<dt><em>Availability</em>:</dt>
510<dd>Available in MochiKit 1.3.1+</dd>
511</dl>
512</blockquote>
513<p>
514<a name="fn-compose"></a>
515<a class="mochidef reference" href="#fn-compose">compose(f1, f2, ..., fN)</a>:</p>
516<blockquote>
517<p>Return a new function as the combination of the given function
518arguments, equivalent to <tt class="docutils literal"><span class="pre">f1(f2(arguments))</span></tt>.</p>
519<dl class="docutils">
520<dt><em>Availability</em>:</dt>
521<dd>Available in MochiKit 1.4+</dd>
522</dl>
523</blockquote>
524<p>
525<a name="fn-concat"></a>
526<a class="mochidef reference" href="#fn-concat">concat(lst[, ...])</a>:</p>
527<blockquote>
528<p>Concatenates all given <tt class="docutils literal"><span class="pre">Array</span></tt>-like arguments and returns
529a new <tt class="docutils literal"><span class="pre">Array</span></tt>:</p>
530<pre class="literal-block">
531var lst = concat([&quot;1&quot;,&quot;3&quot;,&quot;5&quot;], [&quot;2&quot;,&quot;4&quot;,&quot;6&quot;]);
532assert( lst.toString() == &quot;1,3,5,2,4,6&quot; );
533</pre>
534<dl class="docutils">
535<dt><em>Availability</em>:</dt>
536<dd>Available in MochiKit 1.3.1+</dd>
537</dl>
538</blockquote>
539<p>
540<a name="fn-counter"></a>
541<a class="mochidef reference" href="#fn-counter">counter(n=1)</a>:</p>
542<blockquote>
543<p>Returns a function that will return a number one greater than
544the previous returned value, starting at <tt class="docutils literal"><span class="pre">n</span></tt>. For example:</p>
545<pre class="literal-block">
546nextId = counter()
547assert( nextId() == 1 )
548assert( nextId() == 2 )
549</pre>
550<p>For an iterator with this behavior, see
551<a class="mochiref reference" href="Iter.html#fn-count">MochiKit.Iter.count</a>.</p>
552<dl class="docutils">
553<dt><em>Availability</em>:</dt>
554<dd>Available in MochiKit 1.3.1+</dd>
555</dl>
556</blockquote>
557<p>
558<a name="fn-extend"></a>
559<a class="mochidef reference" href="#fn-extend">extend(self, obj, skip=0)</a>:</p>
560<blockquote>
561<p>Mutate the array <tt class="docutils literal"><span class="pre">self</span></tt> by extending it with an <tt class="docutils literal"><span class="pre">Array</span></tt>-like
562<tt class="docutils literal"><span class="pre">obj</span></tt>, starting from index <tt class="docutils literal"><span class="pre">skip</span></tt>. If <tt class="docutils literal"><span class="pre">null</span></tt> is given as the
563initial array, a new one will be created.</p>
564<p>This mutates <em>and returns</em> <tt class="docutils literal"><span class="pre">self</span></tt>, be warned.</p>
565<dl class="docutils">
566<dt><em>Availability</em>:</dt>
567<dd>Available in MochiKit 1.3.1+</dd>
568</dl>
569</blockquote>
570<p>
571<a name="fn-evaljson"></a>
572<a class="mochidef reference" href="#fn-evaljson">evalJSON(aJSONString)</a>:</p>
573<blockquote>
574<p>Unserialize a JSON <a class="footnote-reference" href="#id7" id="id4" name="id4">[1]</a> represenation of an object.</p>
575<p>Note that this uses the <tt class="docutils literal"><span class="pre">eval</span></tt> function of the interpreter, and
576therefore trusts the contents of <tt class="docutils literal"><span class="pre">aJSONString</span></tt> to be safe. This
577is acceptable when the JSON and JavaScript application originate
578from the same server, but in other scenarios it may not be the
579appropriate security model. Currently, a validating JSON parser is
580beyond the scope of MochiKit, but there is one available from
581json.org <a class="footnote-reference" href="#id7" id="id5" name="id5">[1]</a>.</p>
582<dl class="docutils">
583<dt><em>Availability</em>:</dt>
584<dd>Available in MochiKit 1.3.1+</dd>
585</dl>
586</blockquote>
587<p>
588<a name="fn-filter"></a>
589<a class="mochidef reference" href="#fn-filter">filter(fn, lst)</a>:</p>
590<blockquote>
591<p>Returns a new <tt class="docutils literal"><span class="pre">Array</span></tt> composed of all elements from <tt class="docutils literal"><span class="pre">lst</span></tt>
592where <tt class="docutils literal"><span class="pre">fn(lst[i])</span></tt> returns a true value.</p>
593<p>If <tt class="docutils literal"><span class="pre">fn</span></tt> is <tt class="docutils literal"><span class="pre">null</span></tt>, <tt class="docutils literal"><span class="pre">operator.truth</span></tt> will be used.</p>
594<dl class="docutils">
595<dt><em>Availability</em>:</dt>
596<dd>Available in MochiKit 1.3.1+</dd>
597</dl>
598</blockquote>
599<p>
600<a name="fn-findvalue"></a>
601<a class="mochidef reference" href="#fn-findvalue">findValue(lst, value, start=0, end=lst.length)</a>:</p>
602<blockquote>
603<p>Finds the index of <tt class="docutils literal"><span class="pre">value</span></tt> in the <tt class="docutils literal"><span class="pre">Array</span></tt>-like object <tt class="docutils literal"><span class="pre">lst</span></tt>
604using <a class="mochiref reference" href="#fn-compare">compare</a>. The search starts at the index
605<tt class="docutils literal"><span class="pre">start</span></tt>, and ends at the index <tt class="docutils literal"><span class="pre">end</span> <span class="pre">-</span> <span class="pre">1</span></tt>. If <tt class="docutils literal"><span class="pre">value</span></tt> is not
606found in <tt class="docutils literal"><span class="pre">lst</span></tt>, it will return <tt class="docutils literal"><span class="pre">-1</span></tt>.</p>
607<p>For example:</p>
608<pre class="literal-block">
609assert( findValue([1, 2, 3, 2, 1], 2) == 1 )
610assert( findValue([1, 2, 3, 2, 1], 2, 2) == 3 )
611</pre>
612<dl class="docutils">
613<dt><em>Availability</em>:</dt>
614<dd>Available in MochiKit 1.3.1+</dd>
615</dl>
616</blockquote>
617<p>
618<a name="fn-findidentical"></a>
619<a class="mochidef reference" href="#fn-findidentical">findIdentical(lst, value, start=0, end=lst.length)</a>:</p>
620<blockquote>
621<p>Finds the index of <tt class="docutils literal"><span class="pre">value</span></tt> in the <tt class="docutils literal"><span class="pre">Array</span></tt>-like object <tt class="docutils literal"><span class="pre">lst</span></tt>
622using the <tt class="docutils literal"><span class="pre">===</span></tt> operator. The search starts at the index
623<tt class="docutils literal"><span class="pre">start</span></tt>, and ends at the index <tt class="docutils literal"><span class="pre">end</span> <span class="pre">-</span> <span class="pre">1</span></tt>. If <tt class="docutils literal"><span class="pre">value</span></tt> is not
624found in <tt class="docutils literal"><span class="pre">lst</span></tt>, it will return <tt class="docutils literal"><span class="pre">-1</span></tt>.</p>
625<p>You should use this function instead of <a class="mochiref reference" href="#fn-findvalue">findValue</a> if
626<tt class="docutils literal"><span class="pre">lst</span></tt> may be comprised of objects for which no comparator is
627defined and all you care about is finding an identical object
628(e.g. the same instance), or if <tt class="docutils literal"><span class="pre">lst</span></tt> is comprised of just
629numbers or strings and performance is important.</p>
630<p>For example:</p>
631<pre class="literal-block">
632assert( findIdentical([1, 2, 3, 2, 1], 2) == 1 )
633assert( findIdentical([1, 2, 3, 2, 1], 2, 2) == 3 )
634</pre>
635<dl class="docutils">
636<dt><em>Availability</em>:</dt>
637<dd>Available in MochiKit 1.3.1+</dd>
638</dl>
639</blockquote>
640<p>
641<a name="fn-flattenarguments"></a>
642<a class="mochidef reference" href="#fn-flattenarguments">flattenArguments(arg[, ...])</a>:</p>
643<blockquote>
644<p>Given a bunch of arguments, return a single <tt class="docutils literal"><span class="pre">Array</span></tt> containing
645all of those arguments. Any <tt class="docutils literal"><span class="pre">Array</span></tt>-like argument will be extended
646in-place, e.g.:</p>
647<pre class="literal-block">
648compare(flattenArguments(1, [2, 3, [4, 5]]), [1, 2, 3, 4, 5]) == 0
649</pre>
650<dl class="docutils">
651<dt><em>Availability</em>:</dt>
652<dd>Available in MochiKit 1.3.1+</dd>
653</dl>
654</blockquote>
655<p>
656<a name="fn-flattenarray"></a>
657<a class="mochidef reference" href="#fn-flattenarray">flattenArray(lst)</a>:</p>
658<blockquote>
659<p>Return a new <tt class="docutils literal"><span class="pre">Array</span></tt> consisting of every item in lst with <tt class="docutils literal"><span class="pre">Array</span></tt>
660items expanded in-place recursively. This differs from
661<a class="mochiref reference" href="#fn-flattenarguments">flattenArguments</a> in that it only takes one argument and
662it only flattens items that are <tt class="docutils literal"><span class="pre">instanceof</span> <span class="pre">Array</span></tt>.</p>
663<blockquote>
664compare(flattenArray([1, [2, 3, [4, 5]]]), [1, 2, 3, 4, 5]) == 0</blockquote>
665<dl class="docutils">
666<dt><em>Availability</em>:</dt>
667<dd>Available in MochiKit 1.4+</dd>
668</dl>
669</blockquote>
670<p>
671<a name="fn-forwardcall"></a>
672<a class="mochidef reference" href="#fn-forwardcall">forwardCall(name)</a>:</p>
673<blockquote>
674<p>Returns a function that forwards a method call to
675<tt class="docutils literal"><span class="pre">this.name(...)</span></tt></p>
676<dl class="docutils">
677<dt><em>Availability</em>:</dt>
678<dd>Available in MochiKit 1.3.1+</dd>
679</dl>
680</blockquote>
681<p>
682<a name="fn-isarraylike"></a>
683<a class="mochidef reference" href="#fn-isarraylike">isArrayLike(obj[, ...])</a>:</p>
684<blockquote>
685<p>Returns <tt class="docutils literal"><span class="pre">true</span></tt> if all given arguments are <tt class="docutils literal"><span class="pre">Array</span></tt>-like (have a
686<tt class="docutils literal"><span class="pre">.length</span></tt> property and <tt class="docutils literal"><span class="pre">typeof(obj)</span> <span class="pre">==</span> <span class="pre">'object'</span></tt>)</p>
687<dl class="docutils">
688<dt><em>Availability</em>:</dt>
689<dd>Available in MochiKit 1.3.1+</dd>
690</dl>
691</blockquote>
692<p>
693<a name="fn-isdatelike"></a>
694<a class="mochidef reference" href="#fn-isdatelike">isDateLike(obj[, ...])</a>:</p>
695<blockquote>
696<p>Returns <tt class="docutils literal"><span class="pre">true</span></tt> if all given arguments are <tt class="docutils literal"><span class="pre">Date</span></tt>-like (have a
697<tt class="docutils literal"><span class="pre">.getTime()</span></tt> method)</p>
698<dl class="docutils">
699<dt><em>Availability</em>:</dt>
700<dd>Available in MochiKit 1.3.1+</dd>
701</dl>
702</blockquote>
703<p>
704<a name="fn-isempty"></a>
705<a class="mochidef reference" href="#fn-isempty">isEmpty(obj[, ...])</a>:</p>
706<blockquote>
707<p>Returns <tt class="docutils literal"><span class="pre">true</span></tt> if all the given <tt class="docutils literal"><span class="pre">Array</span></tt>-like or string
708arguments are empty <tt class="docutils literal"><span class="pre">(obj.length</span> <span class="pre">==</span> <span class="pre">0)</span></tt></p>
709<dl class="docutils">
710<dt><em>Availability</em>:</dt>
711<dd>Available in MochiKit 1.3.1+</dd>
712</dl>
713</blockquote>
714<p>
715<a name="fn-isnotempty"></a>
716<a class="mochidef reference" href="#fn-isnotempty">isNotEmpty(obj[, ...])</a>:</p>
717<blockquote>
718<p>Returns <tt class="docutils literal"><span class="pre">true</span></tt> if all the given <tt class="docutils literal"><span class="pre">Array</span></tt>-like or string
719arguments are not empty <tt class="docutils literal"><span class="pre">(obj.length</span> <span class="pre">&gt;</span> <span class="pre">0)</span></tt></p>
720<dl class="docutils">
721<dt><em>Availability</em>:</dt>
722<dd>Available in MochiKit 1.3.1+</dd>
723</dl>
724</blockquote>
725<p>
726<a name="fn-isnull"></a>
727<a class="mochidef reference" href="#fn-isnull">isNull(obj[, ...])</a>:</p>
728<blockquote>
729<p>Returns <tt class="docutils literal"><span class="pre">true</span></tt> if all arguments are <tt class="docutils literal"><span class="pre">null</span></tt>.</p>
730<dl class="docutils">
731<dt><em>Availability</em>:</dt>
732<dd>Available in MochiKit 1.3.1+</dd>
733</dl>
734</blockquote>
735<p>
736<a name="fn-isundefinedornull"></a>
737<a class="mochidef reference" href="#fn-isundefinedornull">isUndefinedOrNull(obj[, ...])</a>:</p>
738<blockquote>
739<p>Returns <tt class="docutils literal"><span class="pre">true</span></tt> if all arguments are undefined or <tt class="docutils literal"><span class="pre">null</span></tt></p>
740<dl class="docutils">
741<dt><em>Availability</em>:</dt>
742<dd>Available in MochiKit 1.3.1+</dd>
743</dl>
744</blockquote>
745<p>
746<a name="fn-itemgetter"></a>
747<a class="mochidef reference" href="#fn-itemgetter">itemgetter(name)</a>:</p>
748<blockquote>
749<p>Returns a <tt class="docutils literal"><span class="pre">function(obj)</span></tt> that returns <tt class="docutils literal"><span class="pre">obj[name]</span></tt></p>
750<dl class="docutils">
751<dt><em>Availability</em>:</dt>
752<dd>Available in MochiKit 1.3.1+</dd>
753</dl>
754</blockquote>
755<p>
756<a name="fn-items"></a>
757<a class="mochidef reference" href="#fn-items">items(obj)</a>:</p>
758<blockquote>
759<p>Return an <tt class="docutils literal"><span class="pre">Array</span></tt> of <tt class="docutils literal"><span class="pre">[propertyName,</span> <span class="pre">propertyValue]</span></tt> pairs for
760the given <tt class="docutils literal"><span class="pre">obj</span></tt> (in the order determined by <tt class="docutils literal"><span class="pre">for</span> <span class="pre">propName</span> <span class="pre">in</span>
761<span class="pre">obj</span></tt>).</p>
762<dl class="docutils">
763<dt><em>Availability</em>:</dt>
764<dd>Available in MochiKit 1.3.1+</dd>
765</dl>
766</blockquote>
767<p>
768<a name="fn-keycomparator"></a>
769<a class="mochidef reference" href="#fn-keycomparator">keyComparator(key[, ...])</a>:</p>
770<blockquote>
771<p>A comparator factory that compares <tt class="docutils literal"><span class="pre">a[key]</span></tt> with <tt class="docutils literal"><span class="pre">b[key]</span></tt>.
772e.g.:</p>
773<pre class="literal-block">
774var lst = [&quot;a&quot;, &quot;bbb&quot;, &quot;cc&quot;];
775lst.sort(keyComparator(&quot;length&quot;));
776assert( lst.toString() == &quot;a,cc,bbb&quot; );
777</pre>
778<dl class="docutils">
779<dt><em>Availability</em>:</dt>
780<dd>Available in MochiKit 1.3.1+</dd>
781</dl>
782</blockquote>
783<p>
784<a name="fn-keys"></a>
785<a class="mochidef reference" href="#fn-keys">keys(obj)</a>:</p>
786<blockquote>
787<p>Return an <tt class="docutils literal"><span class="pre">Array</span></tt> of the property names of an object (in the
788order determined by <tt class="docutils literal"><span class="pre">for</span> <span class="pre">propName</span> <span class="pre">in</span> <span class="pre">obj</span></tt>).</p>
789<dl class="docutils">
790<dt><em>Availability</em>:</dt>
791<dd>Available in MochiKit 1.3.1+</dd>
792</dl>
793</blockquote>
794<p>
795<a name="fn-listmax"></a>
796<a class="mochidef reference" href="#fn-listmax">listMax(lst)</a>:</p>
797<blockquote>
798<p>Return the largest element of an <tt class="docutils literal"><span class="pre">Array</span></tt>-like object, as
799determined by <a class="mochiref reference" href="#fn-compare">compare</a>. This is a special form of
800<a class="mochiref reference" href="#fn-listminmax">listMinMax</a>, specifically
801<a class="mochiref reference" href="#fn-partial">partial(listMinMax, 1)</a>.</p>
802<dl class="docutils">
803<dt><em>Availability</em>:</dt>
804<dd>Available in MochiKit 1.3.1+</dd>
805</dl>
806</blockquote>
807<p>
808<a name="fn-listmin"></a>
809<a class="mochidef reference" href="#fn-listmin">listMin(lst)</a>:</p>
810<blockquote>
811<p>Return the smallest element of an <tt class="docutils literal"><span class="pre">Array</span></tt>-like object, as
812determined by <a class="mochiref reference" href="#fn-compare">compare</a>. This is a special form of
813<a class="mochiref reference" href="#fn-listminmax">listMinMax</a>, specifically
814<a class="mochiref reference" href="#fn-partial">partial(listMinMax, -1)</a>.</p>
815<dl class="docutils">
816<dt><em>Availability</em>:</dt>
817<dd>Available in MochiKit 1.3.1+</dd>
818</dl>
819</blockquote>
820<p>
821<a name="fn-listminmax"></a>
822<a class="mochidef reference" href="#fn-listminmax">listMinMax(which, lst)</a>:</p>
823<blockquote>
824<p>If <tt class="docutils literal"><span class="pre">which</span> <span class="pre">==</span> <span class="pre">-1</span></tt> then it will return the smallest element of the
825<tt class="docutils literal"><span class="pre">Array</span></tt>-like <tt class="docutils literal"><span class="pre">lst</span></tt>. This is also available as
826<a class="mochiref reference" href="#fn-listmin">listMin(lst)</a>.</p>
827<p>If <tt class="docutils literal"><span class="pre">which</span> <span class="pre">==</span> <span class="pre">1</span></tt> then it will return the largest element of the
828<tt class="docutils literal"><span class="pre">Array</span></tt>-like <tt class="docutils literal"><span class="pre">lst</span></tt>. This is also available as
829<a class="mochiref reference" href="#fn-listmax">listMax(list)</a>.</p>
830<dl class="docutils">
831<dt><em>Availability</em>:</dt>
832<dd>Available in MochiKit 1.3.1+</dd>
833</dl>
834</blockquote>
835<p>
836<a name="fn-map"></a>
837<a class="mochidef reference" href="#fn-map">map(fn, lst[, ...])</a>:</p>
838<blockquote>
839<p>Return a new array composed of the results of <tt class="docutils literal"><span class="pre">fn(x)</span></tt> for every
840<tt class="docutils literal"><span class="pre">x</span></tt> in <tt class="docutils literal"><span class="pre">lst</span></tt>.</p>
841<p>If <tt class="docutils literal"><span class="pre">fn</span></tt> is <tt class="docutils literal"><span class="pre">null</span></tt>, and only one sequence argument is given the
842identity function is used.</p>
843<blockquote>
844<a class="mochiref reference" href="#fn-map">map(null, lst)</a> -&gt; <tt class="docutils literal"><span class="pre">lst.slice()</span></tt>;</blockquote>
845<p>If <tt class="docutils literal"><span class="pre">fn</span></tt> is not <tt class="docutils literal"><span class="pre">null</span></tt> and more than one sequence argument is
846given, then one element from each sequence is used to build the
847argument list for <tt class="docutils literal"><span class="pre">fn</span></tt>.</p>
848<blockquote>
849<dl class="docutils">
850<dt><a class="mochiref reference" href="#fn-map">map(fn, p, q, ...)</a></dt>
851<dd>-&gt; <tt class="docutils literal"><span class="pre">[fn(p[0],</span> <span class="pre">q[0],</span> <span class="pre">..),</span> <span class="pre">fn(p[1],</span> <span class="pre">q[1],</span> <span class="pre">...),</span> <span class="pre">...]</span></tt></dd>
852</dl>
853</blockquote>
854<p>If <tt class="docutils literal"><span class="pre">fn</span></tt> is <tt class="docutils literal"><span class="pre">null</span></tt>, and more than one sequence is given as
855arguments, then the <tt class="docutils literal"><span class="pre">Array</span></tt> function is used, making it
856equivalent to <a class="mochiref reference" href="Iter.html#fn-zip">MochiKit.Iter.zip</a>.</p>
857<blockquote>
858<dl class="docutils">
859<dt><a class="mochiref reference" href="#fn-map">map(null, p, q, ...)</a></dt>
860<dd>-&gt; <a class="mochiref reference" href="Iter.html#fn-zip">MochiKit.Iter.zip(p, q, ...)</a>
861-&gt; <tt class="docutils literal"><span class="pre">[[p0,</span> <span class="pre">q0,</span> <span class="pre">...],</span> <span class="pre">[p1,</span> <span class="pre">q1,</span> <span class="pre">...],</span> <span class="pre">...];</span></tt></dd>
862</dl>
863</blockquote>
864<dl class="docutils">
865<dt><em>Availability</em>:</dt>
866<dd>Available in MochiKit 1.3.1+</dd>
867</dl>
868</blockquote>
869<p>
870<a name="fn-mean"></a>
871<a class="mochidef reference" href="#fn-mean">mean(lst[, ...])</a>:</p>
872<blockquote>
873<p>Returns the arithmetic mean (average) of the argument list, or an array.
874This function applies <a class="mochiref reference" href="#fn-flattenarguments">flattenArguments()</a> to the argument list.</p>
875<dl class="docutils">
876<dt><em>Availability</em>:</dt>
877<dd>Available in MochiKit 1.4+</dd>
878</dl>
879</blockquote>
880<p>
881<a name="fn-median"></a>
882<a class="mochidef reference" href="#fn-median">median(lst[, ...])</a>:</p>
883<blockquote>
884<p>Returns the median of the argument list, or an array. This function
885applies <a class="mochiref reference" href="#fn-flattenarguments">flattenArguments()</a> to the argument list.</p>
886<dl class="docutils">
887<dt><em>Availability</em>:</dt>
888<dd>Available in MochiKit 1.4+</dd>
889</dl>
890</blockquote>
891<p>
892<a name="fn-merge"></a>
893<a class="mochidef reference" href="#fn-merge">merge(obj[, ...])</a>:</p>
894<blockquote>
895<p>Create a new instance of <tt class="docutils literal"><span class="pre">Object</span></tt> that contains every property
896from all given objects. If a property is defined on more than one
897of the objects, the last property is used.</p>
898<p>This is a special form of <a class="mochiref reference" href="#fn-update">update(self, obj[, ...])</a>,
899specifically, it is defined as <a class="mochiref reference" href="#fn-partial">partial(update, null)</a>.</p>
900<dl class="docutils">
901<dt><em>Availability</em>:</dt>
902<dd>Available in MochiKit 1.3.1+</dd>
903</dl>
904</blockquote>
905<p>
906<a name="fn-method"></a>
907<a class="mochidef reference" href="#fn-method">method(self, func, ...)</a>:</p>
908<blockquote>
909<p>Alternate form of <a class="mochiref reference" href="#fn-bind">bind</a> that takes the object before
910the function. These two calls are equivalent:</p>
911<pre class="literal-block">
912bind(&quot;method&quot;, myobject)
913method(myobject, &quot;method&quot;)
914</pre>
915<dl class="docutils">
916<dt><em>Availability</em>:</dt>
917<dd>Available in MochiKit 1.3.1+</dd>
918</dl>
919</blockquote>
920<p>
921<a name="fn-methodcaller"></a>
922<a class="mochidef reference" href="#fn-methodcaller">methodcaller(name[, args...])</a>:</p>
923<blockquote>
924<p>Return a new function that calls a method on its argument,
925for example:</p>
926<pre class="literal-block">
927lst = map(methodcaller(&quot;toLowerCase&quot;), [&quot;THIS&quot;, &quot;is&quot;, &quot;LoWeRCaSe&quot;]);
928assert( lst.join(&quot; &quot;) == &quot;this is lowercase&quot; );
929</pre>
930<dl class="docutils">
931<dt><em>Availability</em>:</dt>
932<dd>Available in MochiKit 1.4+</dd>
933</dl>
934</blockquote>
935<p>
936<a name="fn-namefunctions"></a>
937<a class="mochidef reference" href="#fn-namefunctions">nameFunctions(namespace)</a>:</p>
938<blockquote>
939<p>Given a <tt class="docutils literal"><span class="pre">namespace</span></tt> (object or function) with a <tt class="docutils literal"><span class="pre">NAME</span></tt>
940property, find all methods in it and give them nice <tt class="docutils literal"><span class="pre">NAME</span></tt>
941properties too (for use with <a class="mochiref reference" href="#fn-repr">repr</a>). e.g.:</p>
942<pre class="literal-block">
943namespace = {
944 NAME: &quot;Awesome&quot;,
945 Dude: function () {}
946}
947nameFunctions(namespace);
948assert( namespace.Dude.NAME == 'Awesome.Dude' );
949</pre>
950<dl class="docutils">
951<dt><em>Availability</em>:</dt>
952<dd>Available in MochiKit 1.3.1+</dd>
953</dl>
954</blockquote>
955<p>
956<a name="fn-noop"></a>
957<a class="mochidef reference" href="#fn-noop">noop()</a>:</p>
958<blockquote>
959<p>A function that performs no operation. Use this where you would
960otherwise use <tt class="docutils literal"><span class="pre">(function</span> <span class="pre">()</span> <span class="pre">{})</span></tt> in order to avoid Internet
961Explorer cyclic garbage leakage.</p>
962<dl class="docutils">
963<dt><em>Availability</em>:</dt>
964<dd>Available in MochiKit 1.4</dd>
965</dl>
966</blockquote>
967<p>
968<a name="fn-objequal"></a>
969<a class="mochidef reference" href="#fn-objequal">objEqual(a, b)</a>:</p>
970<blockquote>
971<p>Return <tt class="docutils literal"><span class="pre">true</span></tt> if <tt class="docutils literal"><span class="pre">compare(a,</span> <span class="pre">b)</span> <span class="pre">==</span> <span class="pre">0</span></tt></p>
972<dl class="docutils">
973<dt><em>Availability</em>:</dt>
974<dd>Available in MochiKit 1.3.1+</dd>
975</dl>
976</blockquote>
977<p>
978<a name="fn-nodewalk"></a>
979<a class="mochidef reference" href="#fn-nodewalk">nodeWalk(node, visitor)</a>:</p>
980<blockquote>
981<p>Non-recursive generic node walking function (e.g. for a DOM).</p>
982<p>The walk order for nodeWalk is breadth first, meaning that all
983siblings will be visited before any children.</p>
984<dl class="docutils">
985<dt><tt class="docutils literal"><span class="pre">node</span></tt>:</dt>
986<dd>The initial node to be searched.</dd>
987<dt><tt class="docutils literal"><span class="pre">visitor</span></tt>:</dt>
988<dd>The visitor function, will be called as <tt class="docutils literal"><span class="pre">visitor(node)</span></tt>, and
989should return an <tt class="docutils literal"><span class="pre">Array</span></tt>-like of nodes to be searched next
990(e.g. <tt class="docutils literal"><span class="pre">node.childNodes</span></tt>). Leaf nodes may return <tt class="docutils literal"><span class="pre">null</span></tt> or
991<tt class="docutils literal"><span class="pre">undefined</span></tt>.</dd>
992<dt><em>Availability</em>:</dt>
993<dd>Available in MochiKit 1.3.1+</dd>
994</dl>
995</blockquote>
996<p>
997<a name="fn-objmax"></a>
998<a class="mochidef reference" href="#fn-objmax">objMax(obj[, ...])</a>:</p>
999<blockquote>
1000<p>Return the maximum object according to <a class="mochiref reference" href="#fn-compare">compare</a> out of
1001the given arguments. This is similar to <a class="mochiref reference" href="#fn-listmax">listMax</a>,
1002except is uses the arguments instead of a given <tt class="docutils literal"><span class="pre">Array</span></tt>-like.</p>
1003<dl class="docutils">
1004<dt><em>Availability</em>:</dt>
1005<dd>Available in MochiKit 1.3.1+</dd>
1006</dl>
1007</blockquote>
1008<p>
1009<a name="fn-objmin"></a>
1010<a class="mochidef reference" href="#fn-objmin">objMin(obj[, ...])</a>:</p>
1011<blockquote>
1012<p>Return the minimum object according to <a class="mochiref reference" href="#fn-compare">compare</a> out of
1013the given arguments. This is similar to <a class="mochiref reference" href="#fn-listmin">listMin</a>,
1014except it uses the arguments instead of a given <tt class="docutils literal"><span class="pre">Array</span></tt>-like.</p>
1015<dl class="docutils">
1016<dt><em>Availability</em>:</dt>
1017<dd>Available in MochiKit 1.3.1+</dd>
1018</dl>
1019</blockquote>
1020<p>
1021<a name="fn-operator"></a>
1022<a class="mochidef reference" href="#fn-operator">operator</a>:</p>
1023<blockquote>
1024<p>A table of JavaScript's operators for usage with <a class="mochiref reference" href="#fn-map">map</a>,
1025<a class="mochiref reference" href="#fn-filter">filter</a>, etc.</p>
1026<p>Unary Logic Operators:</p>
1027<blockquote>
1028<table border="1" class="docutils">
1029<colgroup>
1030<col width="31%" />
1031<col width="40%" />
1032<col width="29%" />
1033</colgroup>
1034<thead valign="bottom">
1035<tr><th class="head">Operator</th>
1036<th class="head">Implementation</th>
1037<th class="head">Description</th>
1038</tr>
1039</thead>
1040<tbody valign="top">
1041<tr><td><tt class="docutils literal"><span class="pre">truth(a)</span></tt></td>
1042<td><tt class="docutils literal"><span class="pre">!!a</span></tt></td>
1043<td>Logical truth</td>
1044</tr>
1045<tr><td><tt class="docutils literal"><span class="pre">lognot(a)</span></tt></td>
1046<td><tt class="docutils literal"><span class="pre">!a</span></tt></td>
1047<td>Logical not</td>
1048</tr>
1049<tr><td><tt class="docutils literal"><span class="pre">identity(a)</span></tt></td>
1050<td><tt class="docutils literal"><span class="pre">a</span></tt></td>
1051<td>Logical identity</td>
1052</tr>
1053</tbody>
1054</table>
1055</blockquote>
1056<p>Unary Math Operators:</p>
1057<blockquote>
1058<table border="1" class="docutils">
1059<colgroup>
1060<col width="33%" />
1061<col width="43%" />
1062<col width="25%" />
1063</colgroup>
1064<thead valign="bottom">
1065<tr><th class="head">Operator</th>
1066<th class="head">Implementation</th>
1067<th class="head">Description</th>
1068</tr>
1069</thead>
1070<tbody valign="top">
1071<tr><td><tt class="docutils literal"><span class="pre">not(a)</span></tt></td>
1072<td><tt class="docutils literal"><span class="pre">~a</span></tt></td>
1073<td>Bitwise not</td>
1074</tr>
1075<tr><td><tt class="docutils literal"><span class="pre">neg(a)</span></tt></td>
1076<td><tt class="docutils literal"><span class="pre">-a</span></tt></td>
1077<td>Negation</td>
1078</tr>
1079</tbody>
1080</table>
1081</blockquote>
1082<p>Binary Operators:</p>
1083<blockquote>
1084<table border="1" class="docutils">
1085<colgroup>
1086<col width="28%" />
1087<col width="28%" />
1088<col width="45%" />
1089</colgroup>
1090<thead valign="bottom">
1091<tr><th class="head">Operator</th>
1092<th class="head">Implementation</th>
1093<th class="head">Description</th>
1094</tr>
1095</thead>
1096<tbody valign="top">
1097<tr><td><tt class="docutils literal"><span class="pre">add(a,</span> <span class="pre">b)</span></tt></td>
1098<td><tt class="docutils literal"><span class="pre">a</span> <span class="pre">+</span> <span class="pre">b</span></tt></td>
1099<td>Addition</td>
1100</tr>
1101<tr><td><tt class="docutils literal"><span class="pre">sub(a,</span> <span class="pre">b)</span></tt></td>
1102<td><tt class="docutils literal"><span class="pre">a</span> <span class="pre">-</span> <span class="pre">b</span></tt></td>
1103<td>Subtraction</td>
1104</tr>
1105<tr><td><tt class="docutils literal"><span class="pre">div(a,</span> <span class="pre">b)</span></tt></td>
1106<td><tt class="docutils literal"><span class="pre">a</span> <span class="pre">/</span> <span class="pre">b</span></tt></td>
1107<td>Division</td>
1108</tr>
1109<tr><td><tt class="docutils literal"><span class="pre">mod(a,</span> <span class="pre">b)</span></tt></td>
1110<td><tt class="docutils literal"><span class="pre">a</span> <span class="pre">%</span> <span class="pre">b</span></tt></td>
1111<td>Modulus</td>
1112</tr>
1113<tr><td><tt class="docutils literal"><span class="pre">mul(a,</span> <span class="pre">b)</span></tt></td>
1114<td><tt class="docutils literal"><span class="pre">a</span> <span class="pre">*</span> <span class="pre">b</span></tt></td>
1115<td>Multiplication</td>
1116</tr>
1117<tr><td><tt class="docutils literal"><span class="pre">and(a,</span> <span class="pre">b)</span></tt></td>
1118<td><tt class="docutils literal"><span class="pre">a</span> <span class="pre">&amp;</span> <span class="pre">b</span></tt></td>
1119<td>Bitwise and</td>
1120</tr>
1121<tr><td><tt class="docutils literal"><span class="pre">or(a,</span> <span class="pre">b)</span></tt></td>
1122<td><tt class="docutils literal"><span class="pre">a</span> <span class="pre">|</span> <span class="pre">b</span></tt></td>
1123<td>Bitwise or</td>
1124</tr>
1125<tr><td><tt class="docutils literal"><span class="pre">xor(a,</span> <span class="pre">b)</span></tt></td>
1126<td><tt class="docutils literal"><span class="pre">a</span> <span class="pre">^</span> <span class="pre">b</span></tt></td>
1127<td>Bitwise exclusive or</td>
1128</tr>
1129<tr><td><tt class="docutils literal"><span class="pre">lshift(a,</span> <span class="pre">b)</span></tt></td>
1130<td><tt class="docutils literal"><span class="pre">a</span> <span class="pre">&lt;&lt;</span> <span class="pre">b</span></tt></td>
1131<td>Bitwise left shift</td>
1132</tr>
1133<tr><td><tt class="docutils literal"><span class="pre">rshift(a,</span> <span class="pre">b)</span></tt></td>
1134<td><tt class="docutils literal"><span class="pre">a</span> <span class="pre">&gt;&gt;</span> <span class="pre">b</span></tt></td>
1135<td>Bitwise signed right shift</td>
1136</tr>
1137<tr><td><tt class="docutils literal"><span class="pre">zrshift(a,</span> <span class="pre">b)</span></tt></td>
1138<td><tt class="docutils literal"><span class="pre">a</span> <span class="pre">&gt;&gt;&gt;</span> <span class="pre">b</span></tt></td>
1139<td>Bitwise unsigned right shift</td>
1140</tr>
1141</tbody>
1142</table>
1143</blockquote>
1144<p>Built-in Comparators:</p>
1145<blockquote>
1146<table border="1" class="docutils">
1147<colgroup>
1148<col width="25%" />
1149<col width="31%" />
1150<col width="44%" />
1151</colgroup>
1152<thead valign="bottom">
1153<tr><th class="head">Operator</th>
1154<th class="head">Implementation</th>
1155<th class="head">Description</th>
1156</tr>
1157</thead>
1158<tbody valign="top">
1159<tr><td><tt class="docutils literal"><span class="pre">eq(a,</span> <span class="pre">b)</span></tt></td>
1160<td><tt class="docutils literal"><span class="pre">a</span> <span class="pre">==</span> <span class="pre">b</span></tt></td>
1161<td>Equals</td>
1162</tr>
1163<tr><td><tt class="docutils literal"><span class="pre">ne(a,</span> <span class="pre">b)</span></tt></td>
1164<td><tt class="docutils literal"><span class="pre">a</span> <span class="pre">!=</span> <span class="pre">b</span></tt></td>
1165<td>Not equals</td>
1166</tr>
1167<tr><td><tt class="docutils literal"><span class="pre">gt(a,</span> <span class="pre">b)</span></tt></td>
1168<td><tt class="docutils literal"><span class="pre">a</span> <span class="pre">&gt;</span> <span class="pre">b</span></tt></td>
1169<td>Greater than</td>
1170</tr>
1171<tr><td><tt class="docutils literal"><span class="pre">ge(a,</span> <span class="pre">b)</span></tt></td>
1172<td><tt class="docutils literal"><span class="pre">a</span> <span class="pre">&gt;=</span> <span class="pre">b</span></tt></td>
1173<td>Greater than or equal to</td>
1174</tr>
1175<tr><td><tt class="docutils literal"><span class="pre">lt(a,</span> <span class="pre">b)</span></tt></td>
1176<td><tt class="docutils literal"><span class="pre">a</span> <span class="pre">&lt;</span> <span class="pre">b</span></tt></td>
1177<td>Less than</td>
1178</tr>
1179<tr><td><tt class="docutils literal"><span class="pre">le(a,</span> <span class="pre">b)</span></tt></td>
1180<td><tt class="docutils literal"><span class="pre">a</span> <span class="pre">&lt;=</span> <span class="pre">b</span></tt></td>
1181<td>Less than or equal to</td>
1182</tr>
1183</tbody>
1184</table>
1185</blockquote>
1186<p>Strict Built-in Comparators:</p>
1187<blockquote>
1188<table border="1" class="docutils">
1189<colgroup>
1190<col width="25%" />
1191<col width="31%" />
1192<col width="44%" />
1193</colgroup>
1194<thead valign="bottom">
1195<tr><th class="head">Operator</th>
1196<th class="head">Implementation</th>
1197<th class="head">Description</th>
1198</tr>
1199</thead>
1200<tbody valign="top">
1201<tr><td><tt class="docutils literal"><span class="pre">seq(a,</span> <span class="pre">b)</span></tt></td>
1202<td><tt class="docutils literal"><span class="pre">a</span> <span class="pre">===</span> <span class="pre">b</span></tt></td>
1203<td>Strict equals</td>
1204</tr>
1205<tr><td><tt class="docutils literal"><span class="pre">sne(a,</span> <span class="pre">b)</span></tt></td>
1206<td><tt class="docutils literal"><span class="pre">a</span> <span class="pre">!==</span> <span class="pre">b</span></tt></td>
1207<td>Strict not equals</td>
1208</tr>
1209</tbody>
1210</table>
1211</blockquote>
1212<p>Extended Comparators (uses <a class="mochiref reference" href="#fn-compare">compare</a>):</p>
1213<blockquote>
1214<table border="1" class="docutils">
1215<colgroup>
1216<col width="22%" />
1217<col width="39%" />
1218<col width="39%" />
1219</colgroup>
1220<thead valign="bottom">
1221<tr><th class="head">Operator</th>
1222<th class="head">Implementation</th>
1223<th class="head">Description</th>
1224</tr>
1225</thead>
1226<tbody valign="top">
1227<tr><td><tt class="docutils literal"><span class="pre">ceq(a,</span> <span class="pre">b)</span></tt></td>
1228<td><tt class="docutils literal"><span class="pre">compare(a,</span> <span class="pre">b)</span> <span class="pre">==</span> <span class="pre">0</span></tt></td>
1229<td>Equals</td>
1230</tr>
1231<tr><td><tt class="docutils literal"><span class="pre">cne(a,</span> <span class="pre">b)</span></tt></td>
1232<td><tt class="docutils literal"><span class="pre">compare(a,</span> <span class="pre">b)</span> <span class="pre">!=</span> <span class="pre">0</span></tt></td>
1233<td>Not equals</td>
1234</tr>
1235<tr><td><tt class="docutils literal"><span class="pre">cgt(a,</span> <span class="pre">b)</span></tt></td>
1236<td><tt class="docutils literal"><span class="pre">compare(a,</span> <span class="pre">b)</span> <span class="pre">==</span> <span class="pre">1</span></tt></td>
1237<td>Greater than</td>
1238</tr>
1239<tr><td><tt class="docutils literal"><span class="pre">cge(a,</span> <span class="pre">b)</span></tt></td>
1240<td><tt class="docutils literal"><span class="pre">compare(a,</span> <span class="pre">b)</span> <span class="pre">!=</span> <span class="pre">-1</span></tt></td>
1241<td>Greater than or equal to</td>
1242</tr>
1243<tr><td><tt class="docutils literal"><span class="pre">clt(a,</span> <span class="pre">b)</span></tt></td>
1244<td><tt class="docutils literal"><span class="pre">compare(a,</span> <span class="pre">b)</span> <span class="pre">==</span> <span class="pre">-1</span></tt></td>
1245<td>Less than</td>
1246</tr>
1247<tr><td><tt class="docutils literal"><span class="pre">cle(a,</span> <span class="pre">b)</span></tt></td>
1248<td><tt class="docutils literal"><span class="pre">compare(a,</span> <span class="pre">b)</span> <span class="pre">!=</span> <span class="pre">1</span></tt></td>
1249<td>Less than or equal to</td>
1250</tr>
1251</tbody>
1252</table>
1253</blockquote>
1254<p>Binary Logical Operators:</p>
1255<blockquote>
1256<table border="1" class="docutils">
1257<colgroup>
1258<col width="33%" />
1259<col width="28%" />
1260<col width="39%" />
1261</colgroup>
1262<thead valign="bottom">
1263<tr><th class="head">Operator</th>
1264<th class="head">Implementation</th>
1265<th class="head">Description</th>
1266</tr>
1267</thead>
1268<tbody valign="top">
1269<tr><td><tt class="docutils literal"><span class="pre">logand(a,</span> <span class="pre">b)</span></tt></td>
1270<td><tt class="docutils literal"><span class="pre">a</span> <span class="pre">&amp;&amp;</span> <span class="pre">b</span></tt></td>
1271<td>Logical and</td>
1272</tr>
1273<tr><td><tt class="docutils literal"><span class="pre">logor(a,</span> <span class="pre">b)</span></tt></td>
1274<td><tt class="docutils literal"><span class="pre">a</span> <span class="pre">||</span> <span class="pre">b</span></tt></td>
1275<td>Logical or</td>
1276</tr>
1277<tr><td><tt class="docutils literal"><span class="pre">contains(a,</span> <span class="pre">b)</span></tt></td>
1278<td><tt class="docutils literal"><span class="pre">b</span> <span class="pre">in</span> <span class="pre">a</span></tt></td>
1279<td>Has property (note order)</td>
1280</tr>
1281</tbody>
1282</table>
1283</blockquote>
1284<dl class="docutils">
1285<dt><em>Availability</em>:</dt>
1286<dd>Available in MochiKit 1.3.1+</dd>
1287</dl>
1288</blockquote>
1289<p>
1290<a name="fn-parsequerystring"></a>
1291<a class="mochidef reference" href="#fn-parsequerystring">parseQueryString(encodedString[, useArrays=false])</a>:</p>
1292<blockquote>
1293<p>Parse a name=value pair URL query string into an object with a
1294property for each pair. e.g.:</p>
1295<pre class="literal-block">
1296var args = parseQueryString(&quot;foo=value%20one&amp;bar=two&quot;);
1297assert( args.foo == &quot;value one&quot; &amp;&amp; args.bar == &quot;two&quot; );
1298</pre>
1299<p>If you expect that the query string will reuse the same name, then
1300give <tt class="docutils literal"><span class="pre">true</span></tt> as a second argument, which will use arrays to store
1301the values. e.g.:</p>
1302<pre class="literal-block">
1303var args = parseQueryString(&quot;foo=one&amp;foo=two&quot;, true);
1304assert( args.foo[0] == &quot;one&quot; &amp;&amp; args.foo[1] == &quot;two&quot; );
1305</pre>
1306<dl class="docutils">
1307<dt><em>Availability</em>:</dt>
1308<dd>Available in MochiKit 1.3.1+</dd>
1309</dl>
1310</blockquote>
1311<p>
1312<a name="fn-partial"></a>
1313<a class="mochidef reference" href="#fn-partial">partial(func, arg[, ...])</a>:</p>
1314<blockquote>
1315<p>Return a partially applied function, e.g.:</p>
1316<pre class="literal-block">
1317addNumbers = function (a, b) {
1318 return a + b;
1319}
1320
1321addOne = partial(addNumbers, 1);
1322
1323assert(addOne(2) == 3);
1324</pre>
1325<p><a class="mochiref reference" href="#fn-partial">partial</a> is a special form of <a class="mochiref reference" href="#fn-bind">bind</a> that
1326does not alter the bound <tt class="docutils literal"><span class="pre">self</span></tt> (if any). It is equivalent to
1327calling:</p>
1328<pre class="literal-block">
1329bind(func, undefined, arg[, ...]);
1330</pre>
1331<p>See the documentation for <a class="mochiref reference" href="#fn-bind">bind</a> for more details about
1332this facility.</p>
1333<p>This could be used to implement, but is NOT currying.</p>
1334<dl class="docutils">
1335<dt><em>Availability</em>:</dt>
1336<dd>Available in MochiKit 1.3.1+</dd>
1337</dl>
1338</blockquote>
1339<p>
1340<a name="fn-querystring"></a>
1341<a class="mochidef reference" href="#fn-querystring">queryString(names, values)</a>:</p>
1342<blockquote>
1343<p>Creates a URL query string from a pair of <tt class="docutils literal"><span class="pre">Array</span></tt>-like objects
1344representing <tt class="docutils literal"><span class="pre">names</span></tt> and <tt class="docutils literal"><span class="pre">values</span></tt>. Each name=value pair will
1345be URL encoded by <a class="mochiref reference" href="#fn-urlencode">urlEncode</a>. name=value pairs with a
1346value of <tt class="docutils literal"><span class="pre">undefined</span></tt> or <tt class="docutils literal"><span class="pre">null</span></tt> will be skipped. e.g.:</p>
1347<pre class="literal-block">
1348var keys = [&quot;foo&quot;, &quot;bar&quot;];
1349var values = [&quot;value one&quot;, &quot;two&quot;];
1350assert( queryString(keys, values) == &quot;foo=value%20one&amp;bar=two&quot; );
1351</pre>
1352<dl class="docutils">
1353<dt>Alternate form 1:</dt>
1354<dd><a class="mochiref reference" href="#fn-querystring">queryString(domElement)</a></dd>
1355</dl>
1356<p>If <a class="mochiref reference" href="DOM.html">MochiKit.DOM</a> is loaded, one argument is given, and
1357that argument is either a string or has a <tt class="docutils literal"><span class="pre">nodeType</span></tt> property
1358greater than zero, then <tt class="docutils literal"><span class="pre">names</span></tt> and <tt class="docutils literal"><span class="pre">values</span></tt> will be the
1359result of <a class="mochiref reference" href="DOM.html#fn-formcontents">MochiKit.DOM.formContents(domElement)</a>.</p>
1360<dl class="docutils">
1361<dt>Alternate form 2:</dt>
1362<dd><a class="mochiref reference" href="#fn-querystring">queryString({name: value, ...})</a></dd>
1363</dl>
1364<p>Note that when using the alternate form, the order of the
1365name=value pairs in the resultant query string is dependent on how
1366the particular JavaScript implementation handles <tt class="docutils literal"><span class="pre">for</span> <span class="pre">(..in..)</span></tt>
1367property enumeration.</p>
1368<p>When using the second alternate form, name=value pairs with
1369<tt class="docutils literal"><span class="pre">typeof(value)</span> <span class="pre">==</span> <span class="pre">&quot;function&quot;</span></tt> are ignored. This is a workaround
1370for the case where a poorly designed library has modified
1371<tt class="docutils literal"><span class="pre">Object.prototype</span></tt> and inserted &quot;convenience functions&quot;.</p>
1372<p>Values that are Array-like will be expanded as if they were multiply
1373defined HTML elements. For example:</p>
1374<pre class="literal-block">
1375assert( queryString({a: [1,2]}) === &quot;a=1&amp;a=2&quot; );
1376</pre>
1377<dl class="docutils">
1378<dt>Alternate form 2 (MochiKit 1.4+):</dt>
1379<dd><a class="mochiref reference" href="#fn-querystring">queryString([names, values])</a></dd>
1380</dl>
1381<p>This form behaves identically to <a class="mochiref reference" href="#fn-querystring">queryString(names, values)</a>,
1382except it takes both arguments as a single Array. This mirrors the
1383return value of <a class="mochiref reference" href="DOM.html#fn-formcontents">MochiKit.DOM.formContents</a>.</p>
1384<dl class="docutils">
1385<dt><em>Availability</em>:</dt>
1386<dd>Available in MochiKit 1.3.1+</dd>
1387</dl>
1388</blockquote>
1389<p>
1390<a name="fn-registercomparator"></a>
1391<a class="mochidef reference" href="#fn-registercomparator">registerComparator(name, check, comparator[, override])</a>:</p>
1392<blockquote>
1393<p>Register a comparator for use with <a class="mochiref reference" href="#fn-compare">compare</a>.</p>
1394<dl class="docutils">
1395<dt><tt class="docutils literal"><span class="pre">name</span></tt>:</dt>
1396<dd>unique identifier describing the comparator.</dd>
1397<dt><tt class="docutils literal"><span class="pre">check</span></tt>:</dt>
1398<dd><tt class="docutils literal"><span class="pre">function(a,</span> <span class="pre">b)</span></tt> that returns <tt class="docutils literal"><span class="pre">true</span></tt> if <tt class="docutils literal"><span class="pre">a</span></tt> and <tt class="docutils literal"><span class="pre">b</span></tt>
1399can be compared with <tt class="docutils literal"><span class="pre">comparator</span></tt>.</dd>
1400<dt><tt class="docutils literal"><span class="pre">comparator</span></tt>:</dt>
1401<dd><p class="first"><tt class="docutils literal"><span class="pre">function(a,</span> <span class="pre">b)</span></tt> that returns:</p>
1402<table border="1" class="docutils">
1403<colgroup>
1404<col width="39%" />
1405<col width="61%" />
1406</colgroup>
1407<tbody valign="top">
1408<tr><td>Value</td>
1409<td>Condition</td>
1410</tr>
1411<tr><td>0</td>
1412<td>a == b</td>
1413</tr>
1414<tr><td>1</td>
1415<td>a &gt; b</td>
1416</tr>
1417<tr><td>-1</td>
1418<td>a &lt; b</td>
1419</tr>
1420</tbody>
1421</table>
1422<p class="last"><tt class="docutils literal"><span class="pre">comparator</span></tt> is guaranteed to only be called if <tt class="docutils literal"><span class="pre">check(a,</span>
1423<span class="pre">b)</span></tt> returns a <tt class="docutils literal"><span class="pre">true</span></tt> value.</p>
1424</dd>
1425<dt><tt class="docutils literal"><span class="pre">override</span></tt>:</dt>
1426<dd>if <tt class="docutils literal"><span class="pre">true</span></tt>, then this will be made the highest precedence
1427comparator. Otherwise, the lowest.</dd>
1428<dt><em>Availability</em>:</dt>
1429<dd>Available in MochiKit 1.3.1+</dd>
1430</dl>
1431</blockquote>
1432<p>
1433<a name="fn-registerjson"></a>
1434<a class="mochidef reference" href="#fn-registerjson">registerJSON(name, check, simplifier[, override])</a>:</p>
1435<blockquote>
1436<p>Register a simplifier function for use with
1437<a class="mochiref reference" href="#fn-serializejson">serializeJSON</a>.</p>
1438<dl class="docutils">
1439<dt><tt class="docutils literal"><span class="pre">name</span></tt>:</dt>
1440<dd>unique identifier describing the serialization.</dd>
1441<dt><tt class="docutils literal"><span class="pre">check</span></tt>:</dt>
1442<dd><tt class="docutils literal"><span class="pre">function(obj)</span></tt> that returns <tt class="docutils literal"><span class="pre">true</span></tt> if <tt class="docutils literal"><span class="pre">obj</span></tt> can
1443can be simplified for serialization by <tt class="docutils literal"><span class="pre">simplifier</span></tt>.</dd>
1444<dt><tt class="docutils literal"><span class="pre">simplifier</span></tt>:</dt>
1445<dd><p class="first"><tt class="docutils literal"><span class="pre">function(obj)</span></tt> that returns a simpler object that can be
1446further serialized by <a class="mochiref reference" href="#fn-serializejson">serializeJSON</a>. For example,
1447you could simplify <tt class="docutils literal"><span class="pre">Date</span></tt>-like objects to ISO 8601 timestamp
1448strings with the following simplifier:</p>
1449<pre class="literal-block">
1450var simplifyDateAsISO = function (obj) {
1451 return toISOTimestamp(obj, true);
1452};
1453registerJSON(&quot;DateLike&quot;, isDateLike, simplifyDateAsISO);
1454</pre>
1455<p class="last"><tt class="docutils literal"><span class="pre">simplifier</span></tt> is guaranteed to only be called if
1456<tt class="docutils literal"><span class="pre">check(obj)</span></tt> returns a <tt class="docutils literal"><span class="pre">true</span></tt> value.</p>
1457</dd>
1458<dt><tt class="docutils literal"><span class="pre">override</span></tt>:</dt>
1459<dd>if <tt class="docutils literal"><span class="pre">true</span></tt>, then this will be made the highest precedence
1460serialization. Otherwise, the lowest.</dd>
1461<dt><em>Availability</em>:</dt>
1462<dd>Available in MochiKit 1.3.1+</dd>
1463</dl>
1464</blockquote>
1465<p>
1466<a name="fn-registerrepr"></a>
1467<a class="mochidef reference" href="#fn-registerrepr">registerRepr(name, check, wrap[, override])</a>:</p>
1468<blockquote>
1469<p>Register a programmer representation function. <a class="mochiref reference" href="#fn-repr">repr</a>
1470functions should take one argument and return a string
1471representation of it suitable for developers, primarily used when
1472debugging.</p>
1473<p>If <tt class="docutils literal"><span class="pre">override</span></tt> is given, it is used as the highest priority repr,
1474otherwise it will be used as the lowest.</p>
1475<dl class="docutils">
1476<dt><em>Availability</em>:</dt>
1477<dd>Available in MochiKit 1.3.1+</dd>
1478</dl>
1479</blockquote>
1480<p>
1481<a name="fn-repr"></a>
1482<a class="mochidef reference" href="#fn-repr">repr(obj)</a>:</p>
1483<blockquote>
1484<p>Return a programmer representation for <tt class="docutils literal"><span class="pre">obj</span></tt>. See the
1485<a class="reference" href="#programmer-representation">Programmer Representation</a> overview for more information about
1486this function.</p>
1487<dl class="docutils">
1488<dt><em>Availability</em>:</dt>
1489<dd>Available in MochiKit 1.3.1+</dd>
1490</dl>
1491</blockquote>
1492<p>
1493<a name="fn-reversekeycomparator"></a>
1494<a class="mochidef reference" href="#fn-reversekeycomparator">reverseKeyComparator(key)</a>:</p>
1495<blockquote>
1496<p>A comparator factory that compares <tt class="docutils literal"><span class="pre">a[key]</span></tt> with <tt class="docutils literal"><span class="pre">b[key]</span></tt> in
1497reverse. e.g.:</p>
1498<pre class="literal-block">
1499var lst = [&quot;a&quot;, &quot;bbb&quot;, &quot;cc&quot;];
1500lst.sort(reverseKeyComparator(&quot;length&quot;));
1501assert(lst.toString() == &quot;bbb,cc,a&quot;);
1502</pre>
1503<dl class="docutils">
1504<dt><em>Availability</em>:</dt>
1505<dd>Available in MochiKit 1.3.1+</dd>
1506</dl>
1507</blockquote>
1508<p>
1509<a name="fn-serializejson"></a>
1510<a class="mochidef reference" href="#fn-serializejson">serializeJSON(anObject)</a>:</p>
1511<blockquote>
1512<p>Serialize <tt class="docutils literal"><span class="pre">anObject</span></tt> in the JSON <a class="footnote-reference" href="#id7" id="id6" name="id6">[1]</a> format, see <a class="reference" href="#json-serialization">JSON
1513Serialization</a> for the coercion rules. For unserializable objects
1514(functions that do not have an adapter, <tt class="docutils literal"><span class="pre">__json__</span></tt> method, or
1515<tt class="docutils literal"><span class="pre">json</span></tt> method), this will return <tt class="docutils literal"><span class="pre">undefined</span></tt>.</p>
1516<p>For those familiar with Python, JSON is similar in scope to
1517pickle, but it can not handle recursive object graphs.</p>
1518<dl class="docutils">
1519<dt><em>Availability</em>:</dt>
1520<dd>Available in MochiKit 1.3.1+</dd>
1521</dl>
1522</blockquote>
1523<p>
1524<a name="fn-setdefault"></a>
1525<a class="mochidef reference" href="#fn-setdefault">setdefault(self, obj[, ...])</a>:</p>
1526<blockquote>
1527<p>Mutate <tt class="docutils literal"><span class="pre">self</span></tt> by adding all properties from other object(s) that
1528it does not already have set.</p>
1529<p>If <tt class="docutils literal"><span class="pre">self</span></tt> is <tt class="docutils literal"><span class="pre">null</span></tt>, a new <tt class="docutils literal"><span class="pre">Object</span></tt> instance will be created
1530and returned.</p>
1531<p>This mutates <em>and returns</em> <tt class="docutils literal"><span class="pre">self</span></tt>, be warned.</p>
1532<dl class="docutils">
1533<dt><em>Availability</em>:</dt>
1534<dd>Available in MochiKit 1.3.1+</dd>
1535</dl>
1536</blockquote>
1537<p>
1538<a name="fn-typematcher"></a>
1539<a class="mochidef reference" href="#fn-typematcher">typeMatcher(typ[, ...])</a>:</p>
1540<blockquote>
1541<p>Given a set of types (as string arguments), returns a
1542<tt class="docutils literal"><span class="pre">function(obj[,</span> <span class="pre">...])</span></tt> that will return <tt class="docutils literal"><span class="pre">true</span></tt> if the types of
1543the given arguments are all members of that set.</p>
1544<dl class="docutils">
1545<dt><em>Availability</em>:</dt>
1546<dd>Available in MochiKit 1.3.1+</dd>
1547</dl>
1548</blockquote>
1549<p>
1550<a name="fn-update"></a>
1551<a class="mochidef reference" href="#fn-update">update(self, obj[, ...])</a>:</p>
1552<blockquote>
1553<p>Mutate <tt class="docutils literal"><span class="pre">self</span></tt> by replacing its key:value pairs with those from
1554other object(s). Key:value pairs from later objects will overwrite
1555those from earlier objects.</p>
1556<p>If <tt class="docutils literal"><span class="pre">self</span></tt> is <tt class="docutils literal"><span class="pre">null</span></tt>, a new <tt class="docutils literal"><span class="pre">Object</span></tt> instance will be created
1557and returned.</p>
1558<p>This mutates <em>and returns</em> <tt class="docutils literal"><span class="pre">self</span></tt>, be warned.</p>
1559<p>A version of this function that creates a new object is available
1560as <a class="mochiref reference" href="#fn-merge">merge(a, b[, ...])</a></p>
1561<dl class="docutils">
1562<dt><em>Availability</em>:</dt>
1563<dd>Available in MochiKit 1.3.1+</dd>
1564</dl>
1565</blockquote>
1566<p>
1567<a name="fn-updatetree"></a>
1568<a class="mochidef reference" href="#fn-updatetree">updatetree(self, obj[, ...])</a>:</p>
1569<blockquote>
1570<p>Mutate <tt class="docutils literal"><span class="pre">self</span></tt> by replacing its key:value pairs with those from
1571other object(s). If a given key has an object value in both
1572<tt class="docutils literal"><span class="pre">self</span></tt> and <tt class="docutils literal"><span class="pre">obj</span></tt>, then this function will be called
1573recursively, updating instead of replacing that object.</p>
1574<p>If <tt class="docutils literal"><span class="pre">self</span></tt> is <tt class="docutils literal"><span class="pre">null</span></tt>, a new <tt class="docutils literal"><span class="pre">Object</span></tt> instance will be created
1575and returned.</p>
1576<p>This mutates <em>and returns</em> <tt class="docutils literal"><span class="pre">self</span></tt>, be warned.</p>
1577<dl class="docutils">
1578<dt><em>Availability</em>:</dt>
1579<dd>Available in MochiKit 1.3.1+</dd>
1580</dl>
1581</blockquote>
1582<p>
1583<a name="fn-urlencode"></a>
1584<a class="mochidef reference" href="#fn-urlencode">urlEncode(unencoded)</a>:</p>
1585<blockquote>
1586<p>Converts <tt class="docutils literal"><span class="pre">unencoded</span></tt> into a URL-encoded string. In this
1587implementation, spaces are converted to %20 instead of &quot;+&quot;. e.g.:</p>
1588<pre class="literal-block">
1589assert( URLencode(&quot;1+2=2&quot;) == &quot;1%2B2%3D2&quot;);
1590</pre>
1591<dl class="docutils">
1592<dt><em>Availability</em>:</dt>
1593<dd>Available in MochiKit 1.3.1+</dd>
1594</dl>
1595</blockquote>
1596<p>
1597<a name="fn-values"></a>
1598<a class="mochidef reference" href="#fn-values">values(obj)</a>:</p>
1599<blockquote>
1600<p>Return an <tt class="docutils literal"><span class="pre">Array</span></tt> of the property values of an object (in the
1601order determined by <tt class="docutils literal"><span class="pre">for</span> <span class="pre">propName</span> <span class="pre">in</span> <span class="pre">obj</span></tt>).</p>
1602<dl class="docutils">
1603<dt><em>Availability</em>:</dt>
1604<dd>Available in MochiKit 1.4+</dd>
1605</dl>
1606</blockquote>
1607<p>
1608<a name="fn-xfilter"></a>
1609<a class="mochidef reference" href="#fn-xfilter">xfilter(fn, obj[, ...])</a>:</p>
1610<blockquote>
1611<p>Returns a new <tt class="docutils literal"><span class="pre">Array</span></tt> composed of the arguments where
1612<tt class="docutils literal"><span class="pre">fn(obj)</span></tt> returns a true value.</p>
1613<p>If <tt class="docutils literal"><span class="pre">fn</span></tt> is <tt class="docutils literal"><span class="pre">null</span></tt>, <tt class="docutils literal"><span class="pre">operator.truth</span></tt> will be used.</p>
1614<dl class="docutils">
1615<dt><em>Availability</em>:</dt>
1616<dd>Available in MochiKit 1.3.1+</dd>
1617</dl>
1618</blockquote>
1619<p>
1620<a name="fn-xmap"></a>
1621<a class="mochidef reference" href="#fn-xmap">xmap(fn, obj[, ...)</a>:</p>
1622<blockquote>
1623<p>Return a new <tt class="docutils literal"><span class="pre">Array</span></tt> composed of <tt class="docutils literal"><span class="pre">fn(obj)</span></tt> for every <tt class="docutils literal"><span class="pre">obj</span></tt>
1624given as an argument.</p>
1625<p>If <tt class="docutils literal"><span class="pre">fn</span></tt> is <tt class="docutils literal"><span class="pre">null</span></tt>, <tt class="docutils literal"><span class="pre">operator.identity</span></tt> is used.</p>
1626<dl class="docutils">
1627<dt><em>Availability</em>:</dt>
1628<dd>Available in MochiKit 1.3.1+</dd>
1629</dl>
1630</blockquote>
1631</div>
1632</div>
1633<div class="section">
1634<h1><a id="see-also" name="see-also">See Also</a></h1>
1635<table class="docutils footnote" frame="void" id="id7" rules="none">
1636<colgroup><col class="label" /><col /></colgroup>
1637<tbody valign="top">
1638<tr><td class="label"><a name="id7">[1]</a></td><td><em>(<a class="fn-backref" href="#id1">1</a>, <a class="fn-backref" href="#id2">2</a>, <a class="fn-backref" href="#id4">3</a>, <a class="fn-backref" href="#id5">4</a>, <a class="fn-backref" href="#id6">5</a>)</em> JSON, JavaScript Object Notation: <a class="reference" href="http://json.org/">http://json.org/</a></td></tr>
1639</tbody>
1640</table>
1641<table class="docutils footnote" frame="void" id="id8" rules="none">
1642<colgroup><col class="label" /><col /></colgroup>
1643<tbody valign="top">
1644<tr><td class="label"><a class="fn-backref" href="#id3" name="id8">[2]</a></td><td>Python's itertools
1645module: <a class="reference" href="http://docs.python.org/lib/module-itertools.html">http://docs.python.org/lib/module-itertools.html</a></td></tr>
1646</tbody>
1647</table>
1648</div>
1649<div class="section">
1650<h1><a id="authors" name="authors">Authors</a></h1>
1651<ul class="simple">
1652<li>Bob Ippolito &lt;<a class="reference" href="mailto:bob&#64;redivi.com">bob&#64;redivi.com</a>&gt;</li>
1653</ul>
1654</div>
1655<div class="section">
1656<h1><a id="copyright" name="copyright">Copyright</a></h1>
1657<p>Copyright 2005 Bob Ippolito &lt;<a class="reference" href="mailto:bob&#64;redivi.com">bob&#64;redivi.com</a>&gt;. This program is
1658dual-licensed free software; you can redistribute it and/or modify it
1659under the terms of the <a class="reference" href="http://www.opensource.org/licenses/mit-license.php">MIT License</a> or the <a class="reference" href="http://www.opensource.org/licenses/afl-2.1.php">Academic Free License
1660v2.1</a>.</p>
1661</div>
1662</div>
1663
1664</body>
1665</html>
danvk/dygraphs fork supporting touch events