docs/sphinx_docs/_build/html/notebooks/Intro.html

   1
   2 <!DOCTYPE html>
   3
   4 <html>
   5   <head>
   6     <meta charset="utf-8" />
   7     <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
   8
   9     <title>Thun: Joy in Python &#8212; Thun 0.4.1 documentation</title>
  10     <link rel="stylesheet" type="text/css" href="../_static/pygments.css" />
  11     <link rel="stylesheet" type="text/css" href="../_static/alabaster.css" />
  12     <script data-url_root="../" id="documentation_options" src="../_static/documentation_options.js"></script>
  13     <script src="../_static/jquery.js"></script>
  14     <script src="../_static/underscore.js"></script>
  15     <script src="../_static/doctools.js"></script>
  16     <link rel="index" title="Index" href="../genindex.html" />
  17     <link rel="search" title="Search" href="../search.html" />
  18     <link rel="next" title="Joy Interpreter" href="../joy.html" />
  19     <link rel="prev" title="Thun 0.4.1 Documentation" href="../index.html" />
  20
  21   <link rel="stylesheet" href="../_static/custom.css" type="text/css" />
  22
  23
  24   <meta name="viewport" content="width=device-width, initial-scale=0.9, maximum-scale=0.9" />
  25
  26   </head><body>
  27
  28
  29     <div class="document">
  30       <div class="documentwrapper">
  31         <div class="bodywrapper">
  32
  33
  34           <div class="body" role="main">
  35
  36   <section id="thun-joy-in-python">
  37 <h1>Thun: Joy in Python<a class="headerlink" href="#thun-joy-in-python" title="Permalink to this headline">¶</a></h1>
  38 <p>This implementation is meant as a tool for exploring the programming
  39 model and method of Joy. Python seems like a great implementation
  40 language for Joy for several reasons.</p>
  41 <ul class="simple">
  42 <li><p>We can lean on the Python immutable types for our basic semantics and types: ints, floats, strings, and tuples, which enforces functional purity.</p></li>
  43 <li><p>We get garbage collection for free.</p></li>
  44 <li><p>Compilation via Cython.</p></li>
  45 <li><p>Python is a “glue language” with loads of libraries which we can wrap in Joy functions.</p></li>
  46 </ul>
  47 <section id="read-eval-print-loop-repl">
  48 <h2><a class="reference external" href="https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop">Read-Eval-Print Loop (REPL)</a><a class="headerlink" href="#read-eval-print-loop-repl" title="Permalink to this headline">¶</a></h2>
  49 <p>The main way to interact with the Joy interpreter is through a simple
  50 <a class="reference external" href="https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop">REPL</a>
  51 that you start by running the package:</p>
  52 <div class="highlight-default notranslate"><div class="highlight"><pre><span></span>$ python3 -m joy
  53 Thun - Copyright © 2017 Simon Forman
  54 This program comes with ABSOLUTELY NO WARRANTY; for details type &quot;warranty&quot;.
  55 This is free software, and you are welcome to redistribute it
  56 under certain conditions; type &quot;sharing&quot; for details.
  57 Type &quot;words&quot; to see a list of all words, and &quot;[&lt;name&gt;] help&quot; to print the
  58 docs for a word.
  59
  60
  61 &lt;-top
  62
  63 joy? _
  64 </pre></div>
  65 </div>
  66 <p>The <code class="docutils literal notranslate"><span class="pre">&lt;-top</span></code> marker points to the top of the (initially empty) stack.
  67 You can enter Joy notation at the prompt and a <a class="reference internal" href="../pretty.html"><span class="doc">trace of evaluation</span></a> will
  68 be printed followed by the stack and prompt again:</p>
  69 <div class="highlight-default notranslate"><div class="highlight"><pre><span></span>joy? 23 sqr 18 +
  70
  71 547 &lt;-top
  72
  73 joy?
  74 </pre></div>
  75 </div>
  76 <p>There is a <cite>trace</cite> combinator:</p>
  77 <div class="highlight-default notranslate"><div class="highlight"><pre><span></span>joy? 23 [sqr 18 +] trace
  78     23 . sqr 18 +
  79     23 . dup mul 18 +
  80  23 23 . mul 18 +
  81    529 . 18 +
  82 529 18 . +
  83    547 .
  84
  85 547 &lt;-top
  86
  87 joy?
  88 </pre></div>
  89 </div>
  90 </section>
  91 <section id="the-stack">
  92 <h2>The Stack<a class="headerlink" href="#the-stack" title="Permalink to this headline">¶</a></h2>
  93 <p>In Joy, in addition to the types Boolean, integer, float, and string,
  94 there is a <a class="reference internal" href="../stack.html"><span class="doc">single sequence type</span></a> represented by enclosing a sequence of
  95 terms in brackets <code class="docutils literal notranslate"><span class="pre">[...]</span></code>. This sequence type is used to represent
  96 both the stack and the expression. It is a <a class="reference external" href="https://en.wikipedia.org/wiki/Cons#Lists">cons
  97 list</a> made from Python
  98 tuples.</p>
  99 </section>
 100 <section id="purely-functional-datastructures">
 101 <h2>Purely Functional Datastructures<a class="headerlink" href="#purely-functional-datastructures" title="Permalink to this headline">¶</a></h2>
 102 <p>Because Joy stacks are made out of Python tuples they are immutable, as are the other Python types we “borrow” for Joy, so all Joy datastructures are <a class="reference external" href="https://en.wikipedia.org/wiki/Purely_functional_data_structure">purely functional</a>.</p>
 103 </section>
 104 <section id="the-joy-function">
 105 <h2>The <code class="docutils literal notranslate"><span class="pre">joy()</span></code> function<a class="headerlink" href="#the-joy-function" title="Permalink to this headline">¶</a></h2>
 106 <section id="an-interpreter">
 107 <h3>An Interpreter<a class="headerlink" href="#an-interpreter" title="Permalink to this headline">¶</a></h3>
 108 <p>The <code class="docutils literal notranslate"><span class="pre">joy()</span></code> interpreter function is extrememly simple. It accepts a stack, an
 109 expression, and a dictionary, and it iterates through the expression
 110 putting values onto the stack and delegating execution to functions which it
 111 looks up in the dictionary.</p>
 112 </section>
 113 <section id="continuation-passing-style">
 114 <h3><a class="reference external" href="https://en.wikipedia.org/wiki/Continuation-passing_style">Continuation-Passing Style</a><a class="headerlink" href="#continuation-passing-style" title="Permalink to this headline">¶</a></h3>
 115 <p>One day I thought, What happens if you rewrite Joy to use
 116 <a class="reference external" href="https://en.wikipedia.org/wiki/Continuation-passing_style">CPS</a>? I
 117 made all the functions accept and return the expression as well as the
 118 stack and found that all the combinators could be rewritten to work by
 119 modifying the expression rather than making recursive calls to the
 120 <code class="docutils literal notranslate"><span class="pre">joy()</span></code> function.</p>
 121 </section>
 122 <section id="view-function">
 123 <h3>View function<a class="headerlink" href="#view-function" title="Permalink to this headline">¶</a></h3>
 124 <p>The <code class="docutils literal notranslate"><span class="pre">joy()</span></code> function accepts an optional <code class="docutils literal notranslate"><span class="pre">viewer</span></code> argument that
 125 is a function which it calls on
 126 each iteration passing the current stack and expression just before
 127 evaluation. This can be used for tracing, breakpoints, retrying after
 128 exceptions, or interrupting an evaluation and saving to disk or sending
 129 over the network to resume later. The stack and expression together
 130 contain all the state of the computation at each step.</p>
 131 </section>
 132 <section id="the-traceprinter">
 133 <h3>The <code class="docutils literal notranslate"><span class="pre">TracePrinter</span></code>.<a class="headerlink" href="#the-traceprinter" title="Permalink to this headline">¶</a></h3>
 134 <p>A <code class="docutils literal notranslate"><span class="pre">viewer</span></code> records each step of the evaluation of a Joy program. The
 135 <code class="docutils literal notranslate"><span class="pre">TracePrinter</span></code> has a facility for printing out a trace of the
 136 evaluation, one line per step. Each step is aligned to the current
 137 interpreter position, signified by a period separating the stack on the
 138 left from the pending expression (“continuation”) on the right.</p>
 139 </section>
 140 </section>
 141 <section id="parser">
 142 <h2>Parser<a class="headerlink" href="#parser" title="Permalink to this headline">¶</a></h2>
 143 <p>The parser is extremely simple.  The undocumented <code class="docutils literal notranslate"><span class="pre">re.Scanner</span></code> class
 144 does the tokenizing and then the parser builds the tuple
 145 structure out of the tokens. There’s no Abstract Syntax Tree or anything
 146 like that.</p>
 147 <section id="symbols">
 148 <h3>Symbols<a class="headerlink" href="#symbols" title="Permalink to this headline">¶</a></h3>
 149 <p>TODO: Symbols are just a string subclass; used by the parser to represent function names and by the interpreter to look up functions in the dictionary.  N.B.: Symbols are not looked up at parse-time.  You <em>could</em> define recursive functions, er, recusively, without <code class="docutils literal notranslate"><span class="pre">genrec</span></code> or other recursion combinators  <code class="docutils literal notranslate"><span class="pre">foo</span> <span class="pre">==</span> <span class="pre">...</span> <span class="pre">foo</span> <span class="pre">...</span></code> but don’t do that.</p>
 150 </section>
 151 <section id="token-regular-expressions">
 152 <h3>Token Regular Expressions<a class="headerlink" href="#token-regular-expressions" title="Permalink to this headline">¶</a></h3>
 153 <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">123</span>   <span class="mf">1.2</span>   <span class="s1">&#39;single quotes&#39;</span>  <span class="s2">&quot;double quotes&quot;</span>   <span class="n">function</span>
 154 </pre></div>
 155 </div>
 156 <p>TBD (look in the :module: joy.parser  module.)</p>
 157 </section>
 158 <section id="examples">
 159 <h3>Examples<a class="headerlink" href="#examples" title="Permalink to this headline">¶</a></h3>
 160 <div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="n">joy</span><span class="o">.</span><span class="n">parser</span><span class="o">.</span><span class="n">text_to_expression</span><span class="p">(</span><span class="s1">&#39;1 2 3 4 5&#39;</span><span class="p">)</span>  <span class="c1"># A simple sequence.</span>
 161 </pre></div>
 162 </div>
 163 <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="p">(</span><span class="mi">5</span><span class="p">,</span> <span class="p">())))))</span>
 164 </pre></div>
 165 </div>
 166 <div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="n">joy</span><span class="o">.</span><span class="n">parser</span><span class="o">.</span><span class="n">text_to_expression</span><span class="p">(</span><span class="s1">&#39;[1 2 3] 4 5&#39;</span><span class="p">)</span>  <span class="c1"># Three items, the first is a list with three items</span>
 167 </pre></div>
 168 </div>
 169 <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">((</span><span class="mi">1</span><span class="p">,</span> <span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="p">()))),</span> <span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="p">(</span><span class="mi">5</span><span class="p">,</span> <span class="p">())))</span>
 170 </pre></div>
 171 </div>
 172 <div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="n">joy</span><span class="o">.</span><span class="n">parser</span><span class="o">.</span><span class="n">text_to_expression</span><span class="p">(</span><span class="s1">&#39;1 23 [&quot;four&quot; [-5.0] cons] 8888&#39;</span><span class="p">)</span>  <span class="c1"># A mixed bag. cons is</span>
 173                                                                  <span class="c1"># a Symbol, no lookup at</span>
 174                                                                  <span class="c1"># parse-time.  Haiku docs.</span>
 175 </pre></div>
 176 </div>
 177 <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="p">(</span><span class="mi">23</span><span class="p">,</span> <span class="p">((</span><span class="s1">&#39;four&#39;</span><span class="p">,</span> <span class="p">((</span><span class="o">-</span><span class="mf">5.0</span><span class="p">,</span> <span class="p">()),</span> <span class="p">(</span><span class="n">cons</span><span class="p">,</span> <span class="p">()))),</span> <span class="p">(</span><span class="mi">8888</span><span class="p">,</span> <span class="p">()))))</span>
 178 </pre></div>
 179 </div>
 180 <div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="n">joy</span><span class="o">.</span><span class="n">parser</span><span class="o">.</span><span class="n">text_to_expression</span><span class="p">(</span><span class="s1">&#39;[][][][][]&#39;</span><span class="p">)</span>  <span class="c1"># Five empty lists.</span>
 181 </pre></div>
 182 </div>
 183 <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">((),</span> <span class="p">((),</span> <span class="p">((),</span> <span class="p">((),</span> <span class="p">((),</span> <span class="p">())))))</span>
 184 </pre></div>
 185 </div>
 186 <div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="n">joy</span><span class="o">.</span><span class="n">parser</span><span class="o">.</span><span class="n">text_to_expression</span><span class="p">(</span><span class="s1">&#39;[[[[[]]]]]&#39;</span><span class="p">)</span>  <span class="c1"># Five nested lists.</span>
 187 </pre></div>
 188 </div>
 189 <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">((((((),</span> <span class="p">()),</span> <span class="p">()),</span> <span class="p">()),</span> <span class="p">()),</span> <span class="p">())</span>
 190 </pre></div>
 191 </div>
 192 </section>
 193 </section>
 194 <section id="library">
 195 <h2>Library<a class="headerlink" href="#library" title="Permalink to this headline">¶</a></h2>
 196 <p>The Joy library of functions (aka commands, or “words” after Forth
 197 usage) encapsulates all the actual functionality (no pun intended) of
 198 the Joy system. There are simple functions such as addition <code class="docutils literal notranslate"><span class="pre">add</span></code> (or
 199 <code class="docutils literal notranslate"><span class="pre">+</span></code>, the library module supports aliases), and combinators which
 200 provide control-flow and higher-order operations.</p>
 201 <p>Many of the functions are defined in Python, like <code class="docutils literal notranslate"><span class="pre">dip</span></code>:</p>
 202 <div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="nb">print</span> <span class="n">inspect</span><span class="o">.</span><span class="n">getsource</span><span class="p">(</span><span class="n">joy</span><span class="o">.</span><span class="n">library</span><span class="o">.</span><span class="n">dip</span><span class="p">)</span>
 203 </pre></div>
 204 </div>
 205 <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">dip</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
 206   <span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">stack</span><span class="p">))</span> <span class="o">=</span> <span class="n">stack</span>
 207   <span class="n">expression</span> <span class="o">=</span> <span class="n">x</span><span class="p">,</span> <span class="n">expression</span>
 208   <span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">concat</span><span class="p">(</span><span class="n">quote</span><span class="p">,</span> <span class="n">expression</span><span class="p">),</span> <span class="n">dictionary</span>
 209 </pre></div>
 210 </div>
 211 <p>Some functions are defined in equations in terms of other functions.
 212 When the interpreter executes a definition function that function just
 213 pushes its body expression onto the pending expression (the
 214 continuation) and returns control to the interpreter.</p>
 215 <div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="nb">print</span> <span class="n">joy</span><span class="o">.</span><span class="n">library</span><span class="o">.</span><span class="n">definitions</span>
 216 </pre></div>
 217 </div>
 218 <pre class="literal-block">second == rest first
 219 third == rest rest first
 220 product == 1 swap [*] step
 221 swons == swap cons
 222 swoncat == swap concat
 223 flatten == [] swap [concat] step
 224 unit == [] cons
 225 quoted == [unit] dip
 226 unquoted == [i] dip
 227 enstacken == stack [clear] dip
 228 disenstacken == ? [uncons ?] loop pop
 229 ? == dup truthy
 230 dinfrirst == dip infra first
 231 nullary == [stack] dinfrirst
 232 unary == [stack [pop] dip] dinfrirst
 233 binary == [stack [popop] dip] dinfrirst
 234 ternary == [stack [popop pop] dip] dinfrirst
 235 pam == [i] map
 236 run == [] swap infra
 237 sqr == dup mul
 238 size == 0 swap [pop ++] step
 239 cleave == [i] app2 [popd] dip
 240 average == [sum 1.0 <em>] [size] cleave /
 241 gcd == 1 [tuck modulus dup 0 &gt;] loop pop
 242 least_fraction == dup [gcd] infra [div] concat map
 243 *fraction == [uncons] dip uncons [swap] dip concat [</em>] infra [*] dip cons
 244 <em>fraction0 == concat [[swap] dip * [</em>] dip] infra
 245 down_to_zero == [0 &gt;] [dup --] while
 246 range_to_zero == unit [down_to_zero] infra
 247 anamorphism == [pop []] swap [dip swons] genrec
 248 range == [0 &lt;=] [1 - dup] anamorphism
 249 while == swap [nullary] cons dup dipd concat loop
 250 dudipd == dup dipd
 251 primrec == [i] genrec</pre>
 252 <p>Currently, there’s no function to add new definitions to the dictionary
 253 from “within” Joy code itself. Adding new definitions remains a
 254 meta-interpreter action. You have to do it yourself, in Python, and wash
 255 your hands afterward.</p>
 256 <p>It would be simple enough to define one, but it would open the door to
 257 <em>name binding</em> and break the idea that all state is captured in the
 258 stack and expression. There’s an implicit <em>standard dictionary</em> that
 259 defines the actual semantics of the syntactic stack and expression
 260 datastructures (which only contain symbols, not the actual functions.
 261 Pickle some and see for yourself.)</p>
 262 <section id="there-should-be-only-one">
 263 <h3>“There should be only one.”<a class="headerlink" href="#there-should-be-only-one" title="Permalink to this headline">¶</a></h3>
 264 <p>Which brings me to talking about one of my hopes and dreams for this
 265 notation: “There should be only one.” What I mean is that there should
 266 be one universal standard dictionary of commands, and all bespoke work
 267 done in a UI for purposes takes place by direct interaction and macros.
 268 There would be a <em>Grand Refactoring</em> biannually (two years, not six
 269 months, that’s semi-annually) where any new definitions factored out of
 270 the usage and macros of the previous time, along with new algorithms and
 271 such, were entered into the dictionary and posted to e.g. IPFS.</p>
 272 <p>Code should not burgeon wildly, as it does today. The variety of code
 273 should map more-or-less to the well-factored variety of human
 274 computably-solvable problems. There shouldn’t be dozens of chat apps, JS
 275 frameworks, programming languages. It’s a waste of time, a <a class="reference external" href="https://en.wikipedia.org/wiki/Thundering_herd_problem">fractal
 276 “thundering herd”
 277 attack</a> on
 278 human mentality.</p>
 279 </section>
 280 <section id="literary-code-library">
 281 <h3>Literary Code Library<a class="headerlink" href="#literary-code-library" title="Permalink to this headline">¶</a></h3>
 282 <p>If you read over the other notebooks you’ll see that developing code in
 283 Joy is a lot like doing simple mathematics, and the descriptions of the
 284 code resemble math papers. The code also works the first time, no bugs.
 285 If you have any experience programming at all, you are probably
 286 skeptical, as I was, but it seems to work: deriving code mathematically
 287 seems to lead to fewer errors.</p>
 288 <p>But my point now is that this great ratio of textual explanation to wind
 289 up with code that consists of a few equations and could fit on an index
 290 card is highly desirable. Less code has fewer errors. The structure of
 291 Joy engenders a kind of thinking that seems to be very effective for
 292 developing structured processes.</p>
 293 <p>There seems to be an elegance and power to the notation.</p>
 294 </section>
 295 </section>
 296 </section>
 297
 298
 299           </div>
 300
 301         </div>
 302       </div>
 303       <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
 304         <div class="sphinxsidebarwrapper">
 305 <h1 class="logo"><a href="../index.html">Thun</a></h1>
 306
 307
 308
 309
 310
 311
 312
 313
 314 <h3>Navigation</h3>
 315 <ul class="current">
 316 <li class="toctree-l1 current"><a class="current reference internal" href="#">Thun: Joy in Python</a><ul>
 317 <li class="toctree-l2"><a class="reference internal" href="#read-eval-print-loop-repl">Read-Eval-Print Loop (REPL)</a></li>
 318 <li class="toctree-l2"><a class="reference internal" href="#the-stack">The Stack</a></li>
 319 <li class="toctree-l2"><a class="reference internal" href="#purely-functional-datastructures">Purely Functional Datastructures</a></li>
 320 <li class="toctree-l2"><a class="reference internal" href="#the-joy-function">The <code class="docutils literal notranslate"><span class="pre">joy()</span></code> function</a></li>
 321 <li class="toctree-l2"><a class="reference internal" href="#parser">Parser</a></li>
 322 <li class="toctree-l2"><a class="reference internal" href="#library">Library</a></li>
 323 </ul>
 324 </li>
 325 <li class="toctree-l1"><a class="reference internal" href="../joy.html">Joy Interpreter</a></li>
 326 <li class="toctree-l1"><a class="reference internal" href="../stack.html">Stack or Quote or Sequence or List…</a></li>
 327 <li class="toctree-l1"><a class="reference internal" href="../parser.html">Parsing Text into Joy Expressions</a></li>
 328 <li class="toctree-l1"><a class="reference internal" href="../pretty.html">Tracing Joy Execution</a></li>
 329 <li class="toctree-l1"><a class="reference internal" href="../library.html">Function Reference</a></li>
 330 <li class="toctree-l1"><a class="reference internal" href="../lib.html">Functions Grouped by, er, Function with Examples</a></li>
 331 <li class="toctree-l1"><a class="reference internal" href="../types.html">Type Inference of Joy Expressions</a></li>
 332 <li class="toctree-l1"><a class="reference internal" href="index.html">Essays about Programming in Joy</a></li>
 333 </ul>
 334
 335 <div class="relations">
 336 <h3>Related Topics</h3>
 337 <ul>
 338   <li><a href="../index.html">Documentation overview</a><ul>
 339       <li>Previous: <a href="../index.html" title="previous chapter">Thun 0.4.1 Documentation</a></li>
 340       <li>Next: <a href="../joy.html" title="next chapter">Joy Interpreter</a></li>
 341   </ul></li>
 342 </ul>
 343 </div>
 344 <div id="searchbox" style="display: none" role="search">
 345   <h3 id="searchlabel">Quick search</h3>
 346     <div class="searchformwrapper">
 347     <form class="search" action="../search.html" method="get">
 348       <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
 349       <input type="submit" value="Go" />
 350     </form>
 351     </div>
 352 </div>
 353 <script>$('#searchbox').show(0);</script>
 354
 355
 356
 357
 358
 359
 360
 361
 362         </div>
 363       </div>
 364       <div class="clearer"></div>
 365     </div>
 366     <div class="footer" role="contentinfo">
 367 <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">
 368 <img alt="Creative Commons License" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" />
 369 </a>
 370 <br />
 371 <span xmlns:dct="http://purl.org/dc/terms/" property="dct:title">Thun Documentation</span> by <a xmlns:cc="http://creativecommons.org/ns#" href="https://joypy.osdn.io/" property="cc:attributionName" rel="cc:attributionURL">Simon Forman</a> is licensed under a <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License</a>.<br />Based on a work at <a xmlns:dct="http://purl.org/dc/terms/" href="https://osdn.net/projects/joypy/" rel="dct:source">https://osdn.net/projects/joypy/</a>.
 372       Created using <a href="http://sphinx-doc.org/">Sphinx</a> 4.3.0.
 373     </div>
 374
 375   </body>
 376 </html>