• R/O
  • HTTP
  • SSH
  • HTTPS

Thun: Résumé du dépôt

Interpreter and library.


Commits Récents RSS

Révision l'heure Auteur Message:
d0a253c 2022-04-06 03:15:34 Simon Forman master Need to keep definition for ucons around the Nim impleme...
9fe565a 2022-04-06 02:06:40 Simon Forman uncons as basis - clear deletes stack at once, not in a ...
2fb2797 2022-04-06 02:02:01 Simon Forman Two wrappers One for math ops, the other for Boolean. F...
68f6e21 2022-04-05 01:09:01 Simon Forman Minor cleanup.
a0374c5 2022-04-05 00:01:51 Simon Forman Start a per-project README for Python.
01135d2 2022-04-05 00:00:09 Simon Forman Start to update README
1da997f 2022-04-04 23:58:22 Simon Forman Expression?
6eff23b 2022-04-01 02:10:22 Simon Forman Rebuild HTML docs.
4be4509 2022-03-31 04:12:19 Simon Forman Sidebar links should be a little farther apart.
b5178dc 2022-03-31 04:11:20 Simon Forman I want to override some CSS. The links on the sidebar ar...

Branches

Nom Révision l'heure Auteur Message:
master d0a253c 2022-04-06 03:15:34 Simon Forman Need to keep definition for...

README

Thun

A Dialect of Joy.

v0.4.2

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.

The best source (no pun intended) for learning about Joy is the
information made available at the website of La Trobe University (see the
references section below for the URL) 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.


Directory structure

    Thun
     |-- LICENSE - GPLv3
     |-- README - this file
     |
     |-- archive
     |   |-- Joy-Programming.zip
     |   `-- README
     |
     |-- docs
     |   |-- notebooks - Jupyter Notebooks and supporting modules
     |   |-- reference - Docs for each function.
     |   |-- sphinx_docs - Generate https://joypy.osdn.io/ site.
     |   `-- README - Table of Contents
     |
     `-- implementations
         |-- Nim - interpreter
         |-- Prolog - interpreter
         |            type inference
         |            work-in-progress compiler
         |-- Python - interpreter
         |-- Rust - work-in-progress interpreter
         `-- defs.txt - common Joy definitions for all interpreters


Documentation

Jupyter Notebooks

The docs/notebooks dir contains Jupyter notebooks, ... TODO

Sphinx Docs

Some of the documentation is in the form of ReST files in
docs/sphinx_docs dir.

Building the Docs

Building the documentation is a little tricky at the moment.  It involves
a makefile that uses nbconvert to generate ReST files from some of the
notebooks, copies those to the sphinx source dir, then builds the HTML
output using sphinx.

Get the dependencies for (re)building the docs:

    pip install Thun[build-docs]
    make docs


Basics of Joy

Joy is stack-based.  There is a main stack that holds data items:
integers, floats, strings, functions, and sequences or quotes which hold
data items themselves.

    23 1.8 'a string' "another" dup [21 18 /] [1 [2 [3]]]

A Joy expression is just a sequence (a.k.a. "list") of items.  Sequences
intended as programs are called "quoted programs".  Evaluation proceeds
by iterating through the terms in the expression, putting all literals
onto the main stack and executing functions as they are encountered.
Functions receive the current stack and return the next stack.


Literals and Simple Functions

    joy? 1 2 3
          . 1 2 3
        1 . 2 3
      1 2 . 3
    1 2 3 . 

    1 2 3 <-top

    joy? + +
    1 2 3 . + +
      1 5 . +
        6 . 

    6 <-top

    joy? 7 *
      6 . 7 *
    6 7 . *
     42 . 

    42 <-top

    joy? 


Combinators

The main loop is very simple as most of the action happens through what
are called "combinators": functions which accept quoted programs on the
stack and run them in various ways.  These combinators factor specific
patterns that provide the effect of control-flow in other languages (such
as ifte which is like if..then..else..)  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.

    joy? 23 [0 >] [dup --] while

    ...

    -> 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23


TODO:

§.4.4 Definitions and More Elaborate Functions

§.4.5 Programming and Metaprogramming

§.4.6 Refactoring


§.6 References & Further Reading


Wikipedia entry for Joy:
https://en.wikipedia.org/wiki/Joy_%28programming_language%29


Homepage at La Trobe University:
http://www.latrobe.edu.au/humanities/research/research-projects/past-projects/joy-programming-language



--------------------------------------------------

Misc...

Stack based - literals (as functions) - functions - combinators -
Refactoring and making new definitions - traces and comparing
performance - metaprogramming as programming, even the lowly integer
range function can be expressed in two phases: building a specialized
program and then executing it with a combinator - ?Partial evaluation?
- ?memoized dynamic dependency graphs? - algebra

--------------------------------------------------

Copyright © 2014-2022 Simon Forman

This file is part of Thun

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.

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.

You should have received a copy of the GNU General Public License along
with Thun.  If not see <http://www.gnu.org/licenses/>.

Afficher sur ancien navigateur de dépôt.