TEACH POPCORE Aaron Sloman Sept 2000
This is a modified version of the Sussex local file HELP TPOP, by Mike
Sharples, and is very close to the summary of Pop-11 in the book
Computers and Thought edited by Sharples et al. However, it is more
up to date, and reflects local extensions at Birmingham.
This file lists a powerful subset of the words and constructs of Poplog
Pop-11 which together are sufficient for a great many interesting
programs.
Those items in the left column not enclosed in angle brackets <...> are
Pop-11 reserved words (i.e. they have a special meaning to Pop-11).
Words in angle brackets refer to a syntactic category. A relevant online
help or teach file is indicated by an asterisk, e.g. * MATCHES.
To read the file in VED place the cursor on the asterisk and type
ESC h or else do "ENTER help matches"
Sometimes the TEACH command will produce a different file,
e.g. ENTER teach matches
CONTENTS
-- Basic data types
-- Comments
-- Variable declarations
-- Miscellaneous
-- Printing facilities
-- Assignments
-- Inserting values in lists and vectors using ("^" and "^^")
-- Defining procedures
-- Miscellaneous 2
-- Arithmetic operators
-- Logical connectives
-- Variable formats for the matcher
-- Looping expressions
-- Arrays
-- Tracing utilities
-- FURTHER READING
ITEM DESCRIPTION AND HELP FILE EXAMPLE
---- ------------------------- -------
-- Basic data types
<Word> A letter followed by a series of "cat"
letters or digits (including the "a_long_word"
underscore). It may also be "M1"
a series of signs such as $ "#$#$#$#"
A word is put in double quotes,
except within a list or vector
expression. *WORDS
<String> Can contain arbitrary characters. 'A funny %$%### string'
Constructed using single quotes.
Can contain "special" characters, E.g.
\n (newline), \t (tab) *STRINGS '\ta tab\nand a newline'
<Number> One or more digits, with an 55
optional decimal point. *NUMBERS 3.14159
4.25e10
<List> A series of text items, such as [a b c d]
words, numbers, other lists, or [1 Acacia Avenue]
strings, within square brackets. ['a string' 33 cat]
*LISTS [[CAT CHAT][DOG CHIEN]]
[% ... %] Decorated list brackets can be [% for x from 1 to 5 do
used with enclosed Pop-11 commands x
to make a list. *PERCENT endfor %] =>
** [1 2 3 4 5]
<vector> Like a list, but cannot be extended {a four word vector}
and takes up less space.
{% ... %} Like decorated list brackets can {% 3+3, 99*9 %} =>
contain Pop-11 commands. ** {6 891}
<record> A kind of structure with a specific recordclass triple
number of components and particular first second third;
procedures for accessing and constriple(1, 2, 3) =>
updating them, etc. *RECORDCLASS ** <triple 1 2 3>
(Or see *defclass)
-- Comments
;;; Begins a comment (text that will ;;; This is a comment.
be ignored by Pop-11). The comment
ends at the end of the line. *COMMENT
/* ... */ An alternative form of comment. /* comments can go
over several lines */
-- Variable declarations
vars Used to declare local or global vars x, y, z;
non-lexical variables. *VARS vars num = 10;
(Don't use vars for local
variables except in a <pattern>).
lvars Used to declare local or global lvars x, y, z;
lexical variables *LVARS lvars num = 99;
-- Miscellaneous
; Semi colon terminates commands. vars a; 100 -> a;
I.e. separates imperatives. It is
a separator.
<undef> A type of object that is the vars xxx;
default value for a variable that xxx=>
has been declared, but not had a ** <undef xxx>
value assigned to it.
REF * IDENT/'Undef Records'
undef This special constant refers to an undef =>
item which is often used as the ** undef
default value for components of a
new structure (e.g. an <array>).
-- Printing facilities
=> Print arrow. *PRINTARROW 3 + 4 =>
** 7
==> Pretty print arrow (prints a long
list or vector tidily). *PRINTARROW
pr Prints an item (word, string, list, pr(list);
vector, etc. without "**" or newline. pr('The cat');
ppr Like pr, but (a) prints lists minus ppr([[the][cat]]);
any list brackets, and (b) prints a the cat
space after each item. *PPR
spr Like pr, but prints a following space spr("a");spr("b");
*SPR a b
npr Like pr, but prints a newline after npr("a");npr("b");
each item. * NPR, *PRINTING a
b
printf For more sophisticated printing see printf(
*PRINTF '%p plus %p gives %p',
[2 3 5]);
2 plus 3 gives 5
-- Assignments
-> Assignment arrow. Assigns a value vars a;
to a variable. TEACH * STACK 100 -> a;
Also invokes updaters, and is used 33 -> hd(list);
in defining procedures with output
locals. See below. Compare: vars a = 100;
->> Like assignment arrow, but first hd(x) ->> a -> b;
duplicates object on stack, so that
e.g. it can be assigned twice.
-- Inserting values in lists and vectors using ("^" and "^^")
^ Includes the value of an expression vars animal = "cat";
in a list or vector expression. [the ^animal sat]=>
*ARROW ** [the cat sat]
^^ Includes the elements of a list vars beasts = [cat pig];
inside another list. *ARROW [the ^^beasts sat] =>
** [the cat pig sat]
^ ^^ NOTE: these also work for vectors
-- Defining procedures
<Procedure> A 'package' of Pop-11 commands, hd, sqrt, maplist,
usually with a name. May have an *, -, subscr, etc.
updater *PROCEDURES*DEFINE are all built-in
Some procedures are built-in some procedures.
user-defined.
define Start and end of a define perim(width,height);
enddefine procedure definition *DEFINE return(2*width + 2*height)
enddefine;
return Terminates execution of the define first_and_last(list);
current procedure, and returns return(hd(list),
to whatever invoked it. last(list))
Analogous to "goto enddefine". enddefine;
Items in brackets after return
are left on the stack. *RETURN
-> Indicates an 'output local' in define perim2(w,h)->result;
a procedure header line. An 2*w + 2*h -> result;
alternative to 'return' as a enddefine;
way of specifying the result of
a procedure call. *DEFINE, *STACK-- Miscellaneous 2
readline() A Pop-11 procedure that prints a ? readline() -> input_words;
and then waits for input from the
terminal. Any words, numbers or
strings typed on the line after
the ? are returned in a list.
*READLINE
date() A procedure that returns a list date()=>
giving the current time and date. ** [18 Sep 1985 11 47 16]
*DATE
length(<item>) length([the cat sat])=>
A procedure that returns the ** 3
length of an item. *LENGTH length("iguana")=>
The length of a item is the number ** 6
of components it contains.
<Subscript>
An element can be picked from a vars sentence animal;
list by giving its position in [the cat sat] -> sentence;
brackets after the name sentence(2) -> animal;
*LISTSUMMARY
oneof(<list>) vars throw =
Returns an element picked at random oneof([1 2 3 4 5 6]);
from a list. *ONEOF-- Arithmetic operators
+ Adds one number to another. width+height->half_perim;
* Multiplies two numbers. 3.14159*d -> circum;
/ Divides one number by another. total/items->average;
Warning: dividing one integer by
another can give a "ratio" which 10/5, 3/4 =>
may print as, e.g. 3_/4 ** 2 3_/4
abs When applied to a positive or abs(-10) =>
negative number returns its ** 10
absolute value (always positive)
*ABS
pop_pr_ratios false -> pop_pr_ratios;
This Pop-11 variable controls how
ratios are printed. If made false 10/5, 3/4 =>
it makes ratios print as decimals. ** 2 0.75
// Divides one integer by another to 10//3
get dividend and remainder, -> (remainder,dividend);
** Raises one number to the power of 2**3 =>
another. ** 8
> Compares two numbers. The result is if x > 3 then .... endif
true if the first is greater.
>= Compares two numbers. The result is
true if the first is greater or equal.
< Compares two numbers. The result is 4 < 3 =>
true if the first is smaller. ** <false>
<= Compares two numbers. The result is
true if the first is smaller than or
equal to the second.
( ) Round brackets have two uses. They (3+2)*4 =>
can alter the order of evaluation in ** 20
expressions, or following a variable perim(45,23) =>
or expression they can signify ** 136
procedure invocation. Any arguments
to the procedure go in the brackets.
true These are constants which hold the true =>
false two special boolean values <true> ** <true>
and <false> used in conditionals false =>
and loop termination tests. *BOOLEAN** <false>
= Tests whether two items are equal if a = 100 then ...
*EQUAL
It can also be used to initalise vars x = [1 2 3];
a variable;
== Tests whether items are identical if a == [cat] then ...
/= Tests whether two items are unequal. a /= b
(Looks inside structures) * EQUAL
/== Tests whether two items are not a /== "cat"
identical.
(Does not look inside structures)
-- Logical connectives
(E.g. for use in conditionals)
and Forms the 'conjunction' of two if x > 0 and x < 100 then
boolean expressions. *AND
or Forms the 'disjunction' of two word="cat" or word="puss"
boolean expressions. *OR
not Negates a boolean expression. not(list matches [== cat ==])
*NOT
if Marks the start of an 'if' if english == "cat" then
conditional. *IF "chat"=>
endif;
then Ends the condition part of an 'if'
conditional. *THEN (Also used with
"unless")
elseif Begins a second (or subsequent) if english == "cat" then
condition in an 'if' statement. "chat" =>
*ELSEIF elseif english == "dog" then
"chien" =>
else Marks the beginning of the else
"default" course of action in [I dont know] =>
a conditional. *ELSE endif;
endif Marks the end of a conditional.
*ENDIF-- Variable formats for the matcher
matches Compares a list with a pattern. vars sentence;
It returns true if they match, [the cat sat] -> sentence;
false otherwise. It will also sentence matches [= cat =] =>
"bind" variables in the pattern, ** <true>
if there are any. *MATCHES
= Matches one item inside a list mylist matches [= cat sat]
pattern.
== Matches zero or more items inside mylist matches [== cat ==]
a pattern.
?<variable> Matches one item inside a list mylist matches [?first ==]
pattern and makes that the value
of the variable. *MATCHES
??<variable> alist matches
Matches zero or more items within [?first ??rest] =>
a list pattern and makes the list
of matched items the value of the ** <true>
variable. *MATCHES
! Use in front of a pattern to make mylist matches
the variables lvars ![?first ??rest] =>
database A Pop-11 variable whose value is database ==>
the database, a list of lists,
used with add, remove, present, etc.
*DATABASE
add(<list>) add([john loves mary]);
Puts an item into the database.
*ADD
remove(<pattern>) remove([john loves =]);
Removes the first item matching
the pattern from the database.
*REMOVE
flush(<pattern>) flush([== loves ==]);
Removes all items matching the
pattern from the database.
*FLUSH
present(<pattern>) if present([?x loves mary])
Searches the database for an then
item matching the database and x=>
returns true if it is found, endif;
false otherwise. Binds variables
in the pattern. *PRESENT
allpresent(<list of patterns>) if allpresent(
Searches the database for items [[?x loves ?y]
that consistently match all the [?y loves ?z]])
patterns, and returns true if then
this succeeds and false otherwise [Triangle ^x ^y ^z] =>
Binds variables in the pattern. endif;
*ALLPRESENT
it A variable that is set by 'add', if present([?x loves mary])
'remove', 'present' and 'foreach'. then
Its value is the last item found it=>
in the database. *IT endif;
-- Looping expressions
repeat Marks the start of a repeat loop. repeat
*REPEAT readline()->line;
quitif(line /== []);
endrepeat Marks the end of a repeat loop. endrepeat;
*ENDREPEAT
times Indicates the number of times a repeat 4 times;
repeat loop is to be repeated (If "."=>
it is omitted then looping is endrepeat;
forever, unless halted by quitif).
*TIMES
quitif(<expression>) vars n = 2;
If the expression is true then repeat;
quit the loop. This example and quitif(n > 1000);
the one using the while loop n =>
below are equivalent (ie they n*n -> n;
give the same result). *QUITIF endrepeat;
while Marks the start of a while loop. vars n = 2;
*WHILE while n <= 1000 do
n =>
do Ends the condition part of a n*n -> n;
'while', 'for', or 'foreach' loop. endwhile;
*DO
endwhile Marks the end of a while loop.
*ENDWHILE
for Marks the start of a for loop. for x in [paris london] do
*FOR [^x is a city]=>
endfor;
endfor Marks the end of a for loop.
*ENDFOR
Note: there are many different forms
of for ... endfor loops.
See *LOOPS, *FOR.
foreach Marks the start of a foreach loop, vars x y;
which matches a pattern against foreach [?x loves ?y] do
each item in the database. *FOREACH it=>
endforeach;
endforeach Marks the end of a foreach.
*FOREACH
forevery Like foreach, but takes a list of forevery
patterns and tries all possible [[?x ison ?y]
ways of matching them all [?y ison ?z]]
consistently with items in the do
database. *FOREVERY them =>
[^x is above ^z] =>
endforevery Syntax word used at the end of endforevery;
a "foreach" loop.
-- Arrays
<array> A compound data object with N dimensions
whose components can be accessed or
updated using N numerical subscripts.
*ARRAYS
newarray The simplest procedure to create a vars ten_by_seven =
Pop-11 array. * NEWARRAY newarray(
[1 10 -3 3]);
boundslist When applied to an array returns a boundslist(
list containing for each dimension ten_by_seven) =>
the upper and lower bounds. ** [1 10 -3 3]
-- Tracing utilities
trace <names of procedures> trace add first_and_last;
A command that alters procedures so
they print out helpful information.
(NB. You can trace built-in
procedures like 'hd' and 'tl'). *TRACE
untrace <names of procedures> untrace add first_and_last;
A command that switches off tracing
of the named procedures. *TRACE
untraceall Switches off any traces.*UNTRACEALL untraceall;
See also *INSPECT and *DEBUGGER-- FURTHER READING
See:
The Pop-11 Primer, by A.Sloman, available online as TEACH PRIMER
and also available in hard copy from the School of Computer Science
Library.
TEACH * FACES, * GSTART, * USEFULKEYS
TEACH *LISTS, *LISTSUMMARY,
TEACH *BOXES*POPSUMMARY, *DEFINE, *STACK, *VARS
TEACH * DATABASE, * FOREACH
HELP * WORDS, *LISTS, *MATH, *LOOPS, *CONTROL, *ARRAYS, *STRINGS
HELP * MATCHES, *PRINT, *TRACE, *RECURSION
TEACH * RECURSION, * SETS, * SETS2, * FUNCTIONAL.STYLE
M. Sharples, et al.
Computers and Thought,
MIT Press, 1989
(This is an introduction to cognitive science using Pop-11
programming examples as illustrations.)
James Anderson(ed)
Pop-11 Comes of Age
Ellis Horwood, 1989
A collection of papers on the history of dialects of Pop, the
features and benefits of the language, and some applications using
Pop-11.
Chris Thornton & Benedict du Boulay (1992)
Artificial Intelligence Through Search
Kluwer Academic (Paperback version Intellect Books)
(An introduction to AI using Pop-11 and Prolog. A good
way to learn Prolog if you know Pop-11 or vice versa.)
WARNING: books published before 1995 are likely to have out of
date information about Pop-11, though the core ideas are unchanged.
In the Poplog system there is a large collection of REF files
giving definitive information about Pop-11. These files are mostly
useful for experts, but occasionally you'll find that information you
need is available nowhere else.
The pop-forum email list and comp.lang.pop internet news group are also
useful sources of information. There is a lot of pop-11 material
available by ftp from the Birmingham Poplog directory
http://www.cs.bham.ac.uk/research/poplog/freepoplog.html
There is a version of Poplog (including Pop-11) for a PC running linux.
--- $poplocal/local/teach/popcore
--- Copyright University of Birmingham 2000. All rights reserved. ------