sforman/Thun
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Working to clean up docs.

Browse Source
This commit is contained in:
Simon Forman
2022-03-22 21:22:57 -07:00
parent ba6d09f956
commit 7dbb3c69ed
26 changed files with 0 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
implementations/Prolog/docs/reference/FORMAT-Functor-Reference.md
-39
View File
@@ -1,39 +0,0 @@
--------------------
Get a list of currently defined functors with:
?- joy(`words`, [], [Words]), maplist(writeln, Words).
FORMAT:
--------------------
## Name
[Basis] Function | Combinator
Summary
Gentzen diagram.
### Definition
if not basis.
### Derivation
if not basis.
### Source
if basis
### Discussion
### Crosslinks
implementations/Prolog/docs/reference/FuncRef.html
-353
View File
@@ -1,353 +0,0 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" lang="" xml:lang="">
<head>
<meta charset="utf-8" />
<meta name="generator" content="pandoc" />
<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes" />
<title>Functor-Reference</title>
<style>
html {
line-height: 1.5;
font-family: Georgia, serif;
font-size: 20px;
color: #1a1a1a;
background-color: #fdfdfd;
}
body {
margin: 0 auto;
max-width: 36em;
padding-left: 50px;
padding-right: 50px;
padding-top: 50px;
padding-bottom: 50px;
hyphens: auto;
word-wrap: break-word;
text-rendering: optimizeLegibility;
font-kerning: normal;
}
@media (max-width: 600px) {
body {
font-size: 0.9em;
padding: 1em;
}
}
@media print {
body {
background-color: transparent;
color: black;
font-size: 12pt;
}
p, h2, h3 {
orphans: 3;
widows: 3;
}
h2, h3, h4 {
page-break-after: avoid;
}
}
p {
margin: 1em 0;
}
a {
color: #1a1a1a;
}
a:visited {
color: #1a1a1a;
}
img {
max-width: 100%;
}
h1, h2, h3, h4, h5, h6 {
margin-top: 1.4em;
}
h5, h6 {
font-size: 1em;
font-style: italic;
}
h6 {
font-weight: normal;
}
ol, ul {
padding-left: 1.7em;
margin-top: 1em;
}
li > ol, li > ul {
margin-top: 0;
}
blockquote {
margin: 1em 0 1em 1.7em;
padding-left: 1em;
border-left: 2px solid #e6e6e6;
color: #606060;
}
code {
font-family: Menlo, Monaco, 'Lucida Console', Consolas, monospace;
font-size: 85%;
margin: 0;
}
pre {
margin: 1em 0;
overflow: auto;
}
pre code {
padding: 0;
overflow: visible;
}
.sourceCode {
background-color: transparent;
overflow: visible;
}
hr {
background-color: #1a1a1a;
border: none;
height: 1px;
margin: 1em 0;
}
table {
margin: 1em 0;
border-collapse: collapse;
width: 100%;
overflow-x: auto;
display: block;
font-variant-numeric: lining-nums tabular-nums;
}
table caption {
margin-bottom: 0.75em;
}
tbody {
margin-top: 0.5em;
border-top: 1px solid #1a1a1a;
border-bottom: 1px solid #1a1a1a;
}
th {
border-top: 1px solid #1a1a1a;
padding: 0.25em 0.5em 0.25em 0.5em;
}
td {
padding: 0.125em 0.5em 0.25em 0.5em;
}
header {
margin-bottom: 4em;
text-align: center;
}
#TOC li {
list-style: none;
}
#TOC a:not(:hover) {
text-decoration: none;
}
code{white-space: pre-wrap;}
span.smallcaps{font-variant: small-caps;}
span.underline{text-decoration: underline;}
div.column{display: inline-block; vertical-align: top; width: 50%;}
div.hanging-indent{margin-left: 1.5em; text-indent: -1.5em;}
ul.task-list{list-style: none;}
.display.math{display: block; text-align: center; margin: 0.5rem auto;}
</style>
<!--[if lt IE 9]>
<script src="//cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7.3/html5shiv-printshiv.min.js"></script>
<![endif]-->
</head>
<body>
<nav id="TOC" role="doc-toc">
<ul>
<li><a href="#functor-reference">Functor Reference</a>
<ul>
<li><a href="#section">!-</a></li>
<li><a href="#app1">app1</a></li>
<li><a href="#b">b</a></li>
<li><a href="#binary">binary</a></li>
<li><a href="#ccons">ccons</a></li>
<li><a href="#cons">cons</a></li>
<li><a href="#i">i</a></li>
<li><a href="#infra">infra</a></li>
<li><a href="#nullary">nullary</a></li>
<li><a href="#ternary">ternary</a></li>
<li><a href="#unary">unary</a></li>
<li><a href="#uncons">uncons</a></li>
<li><a href="#x">x</a></li>
</ul></li>
</ul>
</nav>
<h1 id="functor-reference">Functor Reference</h1>
<p>Version -10.0.0</p>
<p>Each function, combinator, or definition should be documented here.</p>
<hr />
<h2 id="section">!-</h2>
<p>&#x201C;not negative&#x201D;</p>
<p>(Function, Boolean Predicate)</p>
<p>Integer on top of stack is replaced by Boolean value indicating whether it is non-negative.</p>
<pre><code> N !-
----------- N &lt; 0
false
N !-
---------- N &gt;= 0
true</code></pre>
<h3 id="definition">Definition</h3>
<pre><code>0 &gt;=</code></pre>
<hr />
<h2 id="app1">app1</h2>
<p>&#x201C;apply one&#x201D;</p>
<p>(Combinator)</p>
<p>Given a quoted program on TOS and anything as the second stack item run the program without disturbing the stack and replace the two args with the first result of the program.</p>
<pre><code> ... x [Q] app1
---------------------------------
... [x ...] [Q] infra first</code></pre>
<h3 id="definition-1">Definition</h3>
<pre><code>nullary popd</code></pre>
<h3 id="discussion">Discussion</h3>
<p>Just a specialization of <code>nullary</code> really. Its parallelizable cousins are more useful.</p>
<hr />
<h2 id="b">b</h2>
<p>(Combinator)</p>
<p>Run two quoted programs</p>
<pre><code> [P] [Q] b
---------------
P Q</code></pre>
<h3 id="definition-2">Definition</h3>
<pre><code>[i] dip i</code></pre>
<h3 id="derivation">Derivation</h3>
<pre><code>[P] [Q] b
[P] [Q] [i] dip i
[P] i [Q] i
P [Q] i
P Q</code></pre>
<h3 id="discussion-1">Discussion</h3>
<p>This combinator comes in handy.</p>
<h3 id="crosslinks">Crosslinks</h3>
<p><a href="#dupdip">dupdip</a> <a href="#ii">ii</a></p>
<hr />
<h2 id="binary">binary</h2>
<p>(Combinator)</p>
<p>Run a quoted program using exactly two stack values and leave the first item of the result on the stack.</p>
<pre><code> ... y x [P] binary
-----------------------
... A</code></pre>
<h3 id="definition-3">Definition</h3>
<pre><code>unary popd</code></pre>
<h3 id="discussion-2">Discussion</h3>
<p>Runs any other quoted function and returns its first result while consuming exactly two items from the stack.</p>
<h3 id="crosslinks-1">Crosslinks</h3>
<p><a href="#nullary">nullary</a> <a href="#ternary">ternary</a> <a href="#unary">unary</a></p>
<hr />
<h2 id="ccons">ccons</h2>
<p>(Function)</p>
<p>Given two items and a list, append the items to the list to make a new list.</p>
<pre><code> B A [...] ccons
---------------------
[B A ...]</code></pre>
<h3 id="definition-4">Definition</h3>
<pre><code>cons cons</code></pre>
<h3 id="discussion-3">Discussion</h3>
<p>Does <code>cons</code> twice.</p>
<h3 id="crosslinks-2">Crosslinks</h3>
<p><a href="#cons">cons</a></p>
<hr />
<h2 id="cons">cons</h2>
<p>(Basis Function)</p>
<p>Given an item and a list, append the item to the list to make a new list.</p>
<pre><code> A [...] cons
------------------
[A ...]</code></pre>
<h3 id="source">Source</h3>
<pre><code>func(cons, [list(A), B|S], [list([B|A])|S]).</code></pre>
<h3 id="discussion-4">Discussion</h3>
<p>Cons is a venerable old function from Lisp. It doesn&#x2019;t inspect the item but it will not cons onto a non-list. It&#x2019;s inverse operation is called <code>uncons</code>.</p>
<h3 id="crosslinks-3">Crosslinks</h3>
<p><a href="#ccons">ccons</a> <a href="#uncons">uncons</a></p>
<hr />
<h2 id="i">i</h2>
<p>(Basis Combinator)</p>
<p>Append a quoted expression onto the pending expression.</p>
<pre><code> [Q] i
-----------
Q</code></pre>
<h3 id="source-1">Source</h3>
<pre><code>combo(i, [list(P)|S], S, Ei, Eo) :- append(P, Ei, Eo).</code></pre>
<h3 id="discussion-5">Discussion</h3>
<p>This is probably the fundamental combinator. You wind up using it in all kinds of places (for example, the <code>x</code> combinator can be defined as <code>dup i</code>.)</p>
<hr />
<h2 id="infra">infra</h2>
<p>(Combinator)</p>
<p>Accept a quoted program and a list on the stack and run the program with the list as its stack. Does not affect the stack (below the list.)</p>
<pre><code> ... [a b c] [Q] infra
---------------------------
c b a Q [...] swaack</code></pre>
<h3 id="definition-5">Definition</h3>
<pre><code>swons swaack [i] dip swaack</code></pre>
<h3 id="discussion-6">Discussion</h3>
<p>This is one of the more useful combinators. It allows a quoted expression to serve as a stack for a program, effectively running it in a kind of &#x201C;pocket universe&#x201D;. If the list represents a datastructure then <code>infra</code> lets you work on its internal structure.</p>
<h3 id="crosslinks-4">Crosslinks</h3>
<p><a href="#swaack">swaack</a></p>
<hr />
<h2 id="nullary">nullary</h2>
<p>(Combinator)</p>
<p>Run a quoted program without using any stack values and leave the first item of the result on the stack.</p>
<pre><code> ... [P] nullary
---------------------
... A</code></pre>
<h3 id="definition-6">Definition</h3>
<pre><code>[stack] dip infra first</code></pre>
<h3 id="derivation-1">Derivation</h3>
<pre><code>... [P] nullary
... [P] [stack] dip infra first
... stack [P] infra first
... [...] [P] infra first
... [A ...] first
... A</code></pre>
<h3 id="discussion-7">Discussion</h3>
<p>A very useful function that runs any other quoted function and returns it&#x2019;s first result without disturbing the stack (under the quoted program.)</p>
<h3 id="crosslinks-5">Crosslinks</h3>
<p><a href="#unary">unary</a> <a href="#binary">binary</a> <a href="#ternary">ternary</a></p>
<hr />
<h2 id="ternary">ternary</h2>
<p>(Combinator)</p>
<p>Run a quoted program using exactly three stack values and leave the first item of the result on the stack.</p>
<pre><code> ... z y x [P] unary
-------------------------
... A</code></pre>
<h3 id="definition-7">Definition</h3>
<pre><code>binary popd</code></pre>
<h3 id="discussion-8">Discussion</h3>
<p>Runs any other quoted function and returns its first result while consuming exactly three items from the stack.</p>
<h3 id="crosslinks-6">Crosslinks</h3>
<p><a href="#binary">binary</a> <a href="#nullary">nullary</a> <a href="#unary">unary</a></p>
<hr />
<h2 id="unary">unary</h2>
<p>(Combinator)</p>
<p>Run a quoted program using exactly one stack value and leave the first item of the result on the stack.</p>
<pre><code> ... x [P] unary
---------------------
... A</code></pre>
<h3 id="definition-8">Definition</h3>
<pre><code>nullary popd</code></pre>
<h3 id="discussion-9">Discussion</h3>
<p>Runs any other quoted function and returns its first result while consuming exactly one item from the stack.</p>
<h3 id="crosslinks-7">Crosslinks</h3>
<p><a href="#binary">binary</a> <a href="#nullary">nullary</a> <a href="#ternary">ternary</a></p>
<hr />
<h2 id="uncons">uncons</h2>
<p>(Basis Function)</p>
<p>Removes an item from a list and leaves it on the stack under the rest of the list. You cannot <code>uncons</code> an item from an empty list.</p>
<pre><code> [A ...] uncons
--------------------
A [...]</code></pre>
<h3 id="source-2">Source</h3>
<pre><code>func(uncons, Si, So) :- func(cons, So, Si).</code></pre>
<h3 id="discussion-10">Discussion</h3>
<p>This is the inverse of <code>cons</code>.</p>
<h3 id="crosslinks-8">Crosslinks</h3>
<p><a href="#cons">cons</a></p>
<hr />
<h2 id="x">x</h2>
<p>(Combinator)</p>
<pre><code> [F] x
-----------
[F] F</code></pre>
<h3 id="definition-9">Definition</h3>
<pre><code>dup i</code></pre>
<h3 id="discussion-11">Discussion</h3>
<p>The <code>x</code> combinator &#x2026;</p>
</body>
</html>
implementations/Prolog/docs/reference/Functor-Reference.md
-355
View File
@@ -1,355 +0,0 @@
# Functor Reference
Version -10.0.0
Each function, combinator, or definition should be documented here.
--------------------
## !-
"not negative"
(Function, Boolean Predicate)
Integer on top of stack is replaced by Boolean value indicating whether
it is non-negative.
N !-
----------- N < 0
false
N !-
---------- N >= 0
true
### Definition
0 >=
--------------------
## app1
"apply one"
(Combinator)
Given a quoted program on TOS and anything as the second stack item run
the program without disturbing the stack and replace the two args with
the first result of the program.
... x [Q] app1
---------------------------------
... [x ...] [Q] infra first
### Definition
nullary popd
### Discussion
Just a specialization of `nullary` really. Its parallelizable cousins
are more useful.
--------------------
## b
(Combinator)
Run two quoted programs
[P] [Q] b
---------------
P Q
### Definition
[i] dip i
### Derivation
[P] [Q] b
[P] [Q] [i] dip i
[P] i [Q] i
P [Q] i
P Q
### Discussion
This combinator comes in handy.
### Crosslinks
[dupdip](#dupdip)
[ii](#ii)
--------------------
## binary
(Combinator)
Run a quoted program using exactly two stack values and leave the first
item of the result on the stack.
... y x [P] binary
-----------------------
... A
### Definition
unary popd
### Discussion
Runs any other quoted function and returns its first result while
consuming exactly two items from the stack.
### Crosslinks
[nullary](#nullary)
[ternary](#ternary)
[unary](#unary)
--------------------
## ccons
(Function)
Given two items and a list, append the items to the list to make a new list.
B A [...] ccons
---------------------
[B A ...]
### Definition
cons cons
### Discussion
Does `cons` twice.
### Crosslinks
[cons](#cons)
--------------------
## cons
(Basis Function)
Given an item and a list, append the item to the list to make a new list.
A [...] cons
------------------
[A ...]
### Source
func(cons, [list(A), B|S], [list([B|A])|S]).
### Discussion
Cons is a venerable old function from Lisp. It doesn't inspect the item
but it will not cons onto a non-list. It's inverse operation is called
`uncons`.
### Crosslinks
[ccons](#ccons)
[uncons](#uncons)
--------------------
## i
(Basis Combinator)
Append a quoted expression onto the pending expression.
[Q] i
-----------
Q
### Source
combo(i, [list(P)|S], S, Ei, Eo) :- append(P, Ei, Eo).
### Discussion
This is probably the fundamental combinator. You wind up using it in all
kinds of places (for example, the `x` combinator can be defined as `dup i`.)
--------------------
## infra
(Combinator)
Accept a quoted program and a list on the stack and run the program with
the list as its stack. Does not affect the stack (below the list.)
... [a b c] [Q] infra
---------------------------
c b a Q [...] swaack
### Definition
swons swaack [i] dip swaack
### Discussion
This is one of the more useful combinators. It allows a quoted
expression to serve as a stack for a program, effectively running it in a
kind of "pocket universe". If the list represents a datastructure then
`infra` lets you work on its internal structure.
### Crosslinks
[swaack](#swaack)
--------------------
## nullary
(Combinator)
Run a quoted program without using any stack values and leave the first item of the result on the stack.
... [P] nullary
---------------------
... A
### Definition
[stack] dip infra first
### Derivation
... [P] nullary
... [P] [stack] dip infra first
... stack [P] infra first
... [...] [P] infra first
... [A ...] first
... A
### Discussion
A very useful function that runs any other quoted function and returns
it's first result without disturbing the stack (under the quoted
program.)
### Crosslinks
[unary](#unary)
[binary](#binary)
[ternary](#ternary)
--------------------
## ternary
(Combinator)
Run a quoted program using exactly three stack values and leave the first
item of the result on the stack.
... z y x [P] unary
-------------------------
... A
### Definition
binary popd
### Discussion
Runs any other quoted function and returns its first result while
consuming exactly three items from the stack.
### Crosslinks
[binary](#binary)
[nullary](#nullary)
[unary](#unary)
--------------------
## unary
(Combinator)
Run a quoted program using exactly one stack value and leave the first item of the result on the stack.
... x [P] unary
---------------------
... A
### Definition
nullary popd
### Discussion
Runs any other quoted function and returns its first result while
consuming exactly one item from the stack.
### Crosslinks
[binary](#binary)
[nullary](#nullary)
[ternary](#ternary)
--------------------
## uncons
(Basis Function)
Removes an item from a list and leaves it on the stack under the rest of
the list. You cannot `uncons` an item from an empty list.
[A ...] uncons
--------------------
A [...]
### Source
func(uncons, Si, So) :- func(cons, So, Si).
### Discussion
This is the inverse of `cons`.
### Crosslinks
[cons](#cons)
--------------------
## x
(Combinator)
[F] x
-----------
[F] F
### Definition
dup i
### Discussion
The `x` combinator ...
implementations/Prolog/docs/reference/Makefile
-3
View File
@@ -1,3 +0,0 @@
all:
pandoc -s --toc --toc-depth=2 --ascii Functor-Reference.md -o FuncRef.html
implementations/Prolog/docs/reference/app1.md
-26
View File
@@ -1,26 +0,0 @@
--------------------
## app1
"apply one"
(Combinator)
Given a quoted program on TOS and anything as the second stack item run
the program without disturbing the stack and replace the two args with
the first result of the program.
... x [Q] app1
---------------------------------
... [x ...] [Q] infra first
### Definition
nullary popd
### Discussion
Just a specialization of `nullary` really. Its parallelizable cousins
are more useful.
implementations/Prolog/docs/reference/b.md
-33
View File
@@ -1,33 +0,0 @@
--------------------
## b
(Combinator)
Run two quoted programs
[P] [Q] b
---------------
P Q
### Definition
[i] dip i
### Derivation
[P] [Q] b
[P] [Q] [i] dip i
[P] i [Q] i
P [Q] i
P Q
### Discussion
This combinator comes in handy.
### Crosslinks
[dupdip](#dupdip)
[ii](#ii)
implementations/Prolog/docs/reference/binary.md
-28
View File
@@ -1,28 +0,0 @@
--------------------
## binary
(Combinator)
Run a quoted program using exactly two stack values and leave the first
item of the result on the stack.
... y x [P] binary
-----------------------
... A
### Definition
unary popd
### Discussion
Runs any other quoted function and returns its first result while
consuming exactly two items from the stack.
### Crosslinks
[nullary](#nullary)
[ternary](#ternary)
[unary](#unary)
implementations/Prolog/docs/reference/bleah.txt
-20
View File
@@ -1,20 +0,0 @@
The problem is twofold:
1.) Programming is very young, and has been in a growth phase since it's inception. I forget the exact numbers, but *half* of *all* programmers have been doing it for less than *five years*, and that has been true for many decades.
Because there has been no "shakedown" phase (a "correction" in financial jargon), and because the influx of newbies ("Eternal September") has washed out any attempts at *better* programming ("Mother of All Demos", Nelson's "Dream Machine", etc., on the one hand and e.g. Ada on the other, all of it pretty much ignored in the mainstream machines and software available today. How many people have heard of Jef Raskin, let alone read "Humane Interface"? etc...) because of these things we should not expect programming to be at the level of engineering. We are in the Alchemy phase, not Chemistry.
2.) Choice of notation. Without going into a long rant, our fundamental mathematical tools for programming are grotesque. (It would be shocking if the first thing out of the primordial ooze was the perfect programming notation, eh? In point of fact we have Turing Machines, Lambda Calculus, and what was the other one? Anyway, they're clunky.)
For binary Boolean circuits the notation in "Laws of Form" by George Spencer-Brown is the most elegant and parsimonious:
AA == A
((A)) == A
A(AB) == A(B)
That is a complete system of binary Boolean logic that is more efficient than other notations. (For instance, de Morgan's law doesn't apply: you can convert a formula into it's dual, reduce, and recover the original formula. (Ergo, conventional notation has (non-useful) redundancy.))
For orchestrating binary Boolean logic circuits into what we call "programs" the best notation is something called "Joy". It was invented by a philosopher! It has the best aspects of Lisp and Forth. It handles concurrency in a very simple and tractable way. It delivers on the promise of Backus' FP to enable mathematical *algebraic* derivations of algorithms/programs. Etc...
Anyhow, I'm preparing a demo of Joy, with UI influenced by psycho-ergonomic considerations, that can be compiled down to the logic circuits (and e.g. burned onto an FPGA or whatever.) A new model of computer architecture is implied, using latching sort-nets to allow for dynamic reconfiguration of what amounts to dataflow on the level of the CPU. (No more Von Neumann bottleneck.)
implementations/Prolog/docs/reference/ccons.md
-24
View File
@@ -1,24 +0,0 @@
--------------------
## ccons
(Function)
Given two items and a list, append the items to the list to make a new list.
B A [...] ccons
---------------------
[B A ...]
### Definition
cons cons
### Discussion
Does `cons` twice.
### Crosslinks
[cons](#cons)
implementations/Prolog/docs/reference/cons.md
-27
View File
@@ -1,27 +0,0 @@
--------------------
## cons
(Basis Function)
Given an item and a list, append the item to the list to make a new list.
A [...] cons
------------------
[A ...]
### Source
func(cons, [list(A), B|S], [list([B|A])|S]).
### Discussion
Cons is a venerable old function from Lisp. It doesn't inspect the item
but it will not cons onto a non-list. It's inverse operation is called
`uncons`.
### Crosslinks
[ccons](#ccons)
[uncons](#uncons)
implementations/Prolog/docs/reference/foobar.txt
-98
View File
@@ -1,98 +0,0 @@
Implement modular arithmetic semantics for Joy, or
Implement 'BigNums' for Oberon RISC, or
Implement mod arith in Joy and use that to implement BigNums in mod-Joy,
then partial reduce/eval etc. to get BigNums for RISC?
OR, let division operator make rationals!?
I'm using DCG w/ the lists as machine code, and explicitly passing the
environment around; If I put the machine code into the environment I can
just pass that around and define an asm//n DCG for writing machine code.
Parsing and Compiling Using Prolog
1. Introduction
2. Parsing
2.1 Bottom-Up
2.2 Top-Down
2.3 Recursive Descent
3. Syntax-Directed Translation
4. M-Grammars and DCGs
5. Grammar Properties
6. Lexical Scanners And Parser Generation
7. Code Generation
7.1 Generating Code from Polish
7.2 Generating Code from Trees
7.3 A Machine-Independent Algorithm for Code Generation
7.4 Code Generation from a Labelled Tree
8. Optimizations
8.1 Compile-Time Evaluation
8.2 Peephole Optimization
9. Using Proposed Extension
10. Final Remarks
type Item
= Integer Int
| Symbol String
| Boolean Bool
The Web UI
- Docs for each function
- Crosslinks to other funcs in PatLang style
- "Forge" for creating new funcs
- Type-checking
- Examples
- Docs
- Domain/Applicability
- Mathematical Aspects (Cat Theory)
- Evaluation Contexts
- Stage
- Spreadsheet/Grid
- Factory
- Dataflow
- Hall of Records
- History
- Learning from
- Quoting from
- Changing/Deleting (sometimes you gotta)
- Publishing/Sharing
- Registry of definition/functions
- Money?
https://thenewstack.io/rust-creator-graydon-hoare-recounts-the-history-of-compilers/
I've been working (on and off, for years) on making a system inspired by that book and by Jef Raskin's "Humane Interface", et. el., and I'm convinced that software could be made bug-free and cheaply, however I have no hope of convincing other programmers. Instead, I'm going to take it directly to end users (and not tell them that they are learning to program until they already have, so as not to jinx it.)
Trying to market to other developers would be an uphill battle, but normal people can use it to develop bug-free software easily and with minimal training (it's fun, like playing a video game).
I should have a demo going in a week or two. I'm learning Elm lang right now to make a web UI for it. The original demo UI is in Python 2 and Tkinter, but I've transitioned to an implementation based on Prolog, where inter-op with TCL/Tk would be more trouble than simple putting a web server in front of it (not to go off on a tangent but search for "pengine" if you want to know more about Prolog-over-TCP.)
- - - -
Graydon Hoare has a talk on the history of compilers but he doesn't mention Prolog once. I think it's possible he doesn't know about the research into logic programming and compilers.
"Parsing and Compiling Using Prolog" Jacques Cohen and Tim Hickey
ACM Transactions on Programming Languages and Systems 9(2):125-163 · April 1987
DOI: 10.1145/22719.22946 · Source: DBLP
implementations/Prolog/docs/reference/i.md
-22
View File
@@ -1,22 +0,0 @@
--------------------
## i
(Basis Combinator)
Append a quoted expression onto the pending expression.
[Q] i
-----------
Q
### Source
combo(i, [list(P)|S], S, Ei, Eo) :- append(P, Ei, Eo).
### Discussion
This is probably the fundamental combinator. You wind up using it in all
kinds of places (for example, the `x` combinator can be defined as `dup i`.)
implementations/Prolog/docs/reference/infra.md
-29
View File
@@ -1,29 +0,0 @@
--------------------
## infra
(Combinator)
Accept a quoted program and a list on the stack and run the program with
the list as its stack. Does not affect the stack (below the list.)
... [a b c] [Q] infra
---------------------------
c b a Q [...] swaack
### Definition
swons swaack [i] dip swaack
### Discussion
This is one of the more useful combinators. It allows a quoted
expression to serve as a stack for a program, effectively running it in a
kind of "pocket universe". If the list represents a datastructure then
`infra` lets you work on its internal structure.
### Crosslinks
[swaack](#swaack)
implementations/Prolog/docs/reference/not_negative.md
-24
View File
@@ -1,24 +0,0 @@
--------------------
## !-
"not negative"
(Function, Boolean Predicate)
Integer on top of stack is replaced by Boolean value indicating whether
it is non-negative.
N !-
----------- N < 0
false
N !-
---------- N >= 0
true
### Definition
0 >=
implementations/Prolog/docs/reference/nullary.md
-37
View File
@@ -1,37 +0,0 @@
--------------------
## nullary
(Combinator)
Run a quoted program without using any stack values and leave the first item of the result on the stack.
... [P] nullary
---------------------
... A
### Definition
[stack] dip infra first
### Derivation
... [P] nullary
... [P] [stack] dip infra first
... stack [P] infra first
... [...] [P] infra first
... [A ...] first
... A
### Discussion
A very useful function that runs any other quoted function and returns
it's first result without disturbing the stack (under the quoted
program.)
### Crosslinks
[unary](#unary)
[binary](#binary)
[ternary](#ternary)
implementations/Prolog/docs/reference/ternary.md
-29
View File
@@ -1,29 +0,0 @@
--------------------
## ternary
(Combinator)
Run a quoted program using exactly three stack values and leave the first
item of the result on the stack.
... z y x [P] unary
-------------------------
... A
### Definition
binary popd
### Discussion
Runs any other quoted function and returns its first result while
consuming exactly three items from the stack.
### Crosslinks
[binary](#binary)
[nullary](#nullary)
[unary](#unary)
implementations/Prolog/docs/reference/unary.md
-27
View File
@@ -1,27 +0,0 @@
--------------------
## unary
(Combinator)
Run a quoted program using exactly one stack value and leave the first item of the result on the stack.
... x [P] unary
---------------------
... A
### Definition
nullary popd
### Discussion
Runs any other quoted function and returns its first result while
consuming exactly one item from the stack.
### Crosslinks
[binary](#binary)
[nullary](#nullary)
[ternary](#ternary)
implementations/Prolog/docs/reference/uncons.md
-25
View File
@@ -1,25 +0,0 @@
--------------------
## uncons
(Basis Function)
Removes an item from a list and leaves it on the stack under the rest of
the list. You cannot `uncons` an item from an empty list.
[A ...] uncons
--------------------
A [...]
### Source
func(uncons, Si, So) :- func(cons, So, Si).
### Discussion
This is the inverse of `cons`.
### Crosslinks
[cons](#cons)
implementations/Prolog/docs/reference/x.md
-18
View File
@@ -1,18 +0,0 @@
--------------------
## x
(Combinator)
[F] x
-----------
[F] F
### Definition
dup i
### Discussion
The `x` combinator ...