165 lines
8.5 KiB
HTML
165 lines
8.5 KiB
HTML
<!doctype html>
|
|
<html>
|
|
<head>
|
|
<meta charset="utf-8">
|
|
<title>Thun</title>
|
|
<link rel="stylesheet" href="/css/site.css">
|
|
</head>
|
|
<body>
|
|
<h1>Thun</h1>
|
|
<p>A Dialect of Joy.</p>
|
|
<p>Version 0.5.0</p>
|
|
<blockquote>
|
|
<p>Simple pleasures are the best.</p>
|
|
</blockquote>
|
|
<p>Joy is a programming language created by Manfred von Thun that is easy to
|
|
use and understand and has many other nice properties. This project
|
|
implements interpreters for a dialect that attempts to stay very close to
|
|
the spirit of Joy but does not precisely match the behaviour of the
|
|
original version written in C.</p>
|
|
<p>Joy is:</p>
|
|
<ul>
|
|
<li><a href="https://en.wikipedia.org/wiki/Purely_functional_programming">Purely Functional</a></li>
|
|
<li><a href="https://en.wikipedia.org/wiki/Stack-oriented_programming_language">Stack-based</a></li>
|
|
<li><a href="https://en.wikipedia.org/wiki/Concatenative_programming_language">Concatinative</a> (See also <a href="http://www.concatenative.org/wiki/view/Concatenative%20language">concatenative.org</a>)</li>
|
|
<li><a href="https://joypy.osdn.io/notebooks/Categorical.html">Categorical</a></li>
|
|
</ul>
|
|
<p>The best source (no pun intended) for learning about Joy is the
|
|
information made available at the
|
|
<a href="http://www.latrobe.edu.au/humanities/research/research-projects/past-projects/joy-programming-language">website of La Trobe University</a>
|
|
which contains source code for the original C interpreter, Joy language source code for various functions,
|
|
and a great deal of fascinating material mostly written by Von Thun on
|
|
Joy and its deeper facets as well as how to program in it and several
|
|
interesting aspects. It's quite a treasure trove.</p>
|
|
<p><a href="https://en.wikipedia.org/wiki/Joy_%28programming_language%29">Wikipedia entry for Joy</a></p>
|
|
<p><a href="http://www.latrobe.edu.au/humanities/research/research-projects/past-projects/joy-programming-language">Homepage at La Trobe University</a></p>
|
|
<p><a href="https://web.archive.org/web/20220411010035/https://joypy.osdn.io/">The original Thun/Joypy site</a></p>
|
|
<h2>Example Code</h2>
|
|
<p>Here is an example of Joy code:</p>
|
|
<pre><code>square_spiral ≡ [_p] [_then] [_else] ifte
|
|
|
|
_p ≡ [_p0] [_p1] &&
|
|
_p0 ≡ [abs] ii <=
|
|
_p1 ≡ [<>] [pop !-] ||
|
|
|
|
_then ≡ [ !-] [[++]] [[--]] ifte dip
|
|
_else ≡ [pop !-] [--] [++] ifte
|
|
</code></pre>
|
|
<p>It might seem unreadable but with a little familiarity it becomes just as legible as any other notation.</p>
|
|
<p>This function accepts two integers on the stack and increments or
|
|
decrements one of them such that the new pair of numbers is the next
|
|
coordinate pair in a square spiral (like the kind used to construct an
|
|
<a href="https://en.wikipedia.org/wiki/Ulam_spiral">Ulam Spiral</a>
|
|
). For more information see <a href="/notebooks/Square_Spiral.html">Square Spiral Example Joy Code</a></p>
|
|
<h2>Project Hosted on <a href="https://osdn.net/projects/joypy/">OSDN</a></h2>
|
|
<ul>
|
|
<li><a href="https://osdn.net/projects/joypy/scm/git/Thun/">Source Repository</a> (<a href="https://github.com/calroc/Thun">mirror</a>)</li>
|
|
<li><a href="https://todo.sr.ht/~sforman/thun-der">Bug tracker</a> (<a href="https://osdn.net/projects/joypy/ticket/">old tracker</a>)</li>
|
|
<li><a href="https://osdn.net/projects/joypy/forums/">Forums</a></li>
|
|
<li><a href="https://osdn.net/projects/joypy/lists/">Mailing list</a></li>
|
|
</ul>
|
|
<h2>Directory structure</h2>
|
|
<pre><code>Thun
|
|
|
|
|
|-- LICENSE - GPLv3
|
|
|-- README.md - this file
|
|
|
|
|
|-- archive
|
|
| |-- Joy-Programming.zip
|
|
| `-- README
|
|
|
|
|
|-- docs
|
|
| |-- Makefile - Generate https://joypy.osdn.io/ site.
|
|
| |-- notebooks - Jupyter Notebooks and supporting modules
|
|
| |-- reference - Docs for each function.
|
|
| |-- dep-graphs - Generated dependency graphs.
|
|
| `-- README - Table of Contents
|
|
|
|
|
`-- implementations
|
|
|
|
|
|-- Nim - interpreter
|
|
|
|
|
|-- Prolog - interpreter
|
|
| type inference
|
|
| work-in-progress compiler
|
|
|
|
|
|-- Python - interpreter
|
|
|
|
|
`-- defs.txt - common Joy definitions for all interpreters
|
|
</code></pre>
|
|
<h2>Documentation</h2>
|
|
<h3><a href="/notebooks/index.html">Jupyter Notebooks</a></h3>
|
|
<h3><a href="/FuncRef.html">Function Reference</a></h3>
|
|
<h3>Building the Docs</h3>
|
|
<p>Run <code>make</code> in the <code>docs</code> directory. (This is a lie, it's more complex than
|
|
that. Really you need to run (GNU) make in the <code>docs/notebooks</code> and
|
|
<code>docs/reference</code> dirs first, <em>then</em> run <code>make</code> in the <code>docs</code> directory.)</p>
|
|
<h2>Installation</h2>
|
|
<p>Clone the repo and follow the instructions in the individual <code>implementations</code> directories.</p>
|
|
<h2>Basics of Joy</h2>
|
|
<p>Joy is built around three things: a <strong>stack</strong> of data items, an <strong>expression</strong>
|
|
representing a program to evaluate, and a <strong>dictionary</strong> of named functions.</p>
|
|
<p>Joy is <a href="https://en.wikipedia.org/wiki/Stack-oriented_programming_language">stack-based</a>.
|
|
There is a single main <strong>stack</strong> that holds data items, which can be integers, bools,
|
|
symbols (names), or sequences of data items enclosed in square brackets (<code>[</code> or <code>]</code>).</p>
|
|
<pre><code>23 dup [21 18 add] true false [1 [2 [3]]] cons
|
|
</code></pre>
|
|
<p>A Joy <strong>expression</strong> is just a sequence or list of items. Sequences
|
|
intended as programs are called "quoted programs". Evaluation proceeds
|
|
by iterating through the terms in an expression putting all literals (integers, bools, or lists)
|
|
onto the main stack and executing functions named by symbols as they are encountered.
|
|
Functions receive the current stack, expression, and dictionary and return the next stack.</p>
|
|
<p>The <strong>dictionary</strong> associates symbols (strings) with Joy expressions that define the
|
|
available functions of the Joy system. Together the stack, expression, and dictionary
|
|
are the entire state of the Joy interpreter.</p>
|
|
<h3>Stack / Quote / List / Sequence</h3>
|
|
<p>When talking about Joy we use the terms "stack", "quote", "sequence",
|
|
"list", and others to mean the same thing: a simple linear datatype that
|
|
permits certain operations such as iterating and pushing and popping
|
|
values from (at least) one end.</p>
|
|
<blockquote>
|
|
<p>In describing Joy I have used the term quotation to describe all of the
|
|
above, because I needed a word to describe the arguments to combinators
|
|
which fulfill the same role in Joy as lambda abstractions (with
|
|
variables) fulfill in the more familiar functional languages. I use the
|
|
term list for those quotations whose members are what I call literals:
|
|
numbers, characters, truth values, sets, strings and other quotations.
|
|
All these I call literals because their occurrence in code results in
|
|
them being pushed onto the stack. But I also call [London Paris] a list.
|
|
So, [dup *] is a quotation but not a list.</p>
|
|
</blockquote>
|
|
<p>From ["A Conversation with Manfred von Thun" w/ Stevan Apter](http://archive.vector.org.uk/art10000350</p>
|
|
<h3>Literals and Simple Functions</h3>
|
|
<p>TODO</p>
|
|
<h3>Combinators</h3>
|
|
<p>The main loop is very simple as most of the action happens through what
|
|
are called <strong>combinators</strong>. These are functions which accept quoted programs on the
|
|
stack and run them in various ways. These combinators reify specific
|
|
control-flow patterns (such as <code>ifte</code> which is like <code>if.. then.. else..</code> in other
|
|
languages.) Combinators receive the current
|
|
expession in addition to the stack and return the next expression. They
|
|
work by changing the pending expression the interpreter is about to
|
|
execute. (The combinators could work by making recursive calls to the
|
|
interpreter and all intermediate state would be held in the call stack of
|
|
the implementation language, in this joy implementation they work instead
|
|
by changing the pending expression and intermediate state is put there.)</p>
|
|
<pre><code>joy? 23 [0 >] [dup --] while
|
|
23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
|
|
</code></pre>
|
|
<hr>
|
|
<p>Copyright © 2014-2022 Simon Forman</p>
|
|
<p>This file is part of Thun</p>
|
|
<p>Thun is free software: you can redistribute it and/or modify it under the
|
|
terms of the GNU General Public License as published by the Free Software
|
|
Foundation, either version 3 of the License, or (at your option) any
|
|
later version.</p>
|
|
<p>Thun is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
|
|
details.</p>
|
|
<p>You should have received a copy of the GNU General Public License along
|
|
with Thun. If not see <a href="http://www.gnu.org/licenses/">http://www.gnu.org/licenses/</a>.</p>
|
|
</body>
|
|
</html>
|
|
|