376 lines
24 KiB
HTML
376 lines
24 KiB
HTML
|
||
<!DOCTYPE html>
|
||
|
||
<html>
|
||
<head>
|
||
<meta charset="utf-8" />
|
||
<meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
|
||
|
||
<title>Thun: Joy in Python — Thun 0.4.1 documentation</title>
|
||
<link rel="stylesheet" type="text/css" href="../_static/pygments.css" />
|
||
<link rel="stylesheet" type="text/css" href="../_static/alabaster.css" />
|
||
<script data-url_root="../" id="documentation_options" src="../_static/documentation_options.js"></script>
|
||
<script src="../_static/jquery.js"></script>
|
||
<script src="../_static/underscore.js"></script>
|
||
<script src="../_static/doctools.js"></script>
|
||
<link rel="index" title="Index" href="../genindex.html" />
|
||
<link rel="search" title="Search" href="../search.html" />
|
||
<link rel="next" title="Joy Interpreter" href="../joy.html" />
|
||
<link rel="prev" title="Thun 0.4.1 Documentation" href="../index.html" />
|
||
|
||
<link rel="stylesheet" href="../_static/custom.css" type="text/css" />
|
||
|
||
|
||
<meta name="viewport" content="width=device-width, initial-scale=0.9, maximum-scale=0.9" />
|
||
|
||
</head><body>
|
||
|
||
|
||
<div class="document">
|
||
<div class="documentwrapper">
|
||
<div class="bodywrapper">
|
||
|
||
|
||
<div class="body" role="main">
|
||
|
||
<section id="thun-joy-in-python">
|
||
<h1>Thun: Joy in Python<a class="headerlink" href="#thun-joy-in-python" title="Permalink to this headline">¶</a></h1>
|
||
<p>This implementation is meant as a tool for exploring the programming
|
||
model and method of Joy. Python seems like a great implementation
|
||
language for Joy for several reasons.</p>
|
||
<ul class="simple">
|
||
<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>
|
||
<li><p>We get garbage collection for free.</p></li>
|
||
<li><p>Compilation via Cython.</p></li>
|
||
<li><p>Python is a “glue language” with loads of libraries which we can wrap in Joy functions.</p></li>
|
||
</ul>
|
||
<section id="read-eval-print-loop-repl">
|
||
<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>
|
||
<p>The main way to interact with the Joy interpreter is through a simple
|
||
<a class="reference external" href="https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop">REPL</a>
|
||
that you start by running the package:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>$ python3 -m joy
|
||
Thun - Copyright © 2017 Simon Forman
|
||
This program comes with ABSOLUTELY NO WARRANTY; for details type "warranty".
|
||
This is free software, and you are welcome to redistribute it
|
||
under certain conditions; type "sharing" for details.
|
||
Type "words" to see a list of all words, and "[<name>] help" to print the
|
||
docs for a word.
|
||
|
||
|
||
<-top
|
||
|
||
joy? _
|
||
</pre></div>
|
||
</div>
|
||
<p>The <code class="docutils literal notranslate"><span class="pre"><-top</span></code> marker points to the top of the (initially empty) stack.
|
||
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
|
||
be printed followed by the stack and prompt again:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>joy? 23 sqr 18 +
|
||
|
||
547 <-top
|
||
|
||
joy?
|
||
</pre></div>
|
||
</div>
|
||
<p>There is a <cite>trace</cite> combinator:</p>
|
||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>joy? 23 [sqr 18 +] trace
|
||
23 . sqr 18 +
|
||
23 . dup mul 18 +
|
||
23 23 . mul 18 +
|
||
529 . 18 +
|
||
529 18 . +
|
||
547 .
|
||
|
||
547 <-top
|
||
|
||
joy?
|
||
</pre></div>
|
||
</div>
|
||
</section>
|
||
<section id="the-stack">
|
||
<h2>The Stack<a class="headerlink" href="#the-stack" title="Permalink to this headline">¶</a></h2>
|
||
<p>In Joy, in addition to the types Boolean, integer, float, and string,
|
||
there is a <a class="reference internal" href="../stack.html"><span class="doc">single sequence type</span></a> represented by enclosing a sequence of
|
||
terms in brackets <code class="docutils literal notranslate"><span class="pre">[...]</span></code>. This sequence type is used to represent
|
||
both the stack and the expression. It is a <a class="reference external" href="https://en.wikipedia.org/wiki/Cons#Lists">cons
|
||
list</a> made from Python
|
||
tuples.</p>
|
||
</section>
|
||
<section id="purely-functional-datastructures">
|
||
<h2>Purely Functional Datastructures<a class="headerlink" href="#purely-functional-datastructures" title="Permalink to this headline">¶</a></h2>
|
||
<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>
|
||
</section>
|
||
<section id="the-joy-function">
|
||
<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>
|
||
<section id="an-interpreter">
|
||
<h3>An Interpreter<a class="headerlink" href="#an-interpreter" title="Permalink to this headline">¶</a></h3>
|
||
<p>The <code class="docutils literal notranslate"><span class="pre">joy()</span></code> interpreter function is extrememly simple. It accepts a stack, an
|
||
expression, and a dictionary, and it iterates through the expression
|
||
putting values onto the stack and delegating execution to functions which it
|
||
looks up in the dictionary.</p>
|
||
</section>
|
||
<section id="continuation-passing-style">
|
||
<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>
|
||
<p>One day I thought, What happens if you rewrite Joy to use
|
||
<a class="reference external" href="https://en.wikipedia.org/wiki/Continuation-passing_style">CPS</a>? I
|
||
made all the functions accept and return the expression as well as the
|
||
stack and found that all the combinators could be rewritten to work by
|
||
modifying the expression rather than making recursive calls to the
|
||
<code class="docutils literal notranslate"><span class="pre">joy()</span></code> function.</p>
|
||
</section>
|
||
<section id="view-function">
|
||
<h3>View function<a class="headerlink" href="#view-function" title="Permalink to this headline">¶</a></h3>
|
||
<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
|
||
is a function which it calls on
|
||
each iteration passing the current stack and expression just before
|
||
evaluation. This can be used for tracing, breakpoints, retrying after
|
||
exceptions, or interrupting an evaluation and saving to disk or sending
|
||
over the network to resume later. The stack and expression together
|
||
contain all the state of the computation at each step.</p>
|
||
</section>
|
||
<section id="the-traceprinter">
|
||
<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>
|
||
<p>A <code class="docutils literal notranslate"><span class="pre">viewer</span></code> records each step of the evaluation of a Joy program. The
|
||
<code class="docutils literal notranslate"><span class="pre">TracePrinter</span></code> has a facility for printing out a trace of the
|
||
evaluation, one line per step. Each step is aligned to the current
|
||
interpreter position, signified by a period separating the stack on the
|
||
left from the pending expression (“continuation”) on the right.</p>
|
||
</section>
|
||
</section>
|
||
<section id="parser">
|
||
<h2>Parser<a class="headerlink" href="#parser" title="Permalink to this headline">¶</a></h2>
|
||
<p>The parser is extremely simple. The undocumented <code class="docutils literal notranslate"><span class="pre">re.Scanner</span></code> class
|
||
does the tokenizing and then the parser builds the tuple
|
||
structure out of the tokens. There’s no Abstract Syntax Tree or anything
|
||
like that.</p>
|
||
<section id="symbols">
|
||
<h3>Symbols<a class="headerlink" href="#symbols" title="Permalink to this headline">¶</a></h3>
|
||
<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>
|
||
</section>
|
||
<section id="token-regular-expressions">
|
||
<h3>Token Regular Expressions<a class="headerlink" href="#token-regular-expressions" title="Permalink to this headline">¶</a></h3>
|
||
<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">'single quotes'</span> <span class="s2">"double quotes"</span> <span class="n">function</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>TBD (look in the :module: joy.parser module.)</p>
|
||
</section>
|
||
<section id="examples">
|
||
<h3>Examples<a class="headerlink" href="#examples" title="Permalink to this headline">¶</a></h3>
|
||
<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">'1 2 3 4 5'</span><span class="p">)</span> <span class="c1"># A simple sequence.</span>
|
||
</pre></div>
|
||
</div>
|
||
<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>
|
||
</pre></div>
|
||
</div>
|
||
<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">'[1 2 3] 4 5'</span><span class="p">)</span> <span class="c1"># Three items, the first is a list with three items</span>
|
||
</pre></div>
|
||
</div>
|
||
<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>
|
||
</pre></div>
|
||
</div>
|
||
<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">'1 23 ["four" [-5.0] cons] 8888'</span><span class="p">)</span> <span class="c1"># A mixed bag. cons is</span>
|
||
<span class="c1"># a Symbol, no lookup at</span>
|
||
<span class="c1"># parse-time. Haiku docs.</span>
|
||
</pre></div>
|
||
</div>
|
||
<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">'four'</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>
|
||
</pre></div>
|
||
</div>
|
||
<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">'[][][][][]'</span><span class="p">)</span> <span class="c1"># Five empty lists.</span>
|
||
</pre></div>
|
||
</div>
|
||
<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>
|
||
</pre></div>
|
||
</div>
|
||
<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">'[[[[[]]]]]'</span><span class="p">)</span> <span class="c1"># Five nested lists.</span>
|
||
</pre></div>
|
||
</div>
|
||
<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>
|
||
</pre></div>
|
||
</div>
|
||
</section>
|
||
</section>
|
||
<section id="library">
|
||
<h2>Library<a class="headerlink" href="#library" title="Permalink to this headline">¶</a></h2>
|
||
<p>The Joy library of functions (aka commands, or “words” after Forth
|
||
usage) encapsulates all the actual functionality (no pun intended) of
|
||
the Joy system. There are simple functions such as addition <code class="docutils literal notranslate"><span class="pre">add</span></code> (or
|
||
<code class="docutils literal notranslate"><span class="pre">+</span></code>, the library module supports aliases), and combinators which
|
||
provide control-flow and higher-order operations.</p>
|
||
<p>Many of the functions are defined in Python, like <code class="docutils literal notranslate"><span class="pre">dip</span></code>:</p>
|
||
<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>
|
||
</pre></div>
|
||
</div>
|
||
<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>
|
||
<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>
|
||
<span class="n">expression</span> <span class="o">=</span> <span class="n">x</span><span class="p">,</span> <span class="n">expression</span>
|
||
<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>
|
||
</pre></div>
|
||
</div>
|
||
<p>Some functions are defined in equations in terms of other functions.
|
||
When the interpreter executes a definition function that function just
|
||
pushes its body expression onto the pending expression (the
|
||
continuation) and returns control to the interpreter.</p>
|
||
<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>
|
||
</pre></div>
|
||
</div>
|
||
<pre class="literal-block">second == rest first
|
||
third == rest rest first
|
||
product == 1 swap [*] step
|
||
swons == swap cons
|
||
swoncat == swap concat
|
||
flatten == [] swap [concat] step
|
||
unit == [] cons
|
||
quoted == [unit] dip
|
||
unquoted == [i] dip
|
||
enstacken == stack [clear] dip
|
||
disenstacken == ? [uncons ?] loop pop
|
||
? == dup truthy
|
||
dinfrirst == dip infra first
|
||
nullary == [stack] dinfrirst
|
||
unary == [stack [pop] dip] dinfrirst
|
||
binary == [stack [popop] dip] dinfrirst
|
||
ternary == [stack [popop pop] dip] dinfrirst
|
||
pam == [i] map
|
||
run == [] swap infra
|
||
sqr == dup mul
|
||
size == 0 swap [pop ++] step
|
||
cleave == [i] app2 [popd] dip
|
||
average == [sum 1.0 <em>] [size] cleave /
|
||
gcd == 1 [tuck modulus dup 0 >] loop pop
|
||
least_fraction == dup [gcd] infra [div] concat map
|
||
*fraction == [uncons] dip uncons [swap] dip concat [</em>] infra [*] dip cons
|
||
<em>fraction0 == concat [[swap] dip * [</em>] dip] infra
|
||
down_to_zero == [0 >] [dup --] while
|
||
range_to_zero == unit [down_to_zero] infra
|
||
anamorphism == [pop []] swap [dip swons] genrec
|
||
range == [0 <=] [1 - dup] anamorphism
|
||
while == swap [nullary] cons dup dipd concat loop
|
||
dudipd == dup dipd
|
||
primrec == [i] genrec</pre>
|
||
<p>Currently, there’s no function to add new definitions to the dictionary
|
||
from “within” Joy code itself. Adding new definitions remains a
|
||
meta-interpreter action. You have to do it yourself, in Python, and wash
|
||
your hands afterward.</p>
|
||
<p>It would be simple enough to define one, but it would open the door to
|
||
<em>name binding</em> and break the idea that all state is captured in the
|
||
stack and expression. There’s an implicit <em>standard dictionary</em> that
|
||
defines the actual semantics of the syntactic stack and expression
|
||
datastructures (which only contain symbols, not the actual functions.
|
||
Pickle some and see for yourself.)</p>
|
||
<section id="there-should-be-only-one">
|
||
<h3>“There should be only one.”<a class="headerlink" href="#there-should-be-only-one" title="Permalink to this headline">¶</a></h3>
|
||
<p>Which brings me to talking about one of my hopes and dreams for this
|
||
notation: “There should be only one.” What I mean is that there should
|
||
be one universal standard dictionary of commands, and all bespoke work
|
||
done in a UI for purposes takes place by direct interaction and macros.
|
||
There would be a <em>Grand Refactoring</em> biannually (two years, not six
|
||
months, that’s semi-annually) where any new definitions factored out of
|
||
the usage and macros of the previous time, along with new algorithms and
|
||
such, were entered into the dictionary and posted to e.g. IPFS.</p>
|
||
<p>Code should not burgeon wildly, as it does today. The variety of code
|
||
should map more-or-less to the well-factored variety of human
|
||
computably-solvable problems. There shouldn’t be dozens of chat apps, JS
|
||
frameworks, programming languages. It’s a waste of time, a <a class="reference external" href="https://en.wikipedia.org/wiki/Thundering_herd_problem">fractal
|
||
“thundering herd”
|
||
attack</a> on
|
||
human mentality.</p>
|
||
</section>
|
||
<section id="literary-code-library">
|
||
<h3>Literary Code Library<a class="headerlink" href="#literary-code-library" title="Permalink to this headline">¶</a></h3>
|
||
<p>If you read over the other notebooks you’ll see that developing code in
|
||
Joy is a lot like doing simple mathematics, and the descriptions of the
|
||
code resemble math papers. The code also works the first time, no bugs.
|
||
If you have any experience programming at all, you are probably
|
||
skeptical, as I was, but it seems to work: deriving code mathematically
|
||
seems to lead to fewer errors.</p>
|
||
<p>But my point now is that this great ratio of textual explanation to wind
|
||
up with code that consists of a few equations and could fit on an index
|
||
card is highly desirable. Less code has fewer errors. The structure of
|
||
Joy engenders a kind of thinking that seems to be very effective for
|
||
developing structured processes.</p>
|
||
<p>There seems to be an elegance and power to the notation.</p>
|
||
</section>
|
||
</section>
|
||
</section>
|
||
|
||
|
||
</div>
|
||
|
||
</div>
|
||
</div>
|
||
<div class="sphinxsidebar" role="navigation" aria-label="main navigation">
|
||
<div class="sphinxsidebarwrapper">
|
||
<h1 class="logo"><a href="../index.html">Thun</a></h1>
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
<h3>Navigation</h3>
|
||
<ul class="current">
|
||
<li class="toctree-l1 current"><a class="current reference internal" href="#">Thun: Joy in Python</a><ul>
|
||
<li class="toctree-l2"><a class="reference internal" href="#read-eval-print-loop-repl">Read-Eval-Print Loop (REPL)</a></li>
|
||
<li class="toctree-l2"><a class="reference internal" href="#the-stack">The Stack</a></li>
|
||
<li class="toctree-l2"><a class="reference internal" href="#purely-functional-datastructures">Purely Functional Datastructures</a></li>
|
||
<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>
|
||
<li class="toctree-l2"><a class="reference internal" href="#parser">Parser</a></li>
|
||
<li class="toctree-l2"><a class="reference internal" href="#library">Library</a></li>
|
||
</ul>
|
||
</li>
|
||
<li class="toctree-l1"><a class="reference internal" href="../joy.html">Joy Interpreter</a></li>
|
||
<li class="toctree-l1"><a class="reference internal" href="../stack.html">Stack or Quote or Sequence or List…</a></li>
|
||
<li class="toctree-l1"><a class="reference internal" href="../parser.html">Parsing Text into Joy Expressions</a></li>
|
||
<li class="toctree-l1"><a class="reference internal" href="../pretty.html">Tracing Joy Execution</a></li>
|
||
<li class="toctree-l1"><a class="reference internal" href="../library.html">Function Reference</a></li>
|
||
<li class="toctree-l1"><a class="reference internal" href="../lib.html">Functions Grouped by, er, Function with Examples</a></li>
|
||
<li class="toctree-l1"><a class="reference internal" href="../types.html">Type Inference of Joy Expressions</a></li>
|
||
<li class="toctree-l1"><a class="reference internal" href="index.html">Essays about Programming in Joy</a></li>
|
||
</ul>
|
||
|
||
<div class="relations">
|
||
<h3>Related Topics</h3>
|
||
<ul>
|
||
<li><a href="../index.html">Documentation overview</a><ul>
|
||
<li>Previous: <a href="../index.html" title="previous chapter">Thun 0.4.1 Documentation</a></li>
|
||
<li>Next: <a href="../joy.html" title="next chapter">Joy Interpreter</a></li>
|
||
</ul></li>
|
||
</ul>
|
||
</div>
|
||
<div id="searchbox" style="display: none" role="search">
|
||
<h3 id="searchlabel">Quick search</h3>
|
||
<div class="searchformwrapper">
|
||
<form class="search" action="../search.html" method="get">
|
||
<input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
|
||
<input type="submit" value="Go" />
|
||
</form>
|
||
</div>
|
||
</div>
|
||
<script>$('#searchbox').show(0);</script>
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
</div>
|
||
</div>
|
||
<div class="clearer"></div>
|
||
</div>
|
||
<div class="footer" role="contentinfo">
|
||
<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">
|
||
<img alt="Creative Commons License" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" />
|
||
</a>
|
||
<br />
|
||
<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>.
|
||
Created using <a href="http://sphinx-doc.org/">Sphinx</a> 4.4.0.
|
||
</div>
|
||
|
||
</body>
|
||
</html> |