home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Power-Programmierung
/
CD1.mdf
/
snobol
/
aisnobol
/
report2.doc
< prev
next >
Wrap
Text File
|
1987-10-18
|
148KB
|
5,677 lines
APPENDIX F
This is an alphabetical listing of all the SNOLISPIST
functions, with detailed descriptions, examples, and references.
Core functions are marked with an asterisk (*).
The following abbreviations are used to indicate the datatype
of arguments to the functions:
S 'STRING'
L 'CONS' (i.e., list)
N 'NUMERIC' ('REAL', 'DREAL', or 'INTEGER')
NAME 'NAME'
A 'ARRAY'
X any
+-----------------------------+
| ABS(N) |
+-----------------------------+
Returns -N if N is negative; otherwise N.
General Categories: Arithmetic function
Example: ABS( -9.345567) returns 9.345567
Comments: N may be integer, real, or double precision. String
to numeric conversion, if necessary, is handled
automatically.
References:
Charniak et al. (1980), 301.
MTS LISP Manual, 26.
Shapiro (1979), 148.
AI Programming in SNOBOL4 - 87 - August, 1982
+-----------------------------+
| ACOS(N) |
+-----------------------------+
Returns the inverse cosine of N, -1 <= N <= 1. The result is
in radians.
General Categories: Arithmetic function
Example: ACOS(-DIV(1,6)) returns 1.7382444060158.
References:
Gimpel (1976), 336.
+-----------------------------+
| ADD(N1,N2) |
+-----------------------------+
Returns N1 + N2.
General Categories: Arithmetic function
Example: ADD(3.7,19.4) returns 23.1.
Comments: Any combination of numeric datatypes is legal.
"Mixed mode" errors are not a problem. Note that ADD is
strictly binary. See PLUS for a similar function which
takes a list argument.
References:
MTS LISP Manual, 26.
AI Programming in SNOBOL4 - 88 - August, 1982
+-----------------------------+
| ADD1(N) |
+-----------------------------+
Returns N + 1.
General Categories: Arithmetic function
Example: ADD1(17) returns 18.
Comments: The value of the argument N is not changed.
References:
Charniak et al. (1980), 301.
MTS LISP Manual, 26.
Shapiro (1979), 148.
+-----------------------------+
| ADDPROP(NAME,X,S) |
+-----------------------------+
Returns the (entire) altered property list of NAME.
General Categories: List composition
List search
Property-list function
Side Effects: May alter the property list of NAME.
Example: ADDPROP( .DOG, 4, 'LEGS') will search the property
list of .DOG for the indicator 'LEGS'. If 'LEGS' is not
found, then ('LEGS' ~ 4 ~ NIL) will be CONSed onto the
property list. If 'LEGS' is found, then its associated list
of values is searched for 4. If 4 is found, nothing
happens. Otherwise, 4 is added to the list of values (all
the other values remain).
If X is NIL, and if S is already an indicator on the
property list, then nothing changes. If X is NIL and S is
not an indicator, then (S ~ NIL) is added to the property
list.
References:
Charniak et al. (1980), 302.
MTS LISP Manual, 25.
AI Programming in SNOBOL4 - 89 - August, 1982
+-----------------------------+
| APPEND(L) |
+-----------------------------+
Returns a list consisting of the top-level elements of CAR(L),
followed by the top-level elements of CADR(L), followed by
the top-level elements of CADDR(L), etc.
General Categories: List composition
Example: Suppose L1 = #'(A B)',
L2 = #'(C D E)', and
L3 = #'"(F G (H I))'.
Then APPEND(L1 ~ L2 ~ L3 ~ NIL) returns
('A' ~ 'B' ~ 'C' ~ 'D' ~ 'E' ~ 'F' ~ 'G' ~ ('H' ~
'I' ~ NIL) ~ NIL).
Comments: APPEND takes one argument, which must be a list of
lists, ending with NIL.
References: Charniak et al. (1980), 302.
MTS LISP Manual, 20 (CONC, not APPEND!).
Schank & Riesbeck (1981), 54.
Shapiro (1979), 148.
+-----------------------------+
| ASIN(N) |
+-----------------------------+
Returns the inverse sine of N, -1 <= N <= 1. The result is in
radians.
General Categories: Arithmetic function
Example: ASIN(DIV(1,SQRT(2)) returns 0.78539816339773.
References: Gimpel (1976), 334.
AI Programming in SNOBOL4 - 90 - August, 1982
+-----------------------------+
| ASSOC(X,L) |
+-----------------------------+
Returns the tail of L, beginning with the first top-level
element whose CAR is EQUAL to X. If no such element of L is
found, ASSOC returns NIL.
General Categories: List decomposition
List search
Example: Suppose L = #'((1 A) (2 B) (3 C) (4 D))'.
Then ASSOC(3,L) returns #'((3 C) (4 D))'.
Comments: Note that EQUAL is used, not EQU.
References: Charniak et al. (1980), 302.
MTS LISP Manual, 19.
Schank & Riesbeck (1981), 55.
Shapiro (1979), 149.
+-----------------------------+
| ASSOCL(L1,L2) |
+-----------------------------+
Returns the tail of L2, beginning with the first element whose
CAR is a MEMBER of L1. If no element of L1 produces a match
in L2, ASSOCL returns NIL.
General Categories: List decomposition
List search
Example: Suppose L1 = #'(9 3 4 1 2)' and
L2 = #'((1 A) (2 B) (3 C) (4 D))'.
Then ASSOCL(L1,L2) returns all of L2.
AI Programming in SNOBOL4 - 91 - August, 1982
+-----------------------------+
| ATAN(N) |
+-----------------------------+
Returns the inverse tangent of N. The result is in radians.
General Categories: Arithmetic function
Example: ATAN(2) returns 1.1071487177935.
References: Gimpel (1976), 334.
+-----------------------------+
| *ATOM(X) |
+-----------------------------+
Returns the null string. It succeeds if X does not have the
datatype 'CONS', and fails otherwise.
General Categories: Predicate
Example: ATOM('A' ~ 17 ~ NIL) fails.
Comments: ATOM succeeds for all built-in SPITBOL datatypes, as
well as for all programmer-defined datatypes except 'CONS'.
References: Charniak et al. (1980), 302.
MTS LISP Manual, 17.
Schank & Riesbeck (1981), 55.
Shapiro (1979), 149.
+-----------------------------+
| ATOMP(X) |
+-----------------------------+
Returns T if X does not have the datatype 'CONS', and NIL
otherwise.
General Categories: Predicate
Example: ATOMP("A17NIL') returns T.
Comments: See ATOM.
References: See ATOM.
AI Programming in SNOBOL4 - 92 - August, 1982
+-----------------------------+
| CAL(A) |
+-----------------------------+
Returns a list of the elements of the array A. The array must
be one-dimensional.
General Categories: List composition
Example: If A<1> = 1, A<2> = "2", A<3> = "THREE", A<4> =
"four", and A<5> = 5, then CAL(A) returns
(1 ~ "2" ~ "THREE" ~ "four" ~ 5 ~ NIL).
+-----------------------------+
| *CAR(L) |
+-----------------------------+
Returns the first top-level element of the list L. It can also
be used on the left-hand side of an assignment statement to
change the CAR of L (cf. RPLACA).
General Categories: Alters existing CONS cell(s)
List composition
List decomposition
Side Effects: If used on the left-hand side of an assignment
statement, CAR can have bad side-effects, e.g., creating
circular lists: CAR(L) = L. Any function which alters
existing CONS cells can cause similar problems. Such
functions can also cause unintended changes in the values of
identifiers which are not referenced directly in the
assignment statement. These functions should be used
carefully (see references).
Example: If L = #'((8 A B) (10807 W) (60) (T (H)))', then
CAR(L) = (8 ~ 'A' ~ 'B' ~ NIL).
Comments: Note that CAR(L) = X has a different effect in
SNOLISPIST than (SET (CAR L) X) would have in LISP.
References: Charniak et al. (1980), 9, 10, 19-21, 302.
MTS LISP Manual, 12-14, 18-19, 22-23.
Schank & Riesbeck (1981), 55.
Shapiro (1979), 149-150.
AI Programming in SNOBOL4 - 93 - August, 1982
+-----------------------------+
| *CDR(L) |
+-----------------------------+
Returns the tail of L, i.e., L with its first top-level element
deleted. CDR can also be used on the left- hand side of an
assignment statement: CDR(L) = X has the same effect as
RPLACD(L,X). (See CAR.)
General Categories: Alters existing CONS cell(s)
List composition
List decomposition
Side Effects: See CAR.
Example: If L = ('P' ~ 'Q' ~ NIL), then CDR(L) returns ('Q' ~
NIL). Note that if L is a "normal" list, then CDR always
returns a list, not an atom.
Comments: See CAR.
References: See CAR.
+-----------------------------+
| CAAR(L) through CDDDDR(L) |
+-----------------------------+
Return the result of the composition of from two to four CARs
and CDRs. All combinations of two to four A's and D's are
legal. CADR(L) returns CAR(CDR(L)), CADAR(L) returns
CAR(CDR(CAR(L))), and so on.
General Categories: List decomposition
Example: If L = #'(A (B C D) 5 4 ((3 (2 1))))', then CADR(L)
returns ('B' ~ 'C' ~ 'D' ~ NIL).
References: Charniak et al. (1980), 19-23, 302.
MTS LISP Manual, 19.
Schank & Riesbeck (1981), 45-49, 55.
Shapiro (1979), 149-150.
AI Programming in SNOBOL4 - 94 - August, 1982
+-----------------------------+
| CEIL(N) |
+-----------------------------+
Returns the smallest integer not smaller than N. N may be any
integer or floating point number.
General Categories: Arithmetic function
Example: CEIL(8.8) returns 9.
References: Gimpel (1976), 327.
+-----------------------------+
| CLA(L) |
+-----------------------------+
Returns the elements of the list L converted to a one-
dimensional array.
General categories: Datatype conversion
Example: If L = ('E' ~ 'D' ~ 'C' ~ 'B' ~ 'A' ~ NIL), then
CLA(L) returns an array of five elements: 'E', 'D', 'C',
'B', and 'A'.
+-----------------------------+
| CLOG(N) |
+-----------------------------+
Returns log(N) (base 10). N may be any positive integer or
floating point number.
General Categories: Arithmetic function
Example: CLOG(97) returns 1.9867717387128.
References: Gimpel (1976), 335-336.
AI Programming in SNOBOL4 - 95 - August, 1982
+-----------------------------+
| *CONCAT(L,S1,S2) |
+-----------------------------+
Returns a single string consisting of the concatenation of the
elements of L. S1, if present, will be inserted after each
element except the last. (S1 might be a blank or a comma.)
S2, if present, will be placed before and after each
element. (S2 might be a quotation mark.)
General Categories: Datatype conversion
Example: Let L = 'PAY' ~ 'YOUR' ~ 'DUES' ~ NIL. CONCAT(L,'
','"') will return '"PAY" "YOUR" "DUES"' as a single string.
(The double quotes are part of the string.)
Comments: This function was originally written as a utility
function for UNREAD. It has also proved useful in the
construction of expressions at run-time.
+-----------------------------+
| *CONS(X,Y) |
+-----------------------------+
Returns a new CONS cell c such that CAR(c) = X and
CDR(c) = Y.
General Categories: List composition
Example: CONS('A',CONS('B',CONS('C',NIL))) returns the list
('A' ~ 'B' ~ 'C' ~ NIL).
References: Charniak et al.(1980), 11, 19, 22-24, 302-303.
MTS LISP Manual, 12-14, 20.
Schank & Riesbeck (1981), 55.
Shapiro (1979), 150.
AI Programming in SNOBOL4 - 96 - August, 1982
+-----------------------------+
| COS(N) |
+-----------------------------+
Returns the cosine of N radians. N may be any integer or
floating point number.
General Categories: Arithmetic function
Example: COS(-P...I. / 6) returns 0.86602540378456.
References: Gimpel (1976), 332-333.
+-----------------------------+
| DEFPROP(NAME,X,S) |
+-----------------------------+
Returns the modified property list of NAME.
General Categories: Alters existing CONS cell(s)
Property-list function
Side Effects: X is put on the property list of NAME under the
indicator S. DEFPROP operates in a manner similar to PUT:
Previous values of the indicator S are erased.
If X is NIL, then S is placed on the property list as an
indicator with no associated values.
Example: DEFPROP( .DOG, 4, 'LEGS') makes sure that
('LEGS' ~ 4 ~ NIL) is on the property list of DOG.
References: Shapiro (1979), 150.
+-----------------------------+
| DEG(N) |
+-----------------------------+
Returns the number of degrees in N radians.
General Categories: Arithmetic function
Example: DEG(P...I. / 4) returns 45.000000000013.
AI Programming in SNOBOL4 - 97 - August, 1982
+-----------------------------+
| DFLOAT(N) |
+-----------------------------+
Returns N converted to datatype 'DREAL', if possible; otherwise
it fails.
General Categories: Arithmetic function
Datatype conversion
Example: DFLOAT(8) returns 8.D00, a 7-byte floating-point
number.
Comments: SPITBOL supports double precision floating- point
numbers, an extension of SNOBOL4.
+-----------------------------+
| DIFFERENCE(L) |
+-----------------------------+
Returns the first element of L minus the sum of the rest.
General Categories: Arithmetic function
Example: DIFFERENCE(3 ~ 4 ~ 5 ~ 6 ~ -12 ~ NIL) returns 0, since
3 - 4 - 5 - 6 - (-12) = 0.
Comments: The argument to DIFFERENCE must be a list of numbers;
the list must end with NIL. Cf. SUB, which is strictly
binary.
References: Charniak et al. (1980), 303.
Schank & Riesbeck (1981), 55-56.
Shapiro (1979), 150.
+-----------------------------+
| DIV(N1,N2) |
+-----------------------------+
Returns N1 / N2 in double precision.
General Categories: Arithmetic function
Example: DIV(7,8) returns .875.
Comments: Datatype conversion (to DREAL) is handled
automatically, so that DIV(7,8) is .875, not 0.
References: MTS LISP Manual, 26.
AI Programming in SNOBOL4 - 98 - August, 1982
+-----------------------------+
| EQP(X,Y) |
+-----------------------------+
Returns T if EQU(X,Y) succeeds; NIL otherwise.
General Categories: Predicate
Example: See EQU.
Comments: See EQU.
References: See EQU.
+-----------------------------+
| EQU(X,Y) |
+-----------------------------+
Returns the null string. It succeeds if X and Y are equal
numbers (as judged by the SPITBOL EQ function), or if they
are lexically equal strings (as judged by the SPITBOL LEQ
function), or if they are identical (as judged by the
SPITBOL IDENT function); fails otherwise.
General Categories: Predicate
Examples: All these succeed: EQU(8,'8'), EQU('8',8.0),
EQU('A',CAR('A' ~ NIL)), EQU('CAT',REVERSE('TAC')),
EQU(NIL,CDDR('S' ~ 'F' ~ NIL)).
Comments: This predicate is similar to the LISP EQ predicate
(EQ is a built-in numeric predicate in SPITBOL; hence the
name-change). Cf. EQP, EQUAL, and EQUALP.
References.: Charniak et al. (1980), 304.
MTS LISP Manual, 17.
Shapiro (1979), 151.
AI Programming in SNOBOL4 - 99 - August, 1982
+-----------------------------+
| EQUAL(X,Y) |
+-----------------------------+
Returns the null string. It succeeds if EQU(X,Y) succeeds, or
if X and Y are lists which would PRINT as lexically equal
(LEQ) strings; otherwise, it fails.
General Categories: Predicate
Example: See EQU. In addition, the following succeeds, while
the analogous EQU expression would fail:
EQUAL(7 ~ 8 ~ NIL, 7 ~ 8 ~ NIL).
Comments: EQU and EQUAL behave identically except when their
arguments are programmer-defined datatypes, such as 'CONS'.
EQU can succeed, given two list-valued arguments, if the two
happen to point to precisely the same list. In general,
however, they won't, even if their respective values look
exactly the same. This is because SPITBOL, like LISP, will
not store duplicate copies of identical strings, but will
store duplicate copies of identical-looking lists.
References: Charniak et al. (1980), 23-24, 304.
MTS LISP Manual, 17.
Schank & Riesbeck (1981), 56.
Shapiro (1979), 151.
+-----------------------------+
| EQUALP(X,Y) |
+-----------------------------+
Returns T if EQUAL(X,Y) succeeds; NIL otherwise.
General Categories: Predicate
Example: See EQUAL.
Comments: See EQUAL.
References: See EQUAL.
AI Programming in SNOBOL4 - 100 - August, 1982
+-----------------------------+
| EVALCODE(S) |
+-----------------------------+
Returns the value of S, interpreted and evaluated as a SNOBOL4
(SPITBOL) expression. If the evaluation of the expression
fails, EVALCODE fails.
General Categories.: Depends on S
Side Effects: Depends on S.
Example: EVALCODE('DUPL(" ",12)') returns a string of 12
blanks.
Comments: EVALCODE is mainly useful for evaluating expressions
which are constructed during program execution. The
references below are to the LISP EVAL function, which has a
similar purpose.
References: Charniak et al. (1980), 304.
MTS LISP Manual, 27.
Schank & Riesbeck (1981), 56.
Shapiro (1979), 151.
+-----------------------------+
| EVERY(NAME,L) |
+-----------------------------+
Returns T if the function named NAME returns a non-NIL value
for every argument on the list L; otherwise, NIL.
General Categories: List composition
Mapping function
Example: EVERY( .NUMBERP, 6 ~ '7' ~ -8.888 ~ 'TWO' ~ NIL)
returns NIL because NUMBERP('TWO') returns NIL.
References: Charniak et al. (1980), 304.
AI Programming in SNOBOL4 - 101 - August, 1982
+-----------------------------+
| EVLIS(L) |
+-----------------------------+
Returns a list of the values of the identifiers whose names are
the elements of L.
General Categories: List composition
Mapping function
Example: If A = 1.657, B = 'UNION', C = '?', and
L = .A ~ .B ~ .C ~ NIL, then EVLIS(L) returns
(1.657 ~ 'UNION' ~ '?' ~ NIL).
Comments: The elements of L may be strings or names. They
should not be deferred (unevaluated) expressions.
References: MTS LISP Manual, 20.
Shapiro (1979), 151.
+-----------------------------+
| EXCLUDE(L1,L2) |
+-----------------------------+
Returns the top-level elements of L1, excluding any which are
EQUAL to any element of L2. No duplicate elements will
appear in the result (cf. INTERSECT and UNION).
General Categories: List composition
List decomposition
List search
Example: If L1 = (8 ~ 'A' ~ '7' ~ 'D' ~ NIL) and
L2 = (7 ~ '8' ~ NIL), then EXCLUDE(L1,L2) returns
('A' ~ 'D' ~ NIL).
Comments: This version of EXCLUDE is in the INTERSECT- UNION
family; hence the elimination of duplicates in the result.
References: MTS LISP Manual, 21.
AI Programming in SNOBOL4 - 102 - August, 1982
+-----------------------------+
| EXP(N) |
+-----------------------------+
Returns e**N, where e is the base of the natural logarithms and
N is any integer or floating point number. The value of e,
in double precision, is stored as the value of NAT...BASE.
in SNOLISPIST.
General Categories: Arithmetic function
Example: EXP(P...I.) returns 23.140692632773.
References: Gimpel (1976), 336-337.
+-----------------------------+
| EXPLODE(X) |
+-----------------------------+
Returns a list of the single characters in UNREAD(X).
General Categories: Datatype conversion
List composition
Example: EXPLODE('DOG' ~ 'ARF' ~ NIL) returns
( '(' ~ 'D' ~ 'O' ~ 'G' ~ ' ' ~
'A' ~ 'R' ~ 'F' ~ ')' ~ NIL ).
References: Charniak et al. (1980), 304.
MTS LISP Manual, 22.
Schank & Riesbeck (1981), 56.
Shapiro (1979), 151.
AI Programming in SNOBOL4 - 103 - August, 1982
+-----------------------------+
| *FAIL.IF.NIL(L) |
+-----------------------------+
Returns L if L is non-NIL. If L is NIL, then the function call
fails. The unary operator / is OPSYNed to this function:
/L is equivalent to FAIL.IF.NIL(L).
The argument L must be a list (datatype CONS) or a fatal error
will result.
General Categories: Predicate
Example: The statement
Y = /GETPROP( .DOG, 'LEGS')
sets Y to whatever value is stored on the property list of
DOG under the indicator 'LEGS'. If no such value exists,
GETPROP returns NIL, /GETPROP fails, and the value of Y
remains unchanged.
Comments: This function helps interface the T/NIL mode of LISP-
type predicates with the succeed/fail mode of SNOBOL4
predicates.
+-----------------------------+
| FAIL.IF.NIL.ELSE.SUCCEED(L) |
+-----------------------------+
Returns the null string. It succeeds if /L succeeds, and fails
if /L fails. The unary operator % is OPSYNed to this
function: %L is equivalent to
FAIL.IF.NIL.ELSE.SUCCEED(L).
The argument L must be a list (datatype CONS) or a fatal
error will result.
General Categories: Predicate
Example: The statement
Y = %FIND(P,LST) CONS(P,Y)
will add P to the list Y if P is a substructure of LST; if
not, FIND returns NIL, %FIND fails, and Y remains unchanged.
Note that /FIND would not work here: If FIND found P, it would
return a non-NIL value. /FIND would pass along the same
value. The right-hand side of the assignment statement
would be interpreted as a concatenation expression, and a
fatal error would result, because one or both of the
arguments would be lists, not strings. Because SPITBOL
gives special attention to the null string, %FIND does not
cause the same error.
AI Programming in SNOBOL4 - 104 - August, 1982
+-----------------------------+
| FIND(X,L) |
+-----------------------------+
Returns the first substructure of L which is EQUAL to X. The
search is left-branching, depth-first. If X is not EQUAL to
any substructure of L, then FIND returns NIL.
General Categories: List decomposition
List search
Example: If X = ('A' ~ NIL) and
L = (1 ~ (2 ~ ('A' ~ NIL)) ~ 3 ~ NIL), then FIND(X,L)
returns ('A' ~ NIL).
Comments: This version of FIND is not exactly the same as the
MTS LISP version.
References: MTS LISP Manual, 19.
+-----------------------------+
| FIX(N) |
+-----------------------------+
Returns N converted to datatype 'INTEGER' if possible;
otherwise, it fails.
General Categories: Arithmetic function
Datatype conversion
Example: FIX(9.995) returns 9
Comments: Real to integer conversion is possible only if the
real number is between -2147483648 and 2147483647. Reals in
this range are converted to integers by truncating their
fractional parts.
References: MTS LISP Manual, 26.
Shapiro (1979), 151.
AI Programming in SNOBOL4 - 105 - August, 1982
+-----------------------------+
| FLOAT(N) |
+-----------------------------+
Returns N converted to datatype REAL.
General Categories: Arithmetic function
Datatype conversion
Example: FLOAT(-9) returns -9.0, a 4-byte floating-point
number.
References: MTS LISP Manual, 26.
Shapiro (1979), 151.
+-----------------------------+
| FLOOR(N) |
+-----------------------------+
Returns the largest integer which is no larger than N. N may
be any integer or floating point number.
General Categories: Arithmetic function
Example: FLOOR(-9.1) returns -10.
References: Gimpel (1976), 327.
AI Programming in SNOBOL4 - 106 - August, 1982
+-----------------------------+
| GENSYM() |
+-----------------------------+
Returns a string created by concatenating 'GSYM' with the
current value of &STCOUNT, the number of statements executed
so far. This is usually intended for use as the name of an
identifier. NEWSYM is a synonym for GENSYM.
General Categories: Definitional function
Example: $GENSYM() = LIST('O',NIL) has the effect of GSYM28347
= LIST('O',NIL), assuming that 28347 happens to be the
number of statements executed at the time GENSYM() is
called.
References: Charniak et al. (1980), 77-78, 306.
MTS LISP Manual, 21-22.
Shapiro (1979), 152.
+-----------------------------+
| GET(NAME,X) |
+-----------------------------+
Returns the value (always a list) associated with the indicator
X on the property list of the identifier named NAME. If no
such value exists, GET returns NIL.
General Categories: List decomposition
List search
Property-list function
Example: If ('LEGS' ~ 4 ~ NIL) is an element of the property
list of DOG, then GET( .DOG, 'LEGS') returns (4 ~ NIL).
References: Charniak et al. (1980), 18, 304.
MTS LISP Manual, 24.
Schank & Riesbeck (1981), 57.
Shapiro (1979), 152.
AI Programming in SNOBOL4 - 107 - August, 1982
+-----------------------------+
| GETL(NAME,L) |
+-----------------------------+
Returns the tail of the property list of the identifier named
NAME, beginning with the first element whose CAR is a MEMBER
of L.
General Categories: List decomposition
List search
Property-list function
Example: Suppose DOG has the following property-list:
(('NOSE' ~ 'WET' ~ NIL) ~
('LEGS' ~ 4 ~ NIL) ~
('TEETH' ~ 'SHARP' ~ NIL) ~ NIL). Then
GETL( .DOG, 'WINGS' ~ 'TEETH' ~ 'NOSE' ~ NIL) will return
the entire property list.
References: Charniak et al. (1980), 305.
+-----------------------------+
| GETPROP(NAME,S) |
+-----------------------------+
Returns the first value stored under the indicator S on the
property list of the identifier named NAME.
General Categories.: Alters existing CONS cell(s)
List decomposition
List search
Property-list function
Side Effects: The value returned is deleted from its place on
the property list.
Example: If ('LEGS' ~ 5 ~ 4 ~ 3 ~ 2 ~ 1 ~ NIL) is an element of
the property list of DOG, then five successive evaluations
of GETPROP(.DOG,'LEGS') will return 5, 4, 3, 2, and 1. The
sixth such call will return NIL.
Comments: GETPROP is intended to be used with PUTPROP in the
manipulation of push-down stacks of property list values.
References: MTS LISP Manual, 24-25.
AI Programming in SNOBOL4 - 108 - August, 1982
+-----------------------------+
| GREATER(L) |
+-----------------------------+
Returns the null string. It succeeds if the numbers in the
list L are in strictly decreasing order; otherwise, it
fails.
General Categories: Arithmetic function
Predicate
Example: GREATER(8 ~ 5 ~ 3 ~ -7 ~ 0 ~ NIL) fails.
References: MTS LISP Manual, 25.
Shapiro (1979), 152.
+-----------------------------+
| GREATERP(L) |
+-----------------------------+
Returns T if GREATER(L) succeeds; NIL otherwise.
General Categories: Arithmetic function
Predicate
Example: GREATERP(8.53211 ~ 5 ~ 3 ~ 2 ~ 1 ~ -1 ~ NIL) returns
T.
References: See GREATER.
AI Programming in SNOBOL4 - 109 - August, 1982
+-----------------------------+
| *IN(NAME) |
+-----------------------------+
Returns the next logical record (as a string) from the file
which is associated with the identifier "INPUT.". (Note
that the name of this identifier ends with a period!)
General Categories: Input
Side Effects: If NAME is not null, then the string returned by
IN also becomes the value of the identifier named NAME.
Example: TEMP = IN( .SAVE) reads the next input record, assigns
it as the value of TEMP, and also assigns it as the value of
SAVE.
Comments: No attempt is made in SNOLISPIST to simulate LISP
input functions. All input is string input, and datatype
conversion (e.g., to list) must be handled by the
programmer. (See READ.)
+-----------------------------+
| INSERT(X,L) |
+-----------------------------+
Returns L if X is EQUAL to an element of L; otherwise, it
returns CONS(X,L).
General Categories: List composition
List search
Example: INSERT(1, ('UN' ~ '1' ~ (8 ~ 'GNU') ~ NIL)) returns
its second argument unchanged.
References: Shapiro (1979), 152.
AI Programming in SNOBOL4 - 110 - August, 1982
+-----------------------------+
| INTERSECT(L1,L2) |
+-----------------------------+
Returns the list of elements common to L1 and L2, without
duplicates.
General Categories: List composition
List decomposition
List search
Example: INTERSECT(('A' ~ 'B' ~ NIL), ('B' ~ 'CAT' ~ NIL))
returns ('B' ~ NIL).
References: MTS LISP Manual, 21.
+-----------------------------+
| LAST(L) |
+-----------------------------+
Returns the last non-NIL cell of L (always a list); or NIL if
no such cell exists.
General Categories: List decomposition
List search
Example: LAST('A' ~ ('COMPLEX' ~ 'ELEMENT' ~ NIL) ~ NIL)
returns ('COMPLEX' ~ 'ELEMENT' ~ NIL) ~ NIL.
Comments: LAST returns the last non-NIL CONS-cell of L, not a
copy of that cell. Thus, changes to LAST(L), by means of
RPLACA, RPLACD, etc., produce changes in the value of L.
Also note that LAST(L) does not return the last element of L
(cf. RAC): LAST('A' ~ 'B' ~ NIL) returns ('B' ~ NIL), not
'B'.
References: Charniak et al. (1980), 305.
Schank & Riesbeck (1981), 57.
AI Programming in SNOBOL4 - 111 - August, 1982
+-----------------------------+
| LCOPY(L) |
+-----------------------------+
Returns a copy of the list L, i.e., a structure which is EQUAL
to L but not EQU to L.
General Categories: List composition
Example: For any list L,
EQU( !L, !LCOPY(L)) succeeds;
EQU( L, LCOPY(L)) fails; and
EQUAL( L, LCOPY(L)) succeeds.
Comments: COPY is a built-in function in SPITBOL; hence the
name change.
References: MTS LISP Manual, 20.
+-----------------------------+
| LENGTH(X) |
+-----------------------------+
Returns the number of top-level elements of X, if X is a list.
If X is an atom, LENGTH returns the number of characters in
its string representation; if X has no string
representation, LENGTH fails.
General Categories: List search
Example: LENGTH('UNION' ~ 'SUIT' ~ 'MAKER' ~ NIL) returns 3.
References: Charniak et al. (1980), 305.
MTS LISP Manual, 25.
Schank & Riesbeck (1981), 57.
Shapiro (1979), 152.
AI Programming in SNOBOL4 - 112 - August, 1982
+-----------------------------+
| LESS(L) |
+-----------------------------+
Returns the null string. It succeeds if the numbers in the
list L are in strictly increasing order; otherwise, it
fails.
General Categories: Arithmetic function
Predicate
Example: LESS(1 ~ 2 ~ 3 ~ 5 ~ 8 ~ 13 ~ NIL) succeeds.
References: MTS LISP Manual, 25.
Shapiro (1979), 153.
+-----------------------------+
| LESSP(L) |
+-----------------------------+
Returns T if LESS(L) succeeds; NIL otherwise.
General Categories: Arithmetic function
Predicate
Example: LESSP(1 ~ 1 ~ 9.112 ~ 9112 ~ NIL) returns NIL.
References: See LESS.
AI Programming in SNOBOL4 - 113 - August, 1982
+-----------------------------+
| *LIST(X,Y) |
+-----------------------------+
Returns CONS(X,Y), i.e., a list C such that CAR(C) = X and
CDR(C) = Y. The binary operator ~ is OPSYNed to the LIST
function: 'A' ~ 'B' is equivalent to LIST('A','B').
General Categories: List composition
Example:
SNOLISPIST:
A ~ (B ~ C) ~ (D ~ (E ~ F)) ~ NIL
LISP:
(A (B C) (D (E F)))
Comments: The ~ operator is the highest precedence binary
operator in SPITBOL, and it is right-associative. Thus, (A ~
B ~ C ~ NIL) is equivalent to CONS(A,CONS(B,CONS(C,NIL))),
i.e., to LISP's (A B C).
Note that LIST is strictly binary in SNOLISPIST, but the ~
operator allows the chaining of an indefinite number of
arguments.
References: Charniak et al. (1980), 305.
MTS LISP Manual, 20.
Schank & Riesbeck (1981), 57.
Shapiro (1979), 153.
+-----------------------------+
| LOG(N1,N2) |
+-----------------------------+
Returns log(N1) (base N2); N1 > 0, N2 > 0, N2 <> 1. If N2 is
omitted, e is assumed (i.e., the natural logarithm of N1 is
returned).
General Categories: Arithmetic function
Example: LOG(0.167, 2) returns -2.5820800292618.
References: Gimpel (1976), 335-336.
AI Programming in SNOBOL4 - 114 - August, 1982
+-----------------------------+
| LREVERSE(L) |
+-----------------------------+
Returns the top-level elements of L in reverse order.
General Categories: List composition
List decomposition
Example: LREVERSE(11 ~ 9 ~ 8 ~ 4 ~ NIL) returns
(4 ~ 8 ~ 9 ~ 11 ~ NIL).
Comments: REVERSE is a built-in function in SPITBOL. (It
reverses the characters in a string.)
References: Charniak et al. (1980), 15, 308.
MTS LISP Manual, 20.
Schank & Riesbeck (1981), 59.
Shapiro (1979), 155.
+-----------------------------+
| LTRACE(N,L) |
+-----------------------------+
Returns the null string.
General Categories: Output
Side Effects: This function permits tracing of functions which
have list arguments and/or which return list values. A call
to LTRACE(N,L) turns on N-level tracing for every function
whose name is on the list L. If N is omitted, then N = 3 is
assumed.
0-level tracing indicates that tracing is to be turned off
for all functions whose names are on the list L.
1-level tracing indicates that the values of the arguments
passed to the traced function and the value returned from
the traced function are to be reported every time the
function is called or returned from. The trace messages go
to the user's terminal.
2-level tracing includes the information requested by 1-
level tracing; in addition, the values of all local
variables and arguments are reported every time the traced
function returns.
AI Programming in SNOBOL4 - 115 - August, 1982
3-level tracing includes the information requested by 2-
level tracing; in addition, the program will pause every
time the traced function is called or returned from. At
this time, any SPITBOL or SNOLISPIST expression may be
entered. This expression will be immediately evaluated.
Such an expression could be used to turn off or alter the
level of tracing of one or more functions; to initiate
tracing of one or more additional functions; to print the
value of a variable; to alter the value of a variable; or to
do anything else that can be accomplished with one
expression. A simple line-feed (null line) will cause the
program to continue.
Certain functions cannot be traced. These include all the
SPITBOL built-in functions, as well as the following
SNOLISPIST functions:
LTRACE, POP, any LAMBDA, PRT.VIA.OUTPUT, ATOM, CAR, CDR,
TDUMP, PRINT.IN.FIELD, UNREAD, NULL, UNCONS, IN, CONCAT,
MAPCAR, LIST, and PRINT.
Example: LTRACE(1, .FUNCT1 ~ .APPEND ~ .XYZ ~ NIL) turns on 1-
level tracing for the functions FUNCT1, APPEND, and XYZ.
Here, FUNCT1 and XYZ are presumably user-defined, while
APPEND is a SNOLISPIST function.
Comments: Requests to trace untraceable functions are simply
ignored.
LTRACE is under the control of the SNOBOL4 keyword $TRACE.
This keyword must be set to a positive integer or tracing
will be inhibited.
References: MTS LISP Manual, 63-64.
AI Programming in SNOBOL4 - 116 - August, 1982
+-----------------------------+
| MAP(NAME,L) |
+-----------------------------+
Returns NIL.
General Categories: Mapping function
Side Effects: Applies the function named NAME to L, then to
CDR(L), then to CDDR(L), and so on.
Example: %MAP( .PRINT, 'AARDVARK' ~ 'SYZYGY' ~ 'ZAX' ~ NIL)
causes (AARDVARK SYZYGY ZAX), (SYZYGY ZAX), and (ZAX) to be
printed on three successive lines, then fails.
References: Charniak et al. (1980), 61.
MTS LISP Manual, 28.
+-----------------------------+
| MAPC(NAME,L) |
+-----------------------------+
Returns NIL.
General Categories: Mapping function
Side Effects: Applies the function named NAME to CAR(L), then
to CADR(L), then to CADDR(L), and so on.
Example: %MAPC( .PRINT, 'AARDVARK' ~ 'SYZYGY' ~ 'ZAX' ~ NIL)
causes AARDVARK, SYZYGY, and ZAX to be printed on three
successive lines, then fails.
References: Charniak et al. (1980), 61, 306.
MTS LISP Manual, 28.
Schank & Riesbeck (1981), 65.
Shapiro (1979), 153.
AI Programming in SNOBOL4 - 117 - August, 1982
+-----------------------------+
| MAPCAN(NAME,L) |
+-----------------------------+
Returns NCONC(MAPCAR(NAME,L)).
General Categories: Alters existing CONS cell(s)
List composition
Mapping function
Side Effects: See MAPCON.
Example: MAPCAN( .LAST, ((1 ~ 2 ~ 3 ~ 4 ~ NIL) ~ (7 ~ 8 ~ NIL)
~ ('A' ~ 'B' ~ NIL) ~ NIL)) returns (4 ~ 8 ~ 'B' ~ NIL).
References: Charniak et al. (1980), 61-62, 306.
MTS LISP Manual, 28.
Schank & Riesbeck (1981), 65.
+-----------------------------+
| MAPCAR(NAME,L) |
+-----------------------------+
Returns a list of the values returned when the function named
NAME is applied successively to CAR(L), CADR(L), CADDR(L),
and so on.
General Categories: List composition
Mapping function
Example: MAPCAR( .ADD1, 19 ~ 43 ~ '88' ~ '69' ~ NIL) returns
(20 ~ 44 ~ 89 ~ 70 ~ NIL).
References: Charniak et al. (1980), 15-17, 61-62, 306.
MTS LISP Manual, 28.
Schank & Riesbeck (1981), 65.
Shapiro (1979), 153.
AI Programming in SNOBOL4 - 118 - August, 1982
+-----------------------------+
| *MAPCARV(NAME,L) |
+-----------------------------+
Returns the reverse of MAPCAR(NAME,L).
General Categories: List composition
Mapping function
Example: MAPCARV( .NUMBERP, #'(zed 7 74 EQ *)' ) returns (NIL ~
NIL ~ T ~ T ~ NIL ~ NIL). (The final NIL is the list
terminator.)
Comments: This function is sometimes useful when an argument
list is built up by CONSing elements together. Generally,
such a list is built backwards. MAPCARV can then be used to
map the list and to restore the original order. This saves
two needless calls to LREVERSE.
References: See MAPCAR.
+-----------------------------+
| MAPCON(NAME,L) |
+-----------------------------+
Returns NCONC(MAPLIST(NAME,L)).
General Categories: Alters existing CONS cell(s)
List composition
Mapping function
Side Effects: NCONC uses RPLACD, so the usual caveats apply:
Functions that alter existing cons-cells can have unexpected
consequences. Note also that NAME must return a list for
each argument in L.
Example: MAPCON( .LREVERSE, 1 ~ 2 ~ 3 ~ 4 ~ 5 ~ NIL) returns (5
~ 4 ~ 3 ~ 2 ~ 1 ~ 5 ~ 4 ~ 3 ~ 2 ~ 5 ~ 4 ~ 3 ~ 5 ~ 4 ~ 5 ~
NIL).
References: Charniak et al. (1980), 61-62.
MTS LISP Manual, 28.
AI Programming in SNOBOL4 - 119 - August, 1982
+-----------------------------+
| MAPLIST(NAME,L) |
+-----------------------------+
Returns a list of the values returned when the function named
NAME is applied successively to L, CDR(L), CDDR(L), and so
on.
General Categories: List composition
Mapping function
Example: MAPLIST( .PLUS, 1 ~ 2 ~ 3 ~ 4 ~ NIL) returns
(10 ~ 9 ~ 7 ~ 4 ~ NIL).
References: Charniak et al. (1980), 61.
MTS LISP Manual, 28.
+-----------------------------+
| MAX(N1,N2) |
+-----------------------------+
Returns the larger of N1 and N2.
General Categories: Arithmetic function
Example: MAX(6.78, 12.2243) returns 12.2243.
References: MTS LISP Manual, 26.
Shapiro (1979), 153.
AI Programming in SNOBOL4 - 120 - August, 1982
+-----------------------------+
| MEMBER(X,L) |
+-----------------------------+
Returns the tail of L beginning with the first top-level
element which is EQUAL to X. If no such element exists,
MEMBER returns NIL.
General Categories: List composition
List decomposition
List search
Example:
MEMBER(1, ((1 ~ NIL) ~ (2 ~ NIL) ~ '1' ~ 'A' ~ NIL)) returns
('1' ~ 'A' ~ NIL).
Comments: Cf. ASSOC and MEMQ.
References: Charniak et al. (1980), 306.
MTS LISP Manual, 19.
Schank & Riesbeck (1981), 46, 57.
Shapiro (1979), 153.
+-----------------------------+
| MEMQ(X,L) |
+-----------------------------+
Returns the null string. It succeeds if MEMBER(X,L) is non-
NIL; otherwise, it fails.
General Categories: Predicate
Example: The statement
= MEMQ(1, INTEGERS) 'ONE' ~ A
will CONS the string 'ONE' onto the front of the list A if
the integer 1 (or anything EQUAL to it, e.g., '1.0') is a
member of the list INTEGERS.
Comments: See MEMBER.
References: See MEMBER.
AI Programming in SNOBOL4 - 121 - August, 1982
+-----------------------------+
| MIN(N1,N2) |
+-----------------------------+
Returns the smaller of N1 and N2.
General Categories: Arithmetic function
Example: MIN(0,MAX(-7,8)) returns 0.
References: MTS LISP Manual, 26.
Shapiro (1979), 153.
+-----------------------------+
| MINUS(N) |
+-----------------------------+
Returns -N.
General Categories: Arithmetic function
Example: MINUS(80.8) returns -80.8.
References: Charniak et al. (1980), 306.
MTS LISP Manual, 26.
Schank & Riesbeck (1981), 57.
Shapiro (1979), 153.
+-----------------------------+
| MULT(N1,N2) |
+-----------------------------+
Returns the product of N1 and N2.
General Categories: Arithmetic function
Example: MULT(7, -8.1) returns -56.7.
Comments: MULT is binary. For a comparable function which
takes a list argument, see TIMES.
References: Charniak et al. (1980), 310.
MTS LISP Manual, 26.
Schank & Riesbeck (1981), 60.
Shapiro (1979), 156.
AI Programming in SNOBOL4 - 122 - August, 1982
+-----------------------------+
| NCONC(L) |
+-----------------------------+
Returns a concatenated list of the elements of CAR(L), CADR(L),
CADDR(L), etc. L must be a list of lists.
General Categories: Alters existing CONS cell(s)
List composition
Side Effects: NCONC(L) works analogously to APPEND(L), except
that NCONC links the sublists together by using
RPLACD(LAST(...)) operations. This avoids the creation of
new CONS cells, and is therefore more efficient than APPEND.
It does, however, introduce the risk of creating circular
(endless) lists and/or altering the values of some variables
in unanticipated ways.
Example:
Let A = ('B' ~ 'C' ~ NIL),
B = ('NN' ~ 'OO' ~ NIL), and
C = ('FRONT' ~ A).
Now execute the statement
LONG = NCONC(A ~ B ~ NIL)
At this point,
LONG = ('B' ~ 'C' ~ 'NN' ~ 'OO' ~ NIL),
but we also have (!)
A = ('B' ~ 'C' ~ 'NN' ~ 'OO' ~ NIL) and
C = ('FRONT' ~ 'B' ~ 'C' ~ 'NN' ~ 'OO' ~ NIL).
Even worse results would have been produced by
LONG = NCONC(A ~ C ~ NIL).
Comments: Note that MAPCAN and MAPCON use NCONC.
References: Charniak et al. (1980), 23, 306.
MTS LISP Manual, 23-24 (GRAFT).
AI Programming in SNOBOL4 - 123 - August, 1982
+-----------------------------+
| NEG(N) |
+-----------------------------+
Returns the null string. It succeeds if N is less than 0;
otherwise it fails.
General Categories: Predicate
Example: The statement
Y = NEG(FFC) SQRT( -FFC)
sets Y to the square root of -FFC if FFC is negative;
otherwise, the value of Y remains unchanged.
Comments: In LISP, this predicate usually goes under the name
MINUSP.
References: Schank & Riesbeck (1981), 57.
Shapiro (1979), 153.
+-----------------------------+
| NEGP(N) |
+-----------------------------+
Returns T if NEG(N) succeeds; NIL otherwise.
General Categories: Predicate
Example: MAPCAR( .NEGP, 6 ~ -7 ~ 8 ~ -9 ~ 10 ~ -11 ~ -12 ~ 13 ~
NIL) returns (NIL ~ T ~ NIL ~ T ~ NIL ~ T ~ T ~ NIL ~ NIL).
(The final NIL is the list terminator.)
References: See NEG.
+-----------------------------+
| NEWSYM() |
+-----------------------------+
Synonym for GENSYM().
AI Programming in SNOBOL4 - 124 - August, 1982
+-----------------------------+
| NOT() |
+-----------------------------+
Synonym for NULL().
+-----------------------------+
| NOTP() |
+-----------------------------+
Synonym for NULLP().
+-----------------------------+
| NTH(L,N) |
+-----------------------------+
Returns the tail of L beginning with the Nth top-level element.
If N is 0 or 1, L is returned. If N exceeds LENGTH(L), then
NIL is returned. If N is negative, then the last N elements
of L are returned (not in reverse order). NTH(L, -1) is
equivalent to LAST(L).
General Categories: List decomposition
List search
Example: Let LST = ('F' ~ 'G' ~ NIL) ~ (1 ~ 2 ~ NIL) ~
HOO' ~ 'HAH' ~ NIL.
Then NTH(LST, -2) returns ('HOO' ~ 'HAH' ~ NIL).
Comments: See LAST.
References: Charniak et al. (1980), 310 (SUFLIST).
MTS LISP Manual, 19.
Shapiro (1979), 143.
AI Programming in SNOBOL4 - 125 - August, 1982
+-----------------------------+
| *NULL(L) |
+-----------------------------+
*NULL(L)
Returns the null string. It succeeds if L is NIL; otherwise,
it fails. NOT is a synonym for NULL.
The argument L must be a list (datatype CONS) or a fatal
error will result.
General Categories: Predicate
Example: NULL(T) fails.
References: Charniak et al. (1980), 306.
MTS LISP Manual, 18.
Schank & Riesbeck (1981), 49-50.
Shapiro (1979), 153.
+-----------------------------+
| NULLP(L) |
+-----------------------------+
Returns T if NULL(L) succeeds; otherwise, NIL. NOTP is a
synonym for NULLP.
The argument L must be a list (datatype CONS) or a fatal
error will result.
General Categories: Predicate
Example: NULLP(8 ~ NIL) returns NIL.
References: See NULL.
AI Programming in SNOBOL4 - 126 - August, 1982
+-----------------------------+
| NUMBER(X) |
+-----------------------------+
Returns the null string. It succeeds if X can be converted to
any of the datatypes 'INTEGER', 'REAL', or 'DREAL'; fails
otherwise.
General Categories: Predicate
Example: NUMBER('-3.1415926') succeeds and returns the null
string.
References: Charniak et al. (1980), 306.
MTS LISP Manual, 18.
Schank & Riesbeck (1981), 58.
Shapiro (1979), 153.
+-----------------------------+
| NUMBERP(X) |
+-----------------------------+
Returns T if NUMBER(X) succeeds; NIL otherwise.
General Categories: Predicate
Example: NUMBERP('+3.1415926?') returns NIL.
References: See NUMBER.
+-----------------------------+
| PLUS(L) |
+-----------------------------+
Returns the sum of the numbers in the list L.
General Categories: Arithmetic function
Example: PLUS(8.3 ~ -9.1 ~ 6.25 ~ NIL) returns 5.45.
Comments: Cf. ADD.
References: Charniak et al. (1980), 307.
MTS LISP Manual, 26 (ADD).
Schank & Riesbeck (1981), 58.
Shapiro (1979), 154.
AI Programming in SNOBOL4 - 127 - August, 1982
+-----------------------------+
| *POP(NAME) |
+-----------------------------+
Synonym for UNCONS(NAME).
+-----------------------------+
| PRELIST(L,N) |
+-----------------------------+
Returns a list consisting of the first N top-level elements of
L. If N is zero, NIL is returned. If N exceeds LENGTH(L),
L is returned. If N is negative, the last ABS(N) elements
of L are returned.
General Categories: List decomposition
List search
Example: PRELIST('A' ~ 'B' ~ 'C' ~ 'D' ~ 'E' ~ NIL, 3) returns
'A' ~ 'B' ~ 'C' ~ NIL.
References: Charniak et al. (1980), 96, 307.
+-----------------------------+
| *PRINT(X) |
+-----------------------------+
Synonym for PRT.VIA.OUTPUT.
AI Programming in SNOBOL4 - 128 - August, 1982
+-----------------------------+
| PRINT.IN.FIELD(N,X) |
+-----------------------------+
Returns a string which depends upon the values of N and X. If
the first two characters of X are 'C.', 'L.', or 'R.', then
the rest of X is treated as an expression, and its value is
centered ('C.'), left-justified ('L.'), or right-justified
('R.') in a field of N spaces. If the first two characters
of X do not match any of the three special prefixes ('C.',
'L.', or 'R.'), then N copies of X are concatenated and the
resulting string is returned.
This function is intended to help with formatted output.
The binary operator $ is OPSYNed to PRINT.IN.FIELD: (N % X)
is equivalent to PRINT.IN.FIELD(N,X).
General Categories: Datatype conversion
Output
Side Effects: If the first two characters of X are 'C.', 'L.',
or 'R.', then the remainder of X is EVALed. This may or may
not have side effects, depending upon the value of X.
Example: The statement
|(62 % 'C.LST')
will center the value of LST in a 62-column field. In other
words, the value of LST will be padded with blanks on the
left and right to increase its length to 62.
Comments: If the string to be padded exceeds the requested
field size, the string itself is returned.
Note that, although this function is classified as an output
function, it does not by itself cause anything to be written
to the output file. It is intended to be embedded in an
argument to PRT.VIA.OUTPUT (|).
References: Shapiro (1979), 144-147.
AI Programming in SNOBOL4 - 129 - August, 1982
+-----------------------------+
| *PRT.VIA.OUTPUT(X) |
+-----------------------------+
Returns the string representation of X. The unary operator |
is OPSYNed to this function: That is, |X is equivalent to
PRT.VIA.OUTPUT(X).
General Categories: Output
Side Effects: This string representation of X is written to the
output file associated with the identifier "OUTPUT.". (Note
that the name of this identifier ends with a period.)
Initially,this output file will be the user's terminal.
Example:
|'' will print one blank line
|||'' will print three blank lines
|'Hi, sailor!' will print a friendly greeting.
Comments: See IN, PRINT.IN.FIELD, UNREAD, and PRINT.
+-----------------------------+
| PUT(NAME,S,X) |
+-----------------------------+
Returns the modified property list of NAME.
General Categories: Alters existing CONS cell(s)
List composition
List search
Property-list function
Side Effects: X is put on the property list of the identifier
named NAME, under the indicator S. If S already has a value
or list of values associated with it, all such values are
deleted and replaced by X.
If X is NIL, then S is placed on the property list as an
indicator with no associated values.
Example: PUT( .CHILD, 'BEHAVIOR', 'CHARMING') puts the element
('BEHAVIOR' ~ 'CHARMING' ~ NIL) on the property list of the
identifier CHILD. Any previous value(s) associated with
'BEHAVIOR' are erased.
Comments: Cf. ADDPROP, GET, DEFPROP, PUTPROP, GETL, PUTL.
References: MTS LISP Manual, 24.
Shapiro (1979), 154.
AI Programming in SNOBOL4 - 130 - August, 1982
+-----------------------------+
| PUTL(L,S,X) |
+-----------------------------+
Returns NIL.
General Categories: Alters existing CONS cell(s)
List composition
List search
Property-list function
Side Effects: Puts X under the indicator S on the property list
of each identifier whose name is an element of L, erasing
any previous value(s) associated with S.
Example: PUTL(LID,'STAGE',NIL) initializes the value for the
property indicator 'STAGE' (or resets that value) for each
identifier whose name is an element of LID.
References: MTS LISP Manual, 24 (PUT).
AI Programming in SNOBOL4 - 131 - August, 1982
+-----------------------------+
| PUTPROP(NAME,X,S) |
+-----------------------------+
Returns the modified property list of NAME.
General Categories: Alters existing CONS cell(s)
List composition
List search
Property-list function
Side Effects: It adds X to the list of values associated with
the indicator S on the property list of the identifier named
NAME (without erasing other values associated with S).
If X is NIL, and if S is already an indicator on the
property list, then nothing changes. If X is NIL and S is
not an indicator, then (S NIL) is added to the property
list.
Example:
Suppose 'BEHAVIOR' ~ 'CHARMING' ~ NIL is an element of the
property list of CHILD.
PUTPROP(.CHILD,'AMUSING','BEHAVIOR') would change this
element to ('BEHAVIOR' ~ 'AMUSING' ~ 'CHARMING' ~ NIL).
Comments: Cf. PUT, ADDPROP, PUTL, DEFPROP.
References: Charniak et al. (1980), 308.
MTS LISP Manual, 25 (ADDPROP).
Schank & Riesbeck (1981), 50, 59.
AI Programming in SNOBOL4 - 132 - August, 1982
+-----------------------------+
| QUOTIENT(L) |
+-----------------------------+
Returns the first element of L, divided by the product of the
rest. (If L has just one element, that element is
returned.)
General Categories: Arithmetic function
Example: QUOTIENT(5 ~ 4 ~ 3 ~ 2 ~ 1 ~ NIL) returns
.20833333333333.
Comments: Double precision division is automatic.
References: Charniak et al. (1980), 308.
MTS LISP Manual, 26 (binary DIVIDE).
Shapiro (1979), 154.
+-----------------------------+
| RAC(L) |
+-----------------------------+
Returns the last top-level element of L.
General Categories: List decomposition
List search
Example: Let L = #'((E A T) MORE F I S H)'. Then RAC(L)
returns 'H'.
Comments: RAC(L) is not equivalent to LAST(L), but it is
equivalent to CAR(LREVERSE(L)).
References: Shapiro (1979), 154.
+-----------------------------+
| RAD(N) |
+-----------------------------+
Returns the number of radians in N degrees.
General Categories: Arithmetic function
Example: RAD(66.666667) returns 1.1635529234349.
AI Programming in SNOBOL4 - 133 - August, 1982
+-----------------------------+
| RAISE(N1,N2) |
+-----------------------------+
Returns N1**N2. N1 and N2 may be integers or floating point
numbers.
General Categories: Arithmetic function
Example: RAISE(2, DIV(P...I., 2)) returns 2.9706864235513.
References: Gimpel (1976), 337.
+-----------------------------+
| RDC(L) |
+-----------------------------+
Returns a copy of L with its last top-level element deleted.
General Categories: List decomposition
List search
Example: Let L = #'(A AA AAA AAAA)'. Then RDC(L) returns ('A'
~ 'AA' ~ 'AAA' ~ NIL).
Comments: RDC(L) = LREVERSE(CDR(LREVERSE(L))).
References: Shapiro (1979), 154.
AI Programming in SNOBOL4 - 134 - August, 1982
+-----------------------------+
| *READ(S) |
+-----------------------------+
Returns the list represented by S. String-to-list conversion
is carried out using LISP-like rules. The # unary operator
is OPSYNed to the READ function: #S is equivalent to
READ(S).
General Categories: Datatype conversion
List composition
Side Effects: In READ only, a \ unary operator indicates that
the value of a string is to replace the string. Multiple
\'s indicate multiple evaluations.
Example:
Let A = 5, B = 'BOOK', and C = 'CHILD'.
Then #'((A \A) (B \B) (C . \C))' returns
(('A' ~ 5 ~ NIL) ~ ('B' ~ 'BOOK' ~ NIL) ~
('C' ~ 'CHILD') ~ NIL).
Comments: Dotted pairs are allowed, as in LISP, but there must
be at least one blank on each side of the dot, and the
dotted pair must be surrounded by parentheses.
Quoted literal strings are recognized. Double quotes (")
can occur inside single-quoted (') strings and vice versa.
Blanks and parentheses can occur inside quoted strings.
The following expressions all translate to NIL:
('' . ''), ("" . ""), (), and NIL. Also, as indicated in
the example, NIL is provided automatically at the end of a
normal list.
The following expressions translate to T:
T and (T . T).
AI Programming in SNOBOL4 - 135 - August, 1982
+-----------------------------+
| READLIST(L) |
+-----------------------------+
Returns READ(CONCAT(L)). L is a list of strings, not
necessarily single characters. All the strings are
concatenated to form one long string S. READLIST then
returns READ(S).
General Categories: Datatype conversion
List composition
Example: Let L =
( '(' ~ 'FO' ~ ' TO' ~ ' ' ~ 'MAT)' ~ NIL ).
CONCAT would form the concatenated string '(FO TO MAT)' and
READLIST would return #'(FO TO MAT)', which is the list
('FO' ~ 'TO' ~ 'MAT' ~ NIL).
References: Charniak et al. (1980), 51, 71, 308.
Shapiro (1979), 154.
+-----------------------------+
| *REMAINDER(N1,N2) |
+-----------------------------+
Returns N1 modulo N2.
General Categories: Arithmetic function
Example: REMAINDER(8,3) returns 2.
Comments: N1 and N2 must be integers. REMAINDER is the same as
the SPITBOL REMDR function. This means that the sign of the
result is, by definition, the sign of the first argument.
References: Charniak et al. (1980), 308.
MTS LISP Manual, 26.
Shapiro (1979), 155.
AI Programming in SNOBOL4 - 136 - August, 1982
+-----------------------------+
| REMOVE(L,X)
+-----------------------------+
Returns a new list in which all occurrences of X in L have been
deleted.
General Categories: List composition
List decomposition
List search
Example: If L = #'((1 A) (2 B) (3 (2 B)))', then
REMOVE( L, (2 ~ 'B' ~ NIL) ) returns
(1 ~ 'A' ~ NIL) ~ (3 ~ NIL) ~ NIL.
References: Charniak et al. (1980),
MTS LISP Manual, 20-21 (COPY), 23 (DELETE).
Schank & Riesbeck (1981), 59.
Shapiro (1979), 155.
+-----------------------------+
| REMPROP(NAME,S) |
+-----------------------------+
Returns T if the indicator S is found on the property list of
the identifier named NAME; otherwise NIL.
General Categories: List decomposition
List search
Predicate
Property-list function
Side Effects: The indicator S and all its associated values are
removed from the property list of NAME.
Example: REMPROP( .CHILD, 'BEHAVIOR') removes the indicator
'BEHAVIOR' from the property list of CHILD, returning T if
such an indicator was there to be removed, or NIL if no such
indicator was there.
References: Charniak et al. (1980), 308.
MTS LISP Manual, 24 (REM).
Schank & Riesbeck (1981), 59.
AI Programming in SNOBOL4 - 137 - August, 1982
+-----------------------------+
| ROUND(N) |
+-----------------------------+
Returns N rounded to the nearest integer. (.5 rounds up for
positive numbers and down for negative numbers.)
General Categories: Arithmetic function
Example: ROUND(-8.5) returns -9.
References: Shapiro (1979), 147.
+-----------------------------+
| RPLACA(L,X) |
+-----------------------------+
Returns the list formed by replacing the CAR of L with X.
General Categories: Alters existing CONS cell(s)
List composition
Side Effects: This is a function that alters an existing CONS
cell. Therefore, it carries the usual risks of creating
circular lists and of unintentionally altering the values
of other variables (cf. NCONC).
Example: Consider the assignment statement
L = RPLACA(L,L)
This statement creates a circular list.
References: Charniak et al. (1980), 21-22, 308.
MTS LISP Manual, 22.
AI Programming in SNOBOL4 - 138 - August, 1982
+-----------------------------+
| RPLACD(L,X) |
+-----------------------------+
Returns the list created by replacing the CDR of L with X.
General Categories: Alters existing CONS cell(s)
List composition
Side Effects: See RPLACA, NCONC.
Example: If L = #'((A B) (C (D E)) F)', then
RPLACD(L, ('E' ~ 'F' ~ NIL)) returns
(('A' ~ 'B' ~ NIL) ~ 'E' ~ 'F' ~ NIL).
This list also becomes the value of L.
References: Charniak et al. (1980), 21-22, 309.
MTS LISP Manual, 22-23.
+-----------------------------+
| RPLACN(L,N,X) |
+-----------------------------+
Returns the list created by replacing the Nth element of L with
X. If N is 0, then X is CONSed onto the front of L. If N >
LENGTH(L), then LIST(X,NIL) is NCONCed onto the end of L.
If N < 0, the elements of L are numbered "from the right,"
with the last element being number 1.
General Categories: Alters existing CONS cell(s)
List composition
List search
Side Effects: The value of L is changed unless N = 0.
Example: If L = #'(1 2 3 4 5 6)', then
RPLACN(L,3,'THREE') returns
(1 ~ 2 ~ 'THREE' ~ 4 ~ 5 ~ 6 ~ NIL).
This list also becomes the new value of L.
Comments: See RPLACA, RPLACD, NCONC.
References: Shapiro (1979), 143.
AI Programming in SNOBOL4 - 139 - August, 1982
+-----------------------------+
| SET.(NAME,X) |
+-----------------------------+
Returns X.
General Categories: Definitional function
Side Effects: X becomes the value of the identifier named NAME.
Example: SET.( .C, 'SHINING') returns 'SHINING' and sets the
value of C to 'SHINING'.
Comments: (Editor's note) This function was named SET (no
period) in the original report. The period is appended to
distinguish the function from the Spitbol function by the
same name, used to position direct-access files.
References: Charniak et al. (1980), 18, 309.
MTS LISP Manual, 22.
Schank & Riesbeck (1981), 60.
Shapiro (1979), 155.
+-----------------------------+
| SETL(L) |
+-----------------------------+
Returns the list with elements CADR(L), CADDDR(L), ...; i.e.,
the even-numbered elements of L.
General Categories: Definitional function
List composition
List decomposition
Side Effects: Sets the value of CAR(L) to CADR(L), of CADDR(L)
to CADDDR(L), and so on. Note that the odd-numbered
elements of L are interpreted as names, and the even-
numbered elements are interpreted as values.
Example: If A = #'(X1 5 X2 17 X3 19 X4 23)', then SETL(A)
returns (5 ~ 17 ~ 19 ~ 23 ~ NIL) and sets X1 = 5, X2 = 17,
X3 = 19, and X4 = 23.
Comments: This is just the list-argument form of SET which is
available in some LISPs. Note that the structure of the
argument list determines whether SETL acts like LISP's SETQ,
SET, or something else.
AI Programming in SNOBOL4 - 140 - August, 1982
+-----------------------------+
| SIGN(N) |
+-----------------------------+
Returns -1 if N is negative, 1 if N is positive, 0 if N is
zero.
General Categories: Arithmetic function
Example: SIGN(8 x -9.5) returns -1.
+-----------------------------+
| SIN(N) |
+-----------------------------+
Returns the sine of N radians. N may be any integer or real
number.
General Categories: Arithmetic function
Example: SIN(P...I. / 4) returns 0.70710678118633.
(P...I. = pi.)
References: Gimpel (1976), 332-333.
+-----------------------------+
| SORT.(A,N1,N2,S) |
+-----------------------------+
Returns the array A with elements N1 through N2 sorted
according to predicate P. P may be 'LE' (numeric array,
ascending sort), 'GE' (numeric, descending), 'LLE' (string,
ascending), or 'LGE' (string, descending).
Side Effects: The array argument itself is altered.
Example: If ROSTER is an array of N students' names, then
SORT.(ROSTER,1,N, 'LLE') will cause the names to be arranged
in alphabetical order.
Comments: The sorting method is described in Singleton (1968).
(Editor's note) This function was named SORT (no period) in
the original report. The period is appended to distinguish
the function from the Spitbol function by the same name.
AI Programming in SNOBOL4 - 141 - August, 1982
References: Singleton (1968).
Gimpel (1975), 280, 292, 299.
Wirth (1976), 76-84.
+-----------------------------+
| SNOC(L,X) |
+-----------------------------+
Returns a copy of L with X added on as the last top-level
element.
General Categories: List composition
Example: If L = ~'(A B C)', then
SNOC( L, 4) returns ('A' ~ 'B' ~ 'C' ~ 4 ~ NIL).
References: Schank & Riesbeck ~i981), 54, 69 (CONS-END).
Shapiro (1979), 155,
+-----------------------------+
| SOME(NAME,L) |
+-----------------------------+
Returns T if the function named NAME returns a non-NIL value
for some argument in the list L; NIL otherwise.
General Categories: Mapping function
Predicate
Example: If L = #'(! # $ % & 18.9 * =)',
then SOME( .NUMBERP, L) returns T.
Comments: Cf. EVERY, SUBSET.
References: Charniak et al. (1980), 309.
Schank & Riesbeck (1981), 66.
AI Programming in SNOBOL4 - 142 - August, 1982
+-----------------------------+
| SQRT(N) |
+-----------------------------+
Returns the double-precision square root of N. N may be any
non-negative integer or floating point number.
General Categories: Arithmetic function
Example: SQRT(4.5) returns 2.1213203435596.
References: Gimpel (1976), 330-331.
+-----------------------------+
| SUB(N1,N2) |
+-----------------------------+
Returns N1 - N2.
General Categories: Arithmetic function
Example: SUB(1,8) returns -7.
References: Charniak et al. (1980), 303 (DIFFERENCE).
MTS LISP Manual, 26.
Schank & Riesbeck (1981), 55 (DIFFERENCE).
Shapiro (1979), 150 (DIFFERENCE).
+-----------------------------+
| SUB1(N) |
+-----------------------------+
Returns N - 1.
General Categories: Arithmetic function
Example: SUB1(14) returns 13.
References: Charniak et al. (1980), 309.
MTS LISP Manual, 26.
Shapiro (1979), 155.
AI Programming in SNOBOL4 - 143 - August, 1982
+-----------------------------+
| SUBSET(NAME,L) |
+-----------------------------+
Returns a list of the elements of L for which the function
named NAME returns a non-NIL value.
General Categories: List composition
List decomposition
Mapping function
Example: SUBSET( .ATOMP, #'((A J) (J R) JUDY (SAM SON)
ORVILLE)') returns ('JUDY' ~ 'ORVILLE' ~ NIL).
References: Charniak et al. (1980), 309.
+-----------------------------+
| SUBST(L,X1,X2) |
+-----------------------------+
Returns a copy of L with each occurrence of X1 replaced by X2.
General Categories: List composition
List decomposition
List search
Example: Let L = #'(PAC-MAN (CHOMP CHOMP CHOMP))', X1 =
'CHOMP', and X2 = #'(RUN)'. Then SUBST(L,X1,X2) returns
('PAC-MAN' ~ (('RUN' ~ NIL) ~ ('RUN' ~ NIL) ~ ('RUN' ~ NIL)
~ NIL) ~ NIL).
References: Charniak et al. (1980), 309.
MTS LISP Manual, 20-21 (COPY).
Schank & Riesbeck (1981), 60.
Shapiro (1979), 155.
+-----------------------------+
| SUFLIST(L,N) |
+-----------------------------+
Returns the list obtained by applying the CDR operation N times
to L. If N is zero, L is returned. If N is negative,
PRELIST(L,LENGTH(L) + N) is returned; i.e., RDC is applied N
times to L. If ABS(N) exceeds LENGTH(L), NIL is returned.
AI Programming in SNOBOL4 - 144 - August, 1982
General Categories: List decomposition
List search
Example: If L = #'(A I PROGRAMMING)' then SUFLIST(L,2) returns
('PROGRAMMING' ~ NIL).
References: Charniak et al. (1980), 310.
AI Programming in SNOBOL4 - 145 - August, 1982
+-----------------------------+
| TAN(N) |
+-----------------------------+
Returns the tangent of N radians. N may be any integer or real
number such that COS(N) is different from 0.
General Categories: Arithmetic function
Example: TAN(SQRT(2) * P...I.) returns 3.6202185670771.
References: Gimpel (1976), 332-33j.
+-----------------------------+
| TDUMP(NAME,N) |
+-----------------------------+
Returns nothing: It produces a fatal-error message and
terminates the run.
General Categories: Output
Side Effects: NAME is the name of the function in which the
fatal error occurred. N, which is optional, is the number
of the argument (to NAME) which caused the fatal error.
TDUMP prints a message which gives the name of the function
NAME, the name and value of each argument to NAME, and the
name and value of each local variable in NAME when the error
occurred. If N is specified, then the Nth argument is
flagged (with a row of asterisks to its left) to indicate
that it was the cause of the error.
Finally, TDUMP accepts an integer (0, 1, or 2) from the
user's terminal. (The user is prompted for this.) A zero
indicates that no SPITBOL dump is desired; a 1 requests a 1-
level SPITBOL dump (names and values of all keywords and
natural variables); and a 2 requests a 2-level dump (same as
1, plus array, table, and list elements).
Example: TDUMP(.F9,2) causes a fatal-error message to be
printed, with F9 as the name of the offending function and
with the second argument to F9 flagged as the cause of the
error.
AI Programming in SNOBOL4 - 146 - August, 1982
+-----------------------------+
| TIMES(L) |
+-----------------------------+
Returns the product of the numbers on the list L.
General Categories: Arithmetic function
Example: TIMES( #'(8 7 6 5 4 3 2 1 0)') returns 0.
Comments: Cf. MULT.
References: Charniak et al. (1980), 310.
MTS LISP Manual, 26.
Schank & Riesbeck (1981), 60.
Shapiro (1979), 156.
+-----------------------------+
| *UNCONS(NAME) |
+-----------------------------+
Returns the CAR of the list which is the value of the
identifier named NAME. A synonym for UNCONS is POP.
General Categories: List decomposition
Side Effects: The value of the identifier named NAME becomes
the CDR of its former value.
Example: Let C = #'(F R U I T)'. Then POP( .C) returns 'F',
and the value of C becomes ('R' ~ 'U' ~ 'I' ~ 'T' ~ NIL).
Comments: The value of NAME cannot be a dotted pair or an atom;
if it is, a fatal error results. If the value of NAME is
NIL, then POP fails; this is useful for loop control.
References: Charniak et al. (1980), 34-37, 307.
MTS LISP Manual, 29.
Schank & Riesbeck (1981), 49, 58, 69.
AI Programming in SNOBOL4 - 147 - August, 1982
+-----------------------------+
| UNION(L1,L2) |
+-----------------------------+
Returns a list of the elements which appear in L1 or in L2,
without duplicates.
General Categories: List composition
List decomposition
List search
Example: UNION(#'(Z W X)', #'(8 X R W)') returns ('Z' ~ 'W' ~
'X' ~ 8 ~ 'R' ~ NIL).
References: Charniak et al. (1980), 110-112.
MTS LISP Manual, 21.
Shapiro (1979), 130.
+-----------------------------+
| *UNREAD(L) |
+-----------------------------+
Returns the string expression for the list L, using (more or
less) LISP syntax. Lists and dotted pairs are
parenthesized. Literal atoms containing internal blanks are
enclosed in quotes (") unless they are already enclosed in
quotes.
The unary operator | is OPSYNed to the UNREAD function: !L is
equivalent to UNREAD(L).
General Categories: Datatype conversion
Example: If L = 'L' ~ 'I' ~ 'S' ~ 'T' ~ NIL, then
!L = '(L I S T)'.
References: Charniak et al. (1980).
MTS LISP Manual.
Schank & Riesbeck (1981).
Shapiro (1979).
AI Programming in SNOBOL4 - 148 - August, 1982
+-----------------------------+
| ZERO(N) |
+-----------------------------+
Returns the null string. It succeeds if N is equal to 0; fails
otherwise.
General Categories: Arithmetic function
Predicate
Example: ZERO(11.23581321) fails.
References: Charniak et al. (;980), 310.
MTS LISP Manual, 25.
Shapiro (1979), i56.
+-----------------------------+
| ZEROP(N) |
+-----------------------------+
Returns T if ZERO(N) succeeds; NIL otherwise.
General Categories: Arithmetic function
Predicate
Example: ZEROP(5.0 ~ '5') returns T.
References: See ZERO.
AI Programming in SNOBOL4 - 149 - August, 1982
APPENDIX G
This is a compilation listing of a group of programs which were
used in debugging SNOLISPIST. They illustrate a few of the
system's capabilities, as well as some LISPish programming
techniques (e.g., mapping functions and EVALing expressions).
The test program is designed to run interactively from a
terminal. The tests are largely self-documenting.
*
* To run this test program:
* a) have copies of TEST, SNOLISP/LIB, and SNOLISP/CORE
* under your account;
* b) type
* $RUN *SPITBOL SCARDS=SNOLISP/CORE+TEST PAR=SIZE=64
*
*
* Tests of single-argument numerical functions
* SNOLISPIST
*
1 PAWS = *?( |'' |'Press ENTER to continue.'
+ |'' IN() |(COLLECT() ' bytes available' |'') |'' )
2 DEXP('PAUSE() = EVAL(PAWS)')
*
3 ||''
4 ?( |'Single-argument numerical functions' |'' )
5 |'Incidentally uses MAPC, DEXP with LAMBDA, and EVALCODE'
6 |''
7 MAPC(DEXP('LAMBDA(EXPR) = '
+ '|(" " EVALCODE( |EXPR))' ),
+ 'ABS(-15.9999)' ~
+ 'SIGN(0 - 4444.4444)' ~
+ 'ADD1(-1)' ~
+ 'SUB1(14456.9765)' ~
+ 'FLOAT(13 + 15 + 17)' ~
+ 'DFLOAT(17 - 15 - 13)' ~
+ 'FIX(P...I.)' ~
+ 'MINUS(LN...10.)' ~
+ 'ROUND(-8.5)' ~ NIL)
*
8 PAUSE()
*
*
* Tests of binary numerical functions
* SNOLISPIST
*
*
9 ||''
10 |'Binary numerical functions'
11 |''
12 MAPC(DEXP('LAMBDA(EXPR) = '
+ '|(" " EVALCODE( |EXPR))' ),
+ 'ADD(P...I.,LN...10.)' ~
+ 'SUB(P...I.,LN...10.)' ~
AI Programming in SNOBOL4 - 150 - August, 1982
+ 'MULT(P...I.,LN...10.)' ~
+ 'DIV(P...I.,LN...10.)' ~
+ 'MAX(1,-1)' ~
+ 'MIN(1,-1)' ~
+ 'REMAINDER(-44444444.119)' ~ NIL)
*
13 PAUSE()
*
*
* Tests of list-argument numerical functions
* SNOLISPIST
*
14 ||''
15 |'List-argument numerical functions'
16 |''
17 |'Incidentally uses MAPCAR, LREVERSE, and READ'
18 |''
19 ARGUMENT.LIST =
+ MAPCAR(.DFLOAT,
+ LREVERSE(
+ #'(1 1 2 -3 5 8 -13 21)' ))
20 ?( |'Here is the argument list: ' |'' )
21 |ARGUMENT.LIST
*
22 PAUSE()
*
23 MAPC(DEXP('LAMBDA(FUNCTION) = '
+ '|(" " APPLY( |FUNCTION, ARGUMENT.LIST))' ),
+ .PLUS ~
+ .DIFFERENCE ~
+ .TIMES ~
+ .QUOTIENT ~
+ NIL)
*
24 PAUSE()
*
*
* Tests of extended numerical functions
* SNOLISPIST
*
*
25 |''
26 |'Extended numerical functions'
27 |''
28 ?( |'Testing FLOOR' |'' )
29 AL = #'(-10.9 -7.9 -6.01 -0.00001 0.00001 6.01 7.9 10.9)'
30 |'Argument list = '
31 ?( I(" " !AL) |'' )
32 |MAPCAR(.FLOOR,AL)
*
33 PAUSE()
*
34 |''
35 ?( |'Testing CEIL' |'' )
AI Programming in SNOBOL4 - 151 - August, 1982
36 |'Argument list = '
37 ?( |(" " !AL) |'' )
38 |MAPCAR(.CEIL,AL)
*
39 PAUSE()
*
40 |''
41 ?( |'Testing SQRT by inverse mapping' |'' )
42 AL = #'(1 10 100 1000 10000 100000 1000000 10000000)'
43 |'Argument list = '
44 ?( |(" " !AL) |'' )
45 |MAPCAR(DEXP('LAMBDA(A) = ROUND(A * A)'),
+ MAPCAR(.SQRT,AL))
*
46 PAUSE()
*
47 |''
48 |'Testing trigonometric and inverse trigonometric functions'
49 ?( |(' by inverse mapping') |'' )
50 AL = #( '(0 10 20 30 40 50 60 70 80 90 100 120 '
+ '130 140 150 160 170 180 190 200 210 220 230 240 '
+ '250 260 270 280 290 300 310 320 330 340 350 360)' )
51 |'Argument list = '
52 ?( |(" " !AL) |'' )
53 ?( |'SIN and ASIN' |'' )
54 |MAPCAR(.ROUND,
+ MAPCAR(.DEG,
+ MAPCAR(.ASIN,
+ MAPCAR(.SIN,
+ MAPCAR(.RAD,AL)))))
*
55 PAUSE()
*
56 ?( |'COS and ACOS' |'' )
57 |MAPCAR(.ROUND,
+ MAPCAR(.DEG,
+ MAPCAR(.ACOS,
+ MAPCAR(.COS,
+ MAPCAR(.RAD,AL)))))
*
58 PAUSE()
*
59 ?( |'TAN and ATAN' |'' )
60 |MAPCAR(.ROUND,
+ MAPCAR(.DEG,
+ MAPCAR(.ATAN,
+ MAPCAR(.TAN,
+ MAPCAR(.RAD,AL)))))
*
61 PAUSE()
*
62 |''
63 |'Logarithms to the base 2 of the first 30 powers of 2'
64 |''
AI Programming in SNOBOL4 - 152 - August, 1982
65 I = 0 ; AL = NIL ; TWP = 1
68 TWO.LOOP
69 I = LT(I,30) I + 1 :F(TWO.LOOP.END)
70 TWP = 2 * TWP
71 AL = TWP ~ AL :(TWO.LOOP)
72 TWO.LOOP.END
73 AL = LREVERSE(AL)
*
74 |MAPCAR(DEXP('LAMBDA(Z) = ROUND(LOG(Z,2))'), AL)
*
75 PAUSE()
*
76 |''
77 ?( |'The first 10 powers of e' |'' )
78 |MAPCAR(DEXP('LAMBDA(Z) = RAISE(NAT...BASE.,Z)' ),
+ #'(1 2 3 4 5 6 7 8 9 10)' )
*
79 PAUSE()
*
80 |''
81 ?( |'The first 10 negative powers of e' |'' )
82 |MAPCAR(DEXP('LAMBDA(X) = RAISE(NAT...BASE., -X)' ),
+ #'(1 2 3 4 5 6 7 8 9 10)' )
*
83 PAUSE()
*
*
* Test program for all compound CAR/CDR
* functions in SNOLISPIST
*
84 MNMNM = #'(1 2 3 4)'
*
* Build a reasonably hairy list
*
85 LKLKL = #'((((\MNMNM) \MNMNM) \MNMNM) \MNMNM)'
86 MNMNM = #'(\LKLKL \LKLKL \LKLKL \LKLKL)'
87 LKLKL = LCOPY(MNMNM)
*
88 ||''
89 |('LKLKL = ' !LKLKL)
90 |''
91 MAPC(DEXP('LAMBDA(S) = '
+ '|EVAL( |( "C" S "R(LKLKL)" ))' ),
+ #('(A D AA AD DA DD '
+ ' AAA AAD ADA DAA '
+ ' ADD DAD DDA DDD '
+ ' AAAA AAAD AADA ADAA DAAA '
+ ' AADD ADAD DAAD ADDA DADA DDAA '
+ ' ADDD DADD DDAD DDDA DDDD)' ))
*
92 PAUSE()
*
*
* SNOLISPIST I/O test program
AI Programming in SNOBOL4 - 153 - August, 1982
*
93 A = 'C' ; B = 'L' ; C = 'R'
*
96 (|(11 % 'C.A') |'Centered.' ||'')
97 (|(11 % 'L.B') |'Left justified.' ||'')
98 (|(11 % 'R.C') |'Right justified.' ||'')
99 L = #'(A CENTERED LIST)'
*
100 (|(72 % 'C.L') |'A centered list.' ||'')
*
101 (|'Test of indentation via % operator.' |'')
102 ?( |'Outline Level I' |'' )
103 ?( |(5 % ' ' 'Outline Level I.A') |'' )
104 ?( |(10 % ' ' 'Outline Level I.A.1') |'' )
105 ?( |(15 % ' ' 'Outline Level I.A.1.a') ||'' )
*
106 PAUSE()
*
107 |'Input test: Should print echo of next input line.'
108 |''
109 |IN()
*
110 PAUSE()
*
*
* Tests of recursively defined list processing functIons
* SNOLISPIST
*
*
111 ||''
112 |'Recursively defined list processing functions'
113 |''
114 ?( |'Test LCOPY' |'' )
115 ORIGINAL = #'((O . R) (I . G) (I . N) (A . L))'
116 COPY = LCOPY(ORIGINAL)
117 |'Here is the original:'
118 ?( |(62 % 'C.ORIGINAL') |'' )
119 |'Here is the copy:'
120 ?( |(62 % 'C.COPY') |'' )
121 |'Are they EQU?'
122 ?( |(" " ~EQU(COPY,ORIGINAL) 'No.') |'' )
123 |'Are they EQUAL?'
124 ?( |(" " EQUAL(COPY,ORIGINAL) 'Yes.') |'' )
*
125 PAUSE()
*
126 ?( |'Test SUBST' |'' )
127 TEST.LIST = #'(1 (2) (3 . 4) ((5 . 6) 7) 1 2 3 4 5 6 7)'
128 SUBST.LIST = #'(S I X)'
129 |'Here is the original list:'
130 ?( |(62 % 'C.TEST.LIST') |'' )
131 ?( |'Here is the target sublist: 6' |'' )
132 |'Here is the result:'
133 ?( |(62 % 'C.SUBST(TEST.LIST,6,SUBST.LIST)' ) |'' )
AI Programming in SNOBOL4 - 154 - August, 1982
*
134 PAUSE()
*
135 ?( |'Test REMOVE' |'' )
136 TEST.LIST = #'(A (B (C . D) E (F . G)) H A I R)'
137 REM.LIST = #'(C . D)'
138 |'Here is the test list:'
139 ?( |(62 % 'C.TEST.LIST') |'' )
140 |'Here is the list to be removed:'
141 ?( |(62 % 'C.REM.LIST') |'' )
142 |'Here is the result:'
143 ?( |(62 % 'C.REMOVE(TEST.LIST.REM.LIST)' ) |'' )
*
144 PAUSE()
*
145 ?( |'Test FIND' |'' )
146 TEST.LIST = #'(H A Y ((N . E) (E . D) (L . E)) S T A C K)'
147 FIND.LIST = #'(E . D)'
148 |'Here is the test list:'
149 ?( |(62 % 'C.TEST.LIST') |'' )
150 |'Here is the list to be found:'
151 ?( |(62 % 'C.FIND.LIST') |'' )
152 |'Here is the result:'
153 ?( |(62 % 'C.FIND(FIND.LIST,TEST.LIST)' ) |'' )
*
154 PAUSE()
*
* Tests of miscellaneous list processing functions
* SNOLISPIST
*
155 ||''
156 |'Miscellaneous list processing functions'
157 |''
158 ?( |'Test EXPLODE and READLIST by inverse mapping' |'' )
159 |MAPCAR(.READLIST,
+ MAPCAR(.EXPLODE,
+ #'(1 AARDVARK (SUB LIST) (C (O (MPLEX))))' ))
*
160 PAUSE()
*
161 |''
162 ?( |'Test LENGTH' |'' )
163 |MAPLIST(.LENGTH,
+ EXPLODE('abcdefghijklmnopqrstuvwxyz'))
*
164 PAUSE()
*
165 |''
166 |'Test SETL (SET indirectly)'
167 |''
168 DEFINE('PLACE(CH)A') :(PLACE.END)
169 PLACE
+ &ALPHABET CH @A
170 PLACE = A :(RETURN)
AI Programming in SNOBOL4 - 155 - August, 1982
171 PLACE.END
*
172 DEFINE('INTERLEAVE(L1,L2)LL') :(INTERLEAVE.END)
173 INTERLEAVE
+ LL = NIL
174 INTERLEAVE1
+ LL = POP( .L2) ~ POP( .L1) ~ LL
+ :S(INTERLEAVE1)
175 INTERLEAVE = LREVERSE(LL) :(RETURN)
176 INTERLEAVE.END
*
177 AA = EXPLODE('abcdefghijklmnopqrstuvwxyz')
178 VV = MAPCAR(.PLACE,AA)
179 SETL(INTERLEAVE(AA,VV))
180 MAPC(DEXP('LAMBDA(Z) = '
+ '?|(Z " = " VALUE(Z))' ), AA)
*
181 PAUSE()
*
*
* Tests of set functions on lists
* SNOLISPIST
*
*
182 ||''
183 |'Set functions'
184 |''
185 EVEN = #'(2 4 6 8 10 12 14 16 18 20)'
186 ODD = #'(1 3 5 7 9 11 13 15 17 19)'
187 PRIME = #'(2 3 5 7 11 13 17 19)'
188 FIBONACCI = #'(1 1 2 3 5 8 13)'
189 UNIVERSE = UNION(EVEN,ODD)
190 NON.PRIME = EXCLUDE(UNIVERSE,PRIME)
191 EVEN.PRIME = INTERSECT(EVEN,PRIME)
192 PRIME.FIBO = INTERSECT(PRIME,FIBONACCI)
193 ODD.FIBO = INTERSECT(ODD,FIBONACCI)
194 PRIME.OR.FIBO = UNION(PRIME,FIBONACCI)
195 NEITHER.PRIME.NOR.FIBO = EXCLUDE(UNIVERSE,PRIME.OR.FIBO)
*
196 MAPC(DEXP('LAMBDA(NAME) = |$|( |"" NAME )' ),
+ #( '(EVEN ODD PRIME FIBONACCI UNIVERSE NON.PRIME '
+ 'EVEN.PRIME PRIME.FIBO ODD.FIBO PRIME.OR.FIBO '
+ 'NEITHER.PRIME.NOR.FIBO)' ))
*
197 PAUSE()
*
*
* Tests of some functions for adding to a list
* SNOLISPIST
*
*
198 ||''
199 |'Functions which add elements to lists'
200 |''
AI Programming in SNOBOL4 - 156 - August, 1982
201 LIST1 = EXPLODE('APPEND')
202 LIST2 = EXPLODE('NCONC')
203 LIST3 = EXPLODE('SNOC')
204 LIST4 = EXPLODE('INSERT')
*
205 EXTRA.LIST = EXPLODE('EXTRA')
206 EXTRA.ATOM = CONCAT(EXTRA.LIST)
*
207 ||''
208 ?( |'Test APPEND' |'' )
209 |(62 % 'C.APPEND(LIST1 ~ EXTRA.LIST ~ NIL)' )
*
210 PAUSE()
*
211 ?( |'Test NCONC' |'' )
212 |(62 % 'C.NCONC(LIST2 ~ EXTRA.LIST ~ NIL)' )
*
213 PAUSE()
*
214 ?( |'Test SNOC' |'' )
215 |(62 % 'C.SNOC(LIST3,EXTRA.ATOM)' )
*
216 PAUSE()
*
217 ?( |'Test INSERT' |'' )
218 |(62 % 'C.INSERT("R",LIST4)' )
219 |''
220 |(62 % 'C.INSERT(EXTRA.ATOM,LIST4)' )
*
221 PAUSE()
*
* Tests of replacement functions
* SNOLISPIST
*
*
222 ||''
223 |'Replacement functions'
224 |''
225 LST = READ(
+ '(NOW IS THE TIME FOR ALL GOOD MEN '
+ 'TO COME TO THE AID OF THEIR PARTY)' )
226 |''
227 |'The test list is'
228 ?( |(62 % 'C.LST') |'' )
*
229 PAUSE()
*
230 ?( |'Reverse the CDR' |'' )
231 RPLACD(LST,LREVERSE(CDR(LST)))
232 ?( |(62 % 'C.LST') |'' )
*
233 PAUSE()
*
234 ?( |'Put it back like it was' |'' )
AI Programming in SNOBOL4 - 157 - August, 1982
235 RPLACD(LST,LREVERSE(CDR(LST)))
236 ?( |(62 % 'C.LST') |'' )
*
237 PAUSE()
*
238 ?( |'Use RPLACA to change the first five words' |'' )
239 RPLACA(LST,'Now')
240 RPLACA(CDR(LST),'is')
241 RPLACA(CDDR(LST),'the')
242 RPLACA(CDDDR(LST),'time')
243 RPLACA(CDDDDR(LST),'for')
244 ?( |(62 % 'C.LST') |'' )
*
245 PAUSE()
*
246 ?( |'Change the last five words using RPLACN' |'' )
247 RPLACN(LST,-1,'party?')
248 RPLACN(LST,-2,'their')
249 RPLACN(LST,-3,'of')
250 RPLACN(LST,-4,'aid')
251 RPLACN(LST,-5,'the')
252 ?( |(62 % 'C.LST') |'' )
*
253 PAUSE()
*
254 |'Restore the original list; then reverse each '
255 ?( I(" " 'word, starting with the last.') |'' )
256 LST = READ(
+ '(NOW IS THE TIME FOR ALL GOOD MEN '
+ 'TO COME TO THE AID OF THEIR PARTY)' )
257 |''
258 |'The test list is'
259 ?( |(62 % 'C.LST') |'' )
*
260 PAUSE()
*
261 N = LENGTH(LST)
262 I = 0
263 LUPE
264 I = LT(I,N) I + 1 :F(LUPE.END)
265 K = -I
266 RPLACN(LST,K,REVERSE(CAR(NTH(LST,K))))
267 PRINT(LST) :(LUPE)
268 LUPE.END
+ PAUSE()
*
*
* Tests of sublist functions
* SNOLISPIST
*
*
269 ||''
270 |'Sublist functions'
271 |''
AI Programming in SNOBOL4 - 158 - August, 1982
272 LST = READ(
+ '(NEVER TRY TO GIVE NECESSARY AND SUFFICIENT '
+ 'CONDITIONS FOR ANYTHING -- Linsky)' )
273 |''
274 |'The test list is'
275 PRINT(LST)
276 PAUSE()
*
277 |'The last element is'
278 PRINT(LAST(LST))
*
279 PAUSE()
*
280 ?( |'Here is a vertical listing, using NTH' |'' )
281 N = LENGTH(LST)
282 I = 0
283 LOOP
+ I = LT(I,N) I + 1 :F(LOOP.END)
284 PRINT(CAR(NTH(LST,I))) :(LOOP)
285 LOOP.END PAUSE()
*
286 |''
287 |'The first 8 elements are'
288 PRINT(PRELIST(LST,8))
289 PAUSE()
*
290 |'The tail starting with element 4 is'
291 PRINT(SUFLIST(LST,3))
292 PAUSE()
*
293 |'The sublist consisting of elements 4 through 8 is'
294 PRINT(PRELIST(SUFLIST(LST,3),5))
295 PAUSE()
*
296 |'The RAC is'
297 PRINT(RAC(LST))
298 |'The RDC is'
299 PRINT(RDC(LST))
300 PAUSE()
*
*
* Tests of list searching functions
* SNOLISPIST
*
*
301 ||''
302 |'Searching functions'
303 |''
304 ALIST = READ(
+ '((1 BUN) '
+ '(2 SHOE) '
+ '(3 TREE) '
+ '(4 DOOR BORE SHORE CORE) '
+ '(5 HIVE JIVE) '
AI Programming in SNOBOL4 - 159 - August, 1982
+ '(6 SEX) '
+ '(7 HEAVEN) '
+ '(8 WAIT) '
+ '(9 RESIGN) '
+ '(10 WHEN?) )' )
*
305 |'The test list is'
306 PRINT(ALIST)
307 PAUSE()
*
308 ?( |'NIL followed-by beat poetry' |'' )
309 PRINT(ASSOC(95,ALIST))
310 PRINT(ASSOC(6,ALIST))
311 PRINT(ASSOC(9,ALIST))
312 PRINT(ASSOC(5,ALIST))
313 PRINT(ASSOC(10,ALIST))
*
314 PAUSE()
*
315 MESS = #'(47 ABC XYZ BUN WAIT 5 7 1 3)'
316 |''
317 |'The list of targets for ASSOCL is'
318 |''
319 |'LTRACE is also tested here.'
320 |''
321 PRINT(MESS)
322 PAUSE()
*
323 LTRACE(3, .ASSOCL ~ NIL) ; &TRACE = 10000
325 PRINT(ASSOCL(MESS,ALIST))
326 LTRACE(0, .ASSOCL ~ NIL) ; &TRACE = 0
328 PAUSE()
*
329 |'Here is the tail of MESS starting with BUN'
330 PRINT(MEMBER('BUN',MESS))
331 PAUSE()
*
332 MEMQ('WAIT',MESS) ?|'This line should appear'
333 MEMQ('INCLINE',ALIST) ?|'This line should NOT appear'
*
334 PAUSE()
*
* Tests of mapping functions
* SNOLISPIST
*
*
335 ||''
336 |'Mapping functions'
337 |''
338 ?( |'Unimaginative MAP test' |'' )
339 MAP(.PRINT,#'(A B C D 11 22 33 44 (5 . 5))' )
*
340 PAUSE()
*
AI Programming in SNOBOL4 - 160 - August, 1982
341 ?( |'Unimaginative MAPC test' |'' )
342 MAPC(.PRINT,
+ READ(
+ '(Now is the time for all good men '
+ 'to come to the aid of their party)' ))
*
343 PAUSE()
*
344 ?( |'Unimaginative MAPLIST test' |'' )
345 PRINT(MAPLIST(.LENGTH,
+ #'(10 9 8 7 6 5 4 pi 3 e 2 1 0 BLAST OFF! i)' ))
*
346 PAUSE()
*
347 ?( |'MAPCON test -- What will happen???' |'' )
348 PRINT(MAPCON(.EXPLODE,
+ #'(EVERY GOOD BOY DOES FINE)' ))
*
349 PAUSE()
*
350 ?( |'MAPCAN test -- What wlll happen?????' |'' )
351 PRINT(MAPCAN(.EXPLODE,
+ #'(CINNAMON PERSIMMON SIMIAN)' ))
352 PAUSE()
*
353 |'EVERY test (correct answer = NIL)'
354 PRINT(EVERY(.NUMBERP,
+ #'(5 4 3 2 1 0 X)' ))
*
355 PAUSE()
*
356 |'EVLIS test'
357 |'Correct answer is (1 2 3 (LIST VALUE))'
358 SETL( #'(A 1 B 2 C 3 D (LIST VALUE))' )
359 PRINT(EVLIS(#'(A B C D)' ))
*
360 PAUSE()
*
361 |'SOME test (correct answer = NIL)'
362 PRINT(SOME(.ZEROP,
+ #'(19 9 8 3 6 4 2 \P...I. \LN...10. 66 666 -1)' ))
*
363 PAUSE()
*
364 |'SUBSET test (should print only negative numbers)'
365 PRINT(SUBSET(.NEGP,
+ #'(0 0 0 -1 -2 9 8 6.3 \-P...I. \LN...10. -5)' ))
*
366 PAUSE()
*
*
* Tests of non-numerical Predicates
* SNOLISPIST
*
AI Programming in SNOBOL4 - 161 - August, 1982
367 LLST = #'(A (SMALL (TEST (LIST))))'
368 ||''
369 |'A series of Ts'
370 |''
371 MAPC(DEXP('LAMBDA(EXPR) = |(" " !EVALCODE( |EXPR))' ),
+ '/T' ~
+ 'NULLP(NIL)' ~
+ 'NOTP(NIL)' ~
+ 'ATOMP(13.965)' ~
+ 'NUMBERP(-13.965)' ~
+ 'EQP(13,"13.000000")' ~
+ 'EQUALP(LLST,LCOPY(LLST))' ~
+ NIL)
*
372 PAUSE()
*
373 ||''
374 |'A series of NILs'
375 |''
376 LLST = #'(TWEEDLE (DEE . DUM))'
377 MAPC(DEXP('LAMBDA(EXPR) = |(" " !EVALCOOE( |EXPR))' ),
+ 'NULLP(14 ~ NIL)' ~
+ 'NOTP(1 ~ 1)' ~
+ 'ATOMP(1 ~ 2 ~ 3 ~ NIL)' ~
+ 'NUMBERP("LINDA")' ~
+ 'EQP(LLST,LCOPY(LLST))' ~
+ NIL)
*
378 PAUSE()
*
*
* Tests of numerical predicates
* SNOLISPIST
*
*
379 ||''
380 |'Alternating series of Ts and NILs'
381 |''
382 ?( |'Testing NEGP' |'' )
383 |MAPCAR(.NEGP,
+ #'(-1 2 -3.0 4 -5.00 6.00 -7.7 8.8 -8.999 10.101010)')
*
384 PAUSE()
*
385 ?( |'Testing ZEROP' |'' )
386 |MAPCAR(.ZEROP,
+ #'(0 14 0. -41 0.0 29 -0.0 2.99 00000 99999)')
*
387 PAUSE()
*
388 ?( |'Testing LESSP' |'' )
389 |LESSP( #'( \-P...I. 0.00 0.01 10000000)' )
390 |LESSP( #'( \-LN...10. 0.00 1.01 1.000000)' )
*
AI Programming in SNOBOL4 - 162 - August, 1982
391 PAUSE()
*
392 |'Testing GREATERP.'
393 |''
394 |GREATERP( #'( \P...I. 3.1 -4 -19.84)' )
395 |GREATERP( #'( 6 16 7 17 14.82 )' )
*
396 PAUSE()
*
*
* Tests of the property-list functions
* SNOLISPIST
*
*
397 ||''
398 |'Property list functions'
399 |''
*
*
400 MAPC(DEXP('LAMBDA(XPR) = '
+ '|(" " !EVAL( |( |"" XPR )))' ),
+ 'PUT(.DOG,"NUMBER.OF.LEGS",4)' ~
+ 'GET(.DOG,"NUMBER.OF.LEGS")' ~ 'PAUSE()' ~
+ 'REMPROP(.DOG,"NUMBER.OF.LEGS")' ~
+ 'GET(.DOG,"NUMBER.OF.LEGS")' ~ 'PAUSE()' ~
+ 'PUTL(#"(DOG CAT HORSE)","NUMBER.OF.LEGS",4)' ~
+ 'GET(.DOG,"NUMBER.OF.LEGS")' ~
+ 'GET(.CAT,"NUMBER.OF.LEGS")' ~
+ 'GET(.HORSE,"NUMBER.OF.LEGS")' ~
+ 'GET(.ARMADILLO,"NUMBER.OF.LEGS")' ~ 'PAUSE()' ~
+ 'PUTPROP(.DOG,3,"LEGS")' ~
+ 'PUTPROP(.DOG,2,"LEGS")' ~
+ 'PUTPROP(.DOG,1,"LEGS")' ~
+ 'PUTPROP(.DOG,1,"HEAD")' ~
+ 'GETL(.DOG,#"(LEGS HEAD)")' ~
+ 'GETL(.DOG,#"(HEAD)")' ~ 'PAUSE()' ~
+ 'ADDPROP(.DOG,3,"LEGS")' ~
+ 'GET(.DOG,"LEGS")' ~
+ 'ADDPROP(.DOG,"ANOMALY","LEGS")' ~
+ 'GET(.DOG,"LEGS")' ~ 'PAUSE()' ~
+ 'DEFPROP(.FISH,0,"LEGS")' ~
+ 'GETL(.FISH,#"(EYES ARMS TEETH LEGS)")' ~
+ NIL )
*
401 PAUSE()
*
*
402 |''
403 ?( |'Empty all property stacks' |'' )
404 ?( |'DOG -- "LEGS"' |'' )
*
405 LOOP1 TEMP = GETPROP( .DOG, 'LEGS' )
406 ?( PRINT(TEMP) DIFFER(TEMP,NIL) ) :S(LOOP1)
407 |''
AI Programming in SNOBOL4 - 163 - August, 1982
408 PAUSE()
409 ?( |'DOG -- "NUMBER.OF.LEGS"' |'' )
410 LOOP2 TEMP = GETPROP( .DOG, 'NUMBER.OF.LEGS' )
411 ?( PRINT(TEMP) DIFFER(TEMP,NIL) ) :S(LOOP2)
412 |''
413 PAUSE()
414 ?( |'DOG -- "HEAD"' |'' )
415 LOOP3 TEMP = GETPROP( .DOG, 'HEAD' )
416 ?( PRINT(TEMP) DIFFER(TEMP,NIL) ) :S(LOOP3)
417 |''
418 PAUSE()
419 |'CAT -- "NUMBER.OF.LEGS"'
420 LOOP4 TEMP = GETPROP( .CAT, 'NUMBER.OF.LEGS' )
421 ?( PRINT(TEMP) DIFFER(TEMP,NIL) ) :S(LOOP4)
422 |''
423 PAUSE()
424 ?( |'FISH -- "LEGS"' |'' )
425 LOOP5 TEMP = GETPROP( .FISH, 'LEGS' )
426 ?( PRINT(TEMP) DIFFER(TEMP,NIL) ) :S(LOOP5)
427 |''
428 PAUSE()
429 ?( |'HORSE -- "NUMBER.OF.LEGS"' |'' )
430 LOOP6 TEMP = GETPROP( .HORSE, 'NUMBER.OF.LEGS' )
431 ?( PRINT(TEMP) DIFFER(TEMP,NIL) ) :S(LOOP6)
*
432 PAUSE()
*
433 ||''
434 ?( |'A combined test of CLA, CAL, and SORT' |'' )
435 ?( |'Should print ABDENWSSREBA' |'' )
436 L = CLA(EXPLODE('BADNEWSBEARS'))
437 SORT(L,7,12,'LGE')
438 SORT(L,1,6,'LLE')
439 |READLIST(CAL(L))
*
440 PAUSE()
*
441 ||''
442 |'A further test of SORT/CAL/CLA:'
443 |'Make anagrams out of some six-letter names by'
444 |'alphabetizing their letters.'
445 |''
446 MAPC(
+ DEXP(
+ 'LAMBDA(X) = '
+ 'PRINT('
+ 'CONCAT('
+ 'CAL('
+ 'SORT(CLA(EXPLODE(X)),1,6,.LLE) )))' ),
+ ('MARVIN' ~
+ 'PACMAN' ~
+ 'LOLITA' ~
+ 'MERLIN' ~
+ 'ELIJAH' ~
AI Programming in SNOBOL4 - 164 - August, 1982
+ 'SHAFTO' ~
+ 'SYLVIA' ~
+ 'ITALIA' ~
+ 'GEORGE' ~
+ 'GIMPEL' ~
+ 'BACKUS' ~ NIL) )
*
447 PAUSE()
*
448 ||''
449 |'TDUMP test: Should print suitable error message.'
450 |''
451 |(72 % 'C.a=b+c?')
452 END
AI Programming in SNOBOL4 - 165 - August, 1982
APPENDIX H
This is a compilation listing of a version of Bertram Raphael's
SIR (Semantic Information Retrieve) program. This version of the
program is an almost literal SNOBOL4 translation of Shapiro's
(1979, pp. 123-138) LISP version. This SNOBOL4 version has been
tested on Shapiro's (138-140) test dialogue.
* This version of Bertram Raphael's SIR program
* was translated into SNOBOL4 using the SNOLISPIST
* list processing routines.
*
* This program follows closely the LISP version by
* S. Shapiro (Techniques of Artificial Intelligence,
* 1979, pp. 123-140.
*
* To run the program:
* a) have copies of SIR, SNOLISP/CORE, and SNOLISP/LIB
* under your account:
* b) type $RUN *SPITBOL SCARDS=SNOLISP/CORE+SIR PAR=SIZE=64
*
*
1 DEFINE('SIR()S') :(SIR.END)
2 SIR S = GET.SENTENCE() :F(FRETURN)
3 SIR = EQU(CAR(S),"BYE") "GOOD-BYE" :S(RETURN)
4 PROCESS(S) :S(SIR)F(FRETURN)
5 SIR.END
*
6 DEFINE('GET.SENTENCE()S,P') :(GET.SENTENCE.END)
7 GET.SENTENCE S = S " " IN() :F(FRETURN)
8 S RPOS(1) ANY("!?") . P = " " P
+ :F(GET.SENTENCE)
9 GET.SENTENCE = READ( "(" S ")" ) :S(RETURN)F(FRETURN)
10 GET.SENTENCE.END
*
11 DEXP('PROCESS(SENTENCE) = PROCESS.1(SENTENCE,RULE.LIST)')
*
12 DEFINE('PROCESS.1(SENTENCE,RULES)RESP,CA')
+ :(PROCESS.1.END)
13 PROCESS.1 CA = POP( .RULES) :F(PROCESS.1.ERR)
14 RESP = APPLY.RULE(CA,SENTENCE)
15 IDENT(RESP,NIL) :S(PROCESS.1)
16 PROCESS.1 = |RESP :(RETURN)
17 PROCESS.1.ERR
+ |"STATEMENT FORM NOT RECOGNIZED."
18 |" IN PROCESS.1, "
19 |(" SENTENCE = " CONCAT(SENTENCE," ")) :(RETURN)
20 PROCESS.1.END
*
21 DATA('RULE(PATTERN,VARIABLES,TESTS,ACTION)')
*
22 DEFINE('APPLY.RULE(RULE,INP)') :(APPLY.RULE.END)
23 APPLY.RULE APPLY.RULE = NIL
AI Programming in SNOBOL4 - 166 - August, 1982
24 APPLY.RULE =
+ DIFFER(NIL,MATCH(INP,PATTERN(RULE),VARIABLES(RULE)))
+ APPLY.RULE.1(
+ APPLY.TESTS(TESTS(RULE),EVLIS(VARIABLES(RULE))),
+ ACTION(RULE)) :(RETURN)
25 APPLY.RULE.END
*
26 DEFINE('MATCH(INP,PAT,VARS)') :(MATCH.END)
27 MATCH ATOM(PAT) :S(MATCH.A)
28 INITIALIZE(VARS)
29 MATCH.FLAG = MATCH1(INP,PAT,VARS)
30 MATCH.A MATCH = MATCH.FLAG :(RETURN)
31 MATCH.END
*
32 DEXP('INITIALIZE(LVARS) = MAPC( .'
+ DEXP('LAMBDA(LAMBDA...V) = SET(LAMBDA...V,NIL)')
+ ',LVARS)')
*
33 DEFINE('MATCH1(INP,PAT,VARS)CA') :(MATCH1.END)
34 MATCH1 MATCH1 = NULL(INP) NULLP(PAT) :S(RETURN)
35 MATCH1 = NULL(PAT) NIL :S(RETURN)
36 CA = CAR(PAT)
37 MEMQ(CA,VARS) :F(MATCH1A)
38 MATCH1 = NULL( CDR(PAT))
+ SET(CA,APPEND($CA ~ INP ~ NIL))
+ :S(RETURN)
39 MATCH1 = EQU(CAR(INP),CADR(PAT))
+ MATCH1(CDR(INP),CDDR(PAT),VARS)
+ :S(RETURN)
40 MATCH1 = DIFFER(NIL,SET(CA,SNOC($CA,CAR(INP))))
+ MATCH1(CDR(INP),PAT,VARS) :(RETURN)
41 MATCH1A MATCH1 = EQU(CAR(INP),CA)
+ MATCH1(CDR(INP),CDR(PAT),VARS)
+ :S(RETURN)
42 MATCH1 = NIL :(RETURN)
43 MATCH1.END
*
44 DEFINE('APPLY.TESTS(TESTS,PHRASES)L') :(APPLY.TESTS.END)
45 APPLY.TESTS APPLY.TESTS = NIL
46 L = NIL
47 APPLY.TESTS1 L = DIFFER(NIL,PHRASES) DIFFER(NIL,TESTS)
+ APPLY(CAR(TESTS),CAR(PHRASES)) ~ L :F(RETURN)
48 DIFFER(NIL,CAR(L)) ?POP( .TESTS) ?POP( .PHRASES)
+ :F(RETURN)
49 APPLY.TESTS = NULL(TESTS) NULL(PHRASES)
+ LREVERSE(L) :S(RETURN)F(APPLY.TESTS1)
50 APPLY.TESTS.END
*
51 DEFINE('APPLY.RULE.1(L,ACT)XPR') :(APPLY.RULE.1.END)
52 APPLY.RULE.1
+ APPLY.RULE.1 = NULL(L) NIL :S(RETURN)
53 XPR =
+ CAR(ACT) '('
+ CONCAT( RMAPCAR( L, CDR(ACT)), ',', '"') ')'
AI Programming in SNOBOL4 - 167 - August, 1982
54 APPLY.RULE.1 = EVALCODE(XPR) :(RETURN)
55 APPLY.RULE.1.END
*
56 DEFINE('RMAPCAR(S,LF)F') :(RMAPCAR.END)
57 RMAPCAR RMAPCAR = NIL
58 RMAPCAR1 F = POP( .LF) :F(RMAPCAR2)
59 RMAPCAR = APPLY(F,S) ~ RMAPCAR :(RMAPCAR1)
60 RMAPCAR2 RMAPCAR = LREVERSE(RMAPCAR) :(RETURN)
61 RMAPCAR.END
*
62 DEFINE('ADDXRY(X,REL,Y)') :(ADDXRY.END)
63 ADDXRY ADDXRY = MEMQ(Y,GET(X,REL)) NIL :S(RETURN)
64 ADDXRY = PUTPROP(X,Y,REL) :(RETURN)
65 ADDXRY.END OPSYN( .ADDYRX, .ADDXRY)
66 DEXP('PATH(PATH...X,PATH...R,PATH...Y) = '
+ 'MEMQ( $PATH...Y,'
+ 'PATH1( $PATH...X ~ NIL, PATH...R))')
*
67 DEFINE('PATH1(LN,LR)') :(PATH1.END)
68 PATH1 DIFFER(NIL,LN) DIFFER(NIL,LR) :F(PATH1C)
69 DIFFER(NIL,CDR(LR)) MEMQ(CADR(LR),"*" ~ "+" ~ NIL)
+ :F(PATH1A)
70 LN = EXTENDM(CADR(LR),LN,CAR(LR))
71 LR = CDR(LR) :(PATH1B)
72 PATH1A LN = EXTEND(LN,CAR(LR))
73 PATH1B LR = CDR(LR) :(PATH1)
74 PATH1C PATH1 = LN :(RETURN)
75 PATH1.END
*
76 DEFINE('EXTENDM(OP,LN,R)') :(EXTENDM.END)
77 EXTENDM LN = IDENT(OP,"+") EXTEND(LN,R)
78 EXTENDM = LN
79 EXTENDM1 DIFFER(NIL,LN) :F(RETURN)
80 LN = COMPLEMENT(EXTEND(LN,R),EXTENDM)
81 EXTENDM = APPEND(EXTENDM ~ LN ~ NIL) :(EXTENDM1)
82 EXTENDM.END
*
83 DEFINE('EXTEND(LN,R)') :(EXTEND.END)
84 EXTEND EXTEND = NULL(LN) NIL :S(RETURN)
85 EXTEND = ~ATOM(R) PATH1(LN,R) :S(RETURN)
86 EXTEND = UNION(GET(CAR(LN),R),
+ EXTEND(CDR(LN),R)) :(RETURN)
87 EXTEND.END
*
88 OPSYN( .COMPLEMENT, .EXCLUDE)
*
89 G.DETS = READ( "(EACH EVERY ANY A AN)" )
90 S.DETS = READ( "(THE)" )
*
91 DEXP('UNIQUE(NP) = NIL ; UNIQUE = '
+ 'NULL(CDR(NP)) CAR(NP) ; ')
*
92 DEXP('GENERIC(NP) = NIL ; GENERIC = '
+ 'MEMQ(CAR(NP),G.DETS) RAC(NP) ; ')
AI Programming in SNOBOL4 - 168 - August, 1982
*
93 DEXP('SPECIFIC(NP) = NIL ; SPECIFIC = '
+ 'MEMQ(CAR(NP),S.DETS) RAC(NP) ; ')
*
94 DEXP('UNIQUE.GENERIC(NPNP) = '
+ 'APPLY.TESTS( #"(UNIQUE GENERIC)", SPLIT(NPNP,G.DETS))')
*
95 DEXP('SPECIFIC.GENERIC(NPNP) = '
+ 'APPLY.TESTS( #"(SPECIFIC GENERIC)", SPLIT(NPNP,G.DETS))')
*
96 DEXP('GENERIC.GENERIC(NPNP) = '
+ 'APPLY.TESTS( #"(GENERIC GENERIC)", SPLIT(NPNP,G.DETS))')
*
97 DEXP('SPLIT(SNP.LD) = SPLIT1(CDR(SNP),LD,CAR(SNP) ~'
+ 'NIL,NIL)')
*
98 DEFINE('SPLIT1(SNP,LD,NP,LNP)') :(SPLIT1.END)
99 SPLIT1 SPLIT1 =
+ NULL(SNP) LREVERSE( LREVERSE(NP) ~ LNP) :S(RETURN)
100 SPLIT1 = MEMQ(CAR(SNP),LD)
+ SPLIT1(CDR(SNP),LD,CAR(SNP) ~ NIL,
+ LREVERSE(NP) ~ LNP) :S(RETURN)
101 SPLIT1 =
+ SPLIT1( CDR(SNP), LD, CAR(SNP) ~ NP, LNP)
+ :(RETURN)
102 SPLIT1.END
*
* Some responses returned from semantic routines
*
103 UNDERSTAND = "I UNDERSTAND."
104 YES = "YES."
105 SOMETIMES = "SOMETIMES."
106 INSUFFICIENT = "INSUFFICIENT INFORMATION"
107 SILENCE = ""
*
108 DEFINE('SETR(X,Y)') :(SETR.END)
109 SETR ADDXRY(X,"SUBSET",Y)
110 ADDYRX(Y,"SUPERSET",X)
111 SETR = UNDERSTAND :(RETURN)
112 SETR.END
*
113 DEFINE('SETRQ(X,Y)') :(SETRQ.END)
114 SETRQ SETRQ = PATH( .X, #"(SUBSET *)", .Y) YES
+ :S(RETURN)
115 SETRQ = PATH( .Y, #"(SUBSET +)", .X) SOMETIMES
+ :S(RETURN)
116 SETRQ = INSUFFICIENT :(RETURN)
117 SETRQ.END
*
118 DEFINE('SETRS(X,Y)') :(SETRS.END)
119 SETRS ADDXRY(X,"MEMBER",Y)
120 ADDYRX(Y,"ELEMENTS",X)
121 SETRS = UNDERSTAND :(RETURN)
122 SETRS.END
AI Programming in SNOBOL4 - 169 - August, 1982
*
123 DEFINE('SETRSQ(X,Y)') :(SETRSQ.END)
124 SETRSQ SETRSQ =
+ PATH( .X, #"(EQUIV * MEMBER SUBSET *)", .Y) YES
+ :S(RETURN)
125 SETRSQ = INSUFFICIENT :(RETURN)
126 SETRSQ.END
*
127 DEFINE('SETRS1(X,Y)') :(SETRS1.END)
128 SETRS1 SETRS1 = DIFFER(NIL,SET(.X,SPECIFY(X)))
+ SETRS(X,Y) :S(RETURN)
129 SETRS1 = SILENCE :(RETURN)
130 SETRS1.END
*
131 DEXP('SPECIFY(X) = '
+ 'SPECIFY1(EQUIV.COMPRESS(GET(X,"ELEMENTS")),X)')
*
132 DEFINE('SPECIFY1(U,X)') :(SPECIFY1.END)
133 SPECIFY1 NULL(U) :F(SPECIFY1A)
134 SPECIFY1 = SET( .U, GENSYM())
135 SETRS(U,X)
136 |(U " IS A " X ".") :(RETURN)
137 SPECIFY1A
+ SPECIFY1 = NULL(CDR(U)) CAR(U) :S(RETURN)
138 |("WHICH " X "? ... " !U)
139 SPECIFY1 = NIL :(RETURN)
140 SPECIFY1.END
*
141 DEXP('EQUIV.COMPRESS(LX) = EQUIV.COMP1(LX,NIL)')
*
142 DEFINE('EQUIV.COMP1(LX,LEX)') :(EQUIV.COMP1.END)
143 EQUIV.COMP1
+ EQUIV.COMP1 = NULL(LX) NIL :S(RETURN)
144 EQUIV.COMP1 = MEMQ(CAR(LX),LEX)
+ EQUIV.COMP1(CDR(LX),LEX) :S(RETURN)
145 EQUIV.COMP1 =
+ CAR(LX) ~
+ EQUIV.COMP1( CDR(LX),
+ APPEND( GET(CAR(LX),"EQUIV") ~ LEX ~ NIL))
+ :(RETURN)
146 EQUIV.COMP1.END
*
147 DEFINE('SETRS1Q(X,Y)') :(SETRS1Q.END)
148 SETRS1Q SETRS1Q = DIFFER(NIL,SET(.X,SPECIFY(X)))
+ SETRSQ(X,Y) :S(RETURN)
149 SETRS1Q = SILENCE :(RETURN)
150 SETRS1Q.END
*
151 DEFINE('EQUIV(X,Y)') :(EQUIV.END)
152 EQUIV ADDXRY(X,"EQUIV",Y)
153 ADDYRX(Y,"EQUIV",X)
154 EQUIV = UNDERSTAND :(RETURN)
155 EQUIV.END
*
AI Programming in SNOBOL4 - 170 - August, 1982
156 DEFINE('EQUIV1(X,Y)') :(EQUIV1.END)
157 EQUIV1 EQUIV1 = DIFFER(NIL,SET(.Y,SPECIFY(Y)))
+ EQUIV(X,Y) :S(RETURN)
158 EQUIV1 = SILENCE :(RETURN)
159 EQUIV1.END
*
160 DEFINE('OWNR(X,Y)') :(OWNR.END)
161 OWNR ADDXRY(X,"OWNED.BY",Y)
162 ADDYRX(Y,"POSSESS.BY.EACH",X)
163 OWNR = UNDERSTAND :(RETURN)
164 OWNR.END
*
165 DEFINE('OWNRQ(X,Y)') :(OWNRQ.END)
166 OWNRQ OWNRQ = EQU(X,Y)
+ "NO, THEY ARE THE SAME." :S(RETURN)
167 OWNRQ = PATH( .Y, #"(SUBSET * POSSESS.BY.EACH)", .X)
+ YES :S(RETURN)
168 OWNRQ = INSUFFICIENT :(RETURN)
169 OWNRQ.END
*
170 DEFINE('OWNRGU(X,Y)') :(OWNRGU.END)
171 OWNRGU ADDYRX(Y,"POSSESS",X)
172 ADDXRY(X,"OWNED",Y)
173 OWNRGU = UNDERSTAND :(RETURN)
174 OWNRGU.END
*
175 DEFINE('OWNRGUQ(X,Y)') :(OWNRGUQ.END)
176 OWNRGUQ OWNRGUQ =
+ PATH( .Y, #"(EQUIV * POSSESS SUBSET *)", .X)
+ YES :S(RETURN)
177 OWNRGUQ =
+ PATH( .Y, #("(EQUIV * MEMBER SUBSET *"
+ " POSSESS.BY.EACH SUBSET *)"), .X)
+ YES :S(RETURN)
178 OWNRGUQ = INSUFFICIENT :(RETURN)
179 OWNRGUQ.END
*
180 DEFINE('OWNRSGQ(X,Y)') :(OWNRSGQ.END)
181 OWNRSGQ OWNRSGQ = IDENT(NIL,SPECIFY(X)) SILENCE :S(RETURN)
182 OWNRSGQ =
+ PATH( .X, #"(OWNED EQUIV * MEMBER SUBSET *)", .Y)
+ YES :S(RETURN)
183 OWNRSGQ = INSUFFICIENT :(RETURN)
184 OWNRSGQ.END
*
185 DEFINE('MAKE.RULES(STL)ST,R') :(MAKE.RULES.END)
186 MAKE.RULES MAKE.RULES = NIL
187 MAKE.RULES1 ST = POP( .STL) :F(MAKE.RULES2)
188 ST = READ( "(" ST ")" )
189 R = RULE(CAR(ST),CADR(ST),CADDR(ST),CADDDR(ST))
190 MAKE.RULES = R ~ MAKE.RULES :(MAKE.RULES1)
191 MAKE.RULES2 MAKE.RULES = LREVERSE(MAKE.RULES) :(RETURN)
192 MAKE.RULES.END
*
AI Programming in SNOBOL4 - 171 - August, 1982
193 RULE.LIST = MAKE.RULES(
+ '(IS *X* ?) (*X*) (UNIQUE.GENERIC) (SETRSQ CAAR CADAR)' ~
+ ' - (*X*) (SPECIFIC.GENERIC) (SETRS1Q CAAR CADAR)' ~
+ ' - (*X*) (GENERIC.GENERIC) (SETRQ CAAR CADAR)' ~
+ '(DOES *X* OWN *Y* ?) (*X* *Y*) (GENERIC GENERIC) '
+ '(OWNRQ CADR CAR)' ~
+ ' - (*X* *Y*) (UNIQUE GENERIC) (OWNRGUQ CADR CAR)' ~
+ ' - (*X* *Y*) (GENERIC SPECIFIC) (OWNRSGQ CADR CAR)' ~
+ '(*X* IS *Y* !) (*X* *Y*) (UNIQUE GENERIC) '
+ '(SETRS CAR CADR)' ~
+ ' - (*X* *Y*) (GENERIC GENERIC) (SETR CAR CADR)' ~
+ ' - (*X* *Y*) (SPECIFIC GENERIC) (SETRS1 CAR CADR)' ~
+ ' - (*X* *Y*) (UNIQUE UNIQUE) (EQUIV CAR CADR)' ~
+ ' - (*X* *Y*) (UNIQUE SPECIFIC) (EQUIV1 CAR CADR)' ~
+ ' - (*X* *Y*) (SPECIFIC UNIQUE) (EQUIV1 CADR CAR)' ~
+ '(*X* OWNS *Y* !) (*X* *Y*) (GENERIC GENERIC) '
+ '(OWNR CADR CAR)' ~
+ ' - (*X* *Y*) (UNIQUE GENERIC) (OWNRGU CADR CAR)' ~
+ NIL)
*
194 |("THE SIR PROGRAM STARTS WITH " COLLECT() " BYTES.")
195 |SIR()
196 END
AI Programming in SNOBOL4 - 172 - August, 1982
