Search                        Top                                  Index
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

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


 -- 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

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

-- 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

<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

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.

define      Start and end of a                define perim(width,height);
enddefine   procedure definition *DEFINE         return(2*width + 2*height)

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.

date()      A procedure that returns a list      date()=>
            giving the current time and date.    ** [18 Sep 1985 11 47 16]

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.

            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;

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)

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 ...
            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"
            (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 ==])

if          Marks the start of an 'if'           if english == "cat" then
            conditional. *IF                        "chat"=>
then        Ends the condition part of an 'if'
            conditional. *THEN (Also used with

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.

-- 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]

==          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.

add(<list>)                                      add([john loves mary]);
            Puts an item into the database.

remove(<pattern>)                                remove([john loves =]);
            Removes the first item matching
            the pattern from the database.

flush(<pattern>)                                 flush([== loves ==]);
            Removes all items matching the
            pattern from the database.

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;

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;

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).

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;

endwhile    Marks the end of a while loop.

for         Marks the start of a for loop.       for x in [paris london] do
            *FOR                                   [^x is a city]=>
endfor      Marks the end of a for loop.
            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  Marks the end of a 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.

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;



The Pop-11 Primer, by A.Sloman, available online as TEACH PRIMER
and also available in hard copy from the School of Computer Science








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

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

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. ------