►How to Design Programs Languages
▼2 Beginning Student with List Abbreviations
►2.3 Primitive Operations
On this page:
2.3.1 Numbers: Integers, Rationals, Reals, Complex, Exacts, Inexacts
*
+
-
/
<
<=
=
>
>=
abs
acos
add1
angle
asin
atan
ceiling
complex?
conjugate
cos
cosh
current-seconds
denominator
e
even?
exact->inexact
exact?
exp
expt
floor
gcd
imag-part
inexact->exact
inexact?
integer->char
integer-sqrt
integer?
lcm
log
magnitude
make-polar
make-rectangular
max
min
modulo
negative?
number->string
number?
numerator
odd?
pi
positive?
quotient
random
rational?
real-part
real?
remainder
round
sgn
sin
sinh
sqr
sqrt
sub1
tan
zero?
2.3.2 Booleans
boolean=?
boolean?
false?
not
2.3.3 Symbols
symbol->string
symbol=?
symbol?
2.3.4 Lists
append
assq
caaar
caadr
caar
cadar
cadddr
caddr
cadr
car
cdaar
cdadr
cdar
cddar
cdddr
cddr
cdr
cons
cons?
eighth
empty?
fifth
first
fourth
length
list
list*
list-ref
make-list
member
member?
memq
memv
null
null?
pair?
remove
rest
reverse
second
seventh
sixth
third
2.3.5 Posns
make-posn
posn
posn-x
posn-y
posn?
2.3.6 Characters
char->integer
char-alphabetic?
char-ci<=?
char-ci<?
char-ci=?
char-ci>=?
char-ci>?
char-downcase
char-lower-case?
char-numeric?
char-upcase
char-upper-case?
char-whitespace?
char<=?
char<?
char=?
char>=?
char>?
char?
2.3.7 Strings
explode
format
implode
int->string
list->string
make-string
replicate
string
string->int
string->list
string->number
string->symbol
string-alphabetic?
string-append
string-ci<=?
string-ci<?
string-ci=?
string-ci>=?
string-ci>?
string-copy
string-ith
string-length
string-lower-case?
string-numeric?
string-ref
string-upper-case?
string-whitespace?
string<=?
string<?
string=?
string>=?
string>?
string?
substring
2.3.8 Images
image=?
image?
2.3.9 Misc
=~
eof
eof-object?
eq?
equal?
equal~?
eqv?
error
exit
identity
struct?
  top← prev  up  next → 

2.3 Primitive Operations

2.3.1 Numbers: Integers, Rationals, Reals, Complex, Exacts, Inexacts

* : (number number number ... -> number)
Purpose: to compute the product of all of the input numbers
+ : (number number number ... -> number)
Purpose: to compute the sum of the input numbers
- : (number number ... -> number)
Purpose: to subtract the second (and following) number(s) from the first; negate the number if there is only one argument
/ : (number number number ... -> number)
Purpose: to divide the first by the second (and all following) number(s); try (/ 3 4) and (/ 3 2 2) only the first number can be zero.
< : (real real real ... -> boolean)
Purpose: to compare real numbers for less-than
<= : (real real real ... -> boolean)
Purpose: to compare real numbers for less-than or equality
= : (number number number ... -> boolean)
Purpose: to compare numbers for equality
> : (real real real ... -> boolean)
Purpose: to compare real numbers for greater-than
>= : (real real ... -> boolean)
Purpose: to compare real numbers for greater-than or equality
abs : (real -> real)
Purpose: to compute the absolute value of a real number
acos : (number -> number)
Purpose: to compute the arccosine (inverse of cos) of a number
add1 : (number -> number)
Purpose: to compute a number one larger than a given number
angle : (number -> real)
Purpose: to extract the angle from a complex number
asin : (number -> number)
Purpose: to compute the arcsine (inverse of sin) of a number
atan : (number -> number)
Purpose: to compute the arctan (inverse of tan) of a number
ceiling : (real -> integer)
Purpose: to determine the closest integer (exact or inexact) above a real number
complex? : (any -> boolean)
Purpose: to determine whether some value is complex
conjugate : (number -> number)
Purpose: to compute the conjugate of a complex number
cos : (number -> number)
Purpose: to compute the cosine of a number (radians)
cosh : (number -> number)
Purpose: to compute the hyperbolic cosine of a number
current-seconds : (-> integer)
Purpose: to compute the current time in seconds elapsed (since a platform-specific starting date)
denominator : (rat -> integer)
Purpose: to compute the denominator of a rational
e : real
Purpose: Euler’s number
even? : (integer -> boolean)
Purpose: to determine if some integer (exact or inexact) is even or not
exact->inexact : (number -> number)
Purpose: to convert an exact number to an inexact one
exact? : (number -> boolean)
Purpose: to determine whether some number is exact
exp : (number -> number)
Purpose: to compute e raised to a number
expt : (number number -> number)
Purpose: to compute the power of the first to the second number
floor : (real -> integer)
Purpose: to determine the closest integer (exact or inexact) below a real number
gcd : (integer integer ... -> integer)
Purpose: to compute the greatest common divisior of two integers (exact or inexact)
imag-part : (number -> real)
Purpose: to extract the imaginary part from a complex number
inexact->exact : (number -> number)
Purpose: to approximate an inexact number by an exact one
inexact? : (number -> boolean)
Purpose: to determine whether some number is inexact
integer->char : (integer -> char)
Purpose: to lookup the character that corresponds to the given integer (exact only!) in the ASCII table (if any)
integer-sqrt : (number -> integer)
Purpose: to compute the integer (exact or inexact) square root of a number
integer? : (any -> boolean)
Purpose: to determine whether some value is an integer (exact or inexact)
lcm : (integer integer ... -> integer)
Purpose: to compute the least common multiple of two integers (exact or inexact)
log : (number -> number)
Purpose: to compute the base-e logarithm of a number
magnitude : (number -> real)
Purpose: to determine the magnitude of a complex number
make-polar : (real real -> number)
Purpose: to create a complex from a magnitude and angle
make-rectangular : (real real -> number)
Purpose: to create a complex from a real and an imaginary part
max : (real real ... -> real)
Purpose: to determine the largest number
min : (real real ... -> real)
Purpose: to determine the smallest number
modulo : (integer integer -> integer)
Purpose: to find the remainder of the division of the first number by the second; try (modulo 4 3) (modulo 4 -3)
negative? : (number -> boolean)
Purpose: to determine if some value is strictly smaller than zero
number->string : (number -> string)
Purpose: to convert a number to a string
number? : (any -> boolean)
Purpose: to determine whether some value is a number
numerator : (rat -> integer)
Purpose: to compute the numerator of a rational
odd? : (integer -> boolean)
Purpose: to determine if some integer (exact or inexact) is odd or not
pi : real
Purpose: the ratio of a circle’s circumference to its diameter
positive? : (number -> boolean)
Purpose: to determine if some value is strictly larger than zero
quotient : (integer integer -> integer)
Purpose: to divide the first integer (exact or inexact) into the second; try (quotient 3 4) and (quotient 4 3)
random : (integer -> integer)
Purpose: to generate a random natural number less than some given integer (exact only!)
rational? : (any -> boolean)
Purpose: to determine whether some value is a rational number
real-part : (number -> real)
Purpose: to extract the real part from a complex number
real? : (any -> boolean)
Purpose: to determine whether some value is a real number
remainder : (integer integer -> integer)
Purpose: to determine the remainder of dividing the first by the second integer (exact or inexact)
round : (real -> integer)
Purpose: to round a real number to an integer (rounds to even to break ties)
sgn : (real -> (union 1 1.0 0 0.0 -1 -1.0))
Purpose: to compute the sign of a real number
sin : (number -> number)
Purpose: to compute the sine of a number (radians)
sinh : (number -> number)
Purpose: to compute the hyperbolic sine of a number
sqr : (number -> number)
Purpose: to compute the square of a number
sqrt : (number -> number)
Purpose: to compute the square root of a number
sub1 : (number -> number)
Purpose: to compute a number one smaller than a given number
tan : (number -> number)
Purpose: to compute the tangent of a number (radians)
zero? : (number -> boolean)
Purpose: to determine if some value is zero or not

2.3.2 Booleans

boolean=? : (boolean boolean -> boolean)
Purpose: to determine whether two booleans are equal
boolean? : (any -> boolean)
Purpose: to determine whether some value is a boolean
false? : (any -> boolean)
Purpose: to determine whether a value is false
not : (boolean -> boolean)
Purpose: to compute the negation of a boolean value

2.3.3 Symbols

symbol->string : (symbol -> string)
Purpose: to convert a symbol to a string
symbol=? : (symbol symbol -> boolean)
Purpose: to determine whether two symbols are equal
symbol? : (any -> boolean)
Purpose: to determine whether some value is a symbol

2.3.4 Lists

append : 
((listof any)
 (listof any)
 (listof any)
 ...
 ->
 (listof any))
Purpose: to create a single list from several, by juxtaposition of the items
assq : 
(X
 (listof (cons X Y))
 ->
 (union false (cons X Y)))
Purpose: to determine whether some item is the first item of a pair in a list of pairs
caaar : 
((cons
  (cons (cons W (listof Z)) (listof Y))
  (listof X))
 ->
 W)
Purpose: to select the first item of the first list in the first list of a list
caadr : 
((cons
  (cons (cons W (listof Z)) (listof Y))
  (listof X))
 ->
 (listof Z))
Purpose: to select the rest of the first list in the first list of a list
caar : ((cons (cons Z (listof Y)) (listof X)) -> Z)
Purpose: to select the first item of the first list in a list
cadar : 
((cons (cons W (cons Z (listof Y))) (listof X))
 ->
 Z)
Purpose: to select the second item of the first list of a list
cadddr : ((listof Y) -> Y)
Purpose: to select the fourth item of a non-empty list
caddr : ((cons W (cons Z (cons Y (listof X)))) -> Y)
Purpose: to select the third item of a non-empty list
cadr : ((cons Z (cons Y (listof X))) -> Y)
Purpose: to select the second item of a non-empty list
car : ((cons Y (listof X)) -> Y)
Purpose: to select the first item of a non-empty list
cdaar : 
((cons
  (cons (cons W (listof Z)) (listof Y))
  (listof X))
 ->
 (listof Z))
Purpose: to select the rest of the first list in the first list of a list
cdadr : 
((cons W (cons (cons Z (listof Y)) (listof X)))
 ->
 (listof Y))
Purpose: to select the rest of the first list in the rest of a list
cdar : 
((cons (cons Z (listof Y)) (listof X))
 ->
 (listof Y))
Purpose: to select the rest of a non-empty list in a list
cddar : 
((cons (cons W (cons Z (listof Y))) (listof X))
 ->
 (listof Y))
Purpose: to select the rest of the rest of the first list of a list
cdddr : 
((cons W (cons Z (cons Y (listof X))))
 ->
 (listof X))
Purpose: to select the rest of the rest of the rest of a list
cddr : ((cons Z (cons Y (listof X))) -> (listof X))
Purpose: to select the rest of the rest of a list
cdr : ((cons Y (listof X)) -> (listof X))
Purpose: to select the rest of a non-empty list
cons : (X (listof X) -> (listof X))
Purpose: to construct a list
cons? : (any -> boolean)
Purpose: to determine whether some value is a constructed list
eighth : ((listof Y) -> Y)
Purpose: to select the eighth item of a non-empty list
empty? : (any -> boolean)
Purpose: to determine whether some value is the empty list
fifth : ((listof Y) -> Y)
Purpose: to select the fifth item of a non-empty list
first : ((cons Y (listof X)) -> Y)
Purpose: to select the first item of a non-empty list
fourth : ((listof Y) -> Y)
Purpose: to select the fourth item of a non-empty list
length : ((listof any) -> number)
Purpose: to compute the number of items on a list
list : (any ... -> (listof any))
Purpose: to construct a list of its arguments
list* : (any ... (listof any) -> (listof any))
Purpose: to construct a list by adding multiple items to a list
list-ref : ((listof X) natural-number -> X)
Purpose: to extract the indexed item from the list
make-list : (natural-number any -> (listof any))
Purpose: (make-list k x) constructs a list of k copies of x
member : (any (listof any) -> boolean)
Purpose: to determine whether some value is on the list (comparing values with equal?)
member? : (any (listof any) -> boolean)
Purpose: to determine whether some value is on the list (comparing values with equal?)
memq : (any (listof any) -> (union false list))
Purpose: to determine whether some value is on some list if so, it produces the suffix of the list that starts with x if not, it produces false. (It compares values with the eq? predicate.)
memv : (any (listof any) -> (union false list))
Purpose: to determine whether some value is on the list if so, it produces the suffix of the list that starts with x if not, it produces false. (it compares values with the eqv? predicate.)
null : empty
Purpose: the empty list
null? : (any -> boolean)
Purpose: to determine whether some value is the empty list
pair? : (any -> boolean)
Purpose: to determine whether some value is a constructed list
remove : (any (listof any) -> (listof any))
Purpose: to construct a list like the given one with the first occurrence of the given item removed (comparing values with equal?)
rest : ((cons Y (listof X)) -> (listof X))
Purpose: to select the rest of a non-empty list
reverse : ((listof any) -> list)
Purpose: to create a reversed version of a list
second : ((cons Z (cons Y (listof X))) -> Y)
Purpose: to select the second item of a non-empty list
seventh : ((listof Y) -> Y)
Purpose: to select the seventh item of a non-empty list
sixth : ((listof Y) -> Y)
Purpose: to select the sixth item of a non-empty list
third : ((cons W (cons Z (cons Y (listof X)))) -> Y)
Purpose: to select the third item of a non-empty list

2.3.5 Posns

make-posn : (number number -> posn)
Purpose: to construct a posn
posn : signature
Purpose: signature for posns
posn-x : (posn -> number)
Purpose: to extract the x component of a posn
posn-y : (posn -> number)
Purpose: to extract the y component of a posn
posn? : (anything -> boolean)
Purpose: to determine if its input is a posn

2.3.6 Characters

char->integer : (char -> integer)
Purpose: to lookup the number that corresponds to the given character in the ASCII table (if any)
char-alphabetic? : (char -> boolean)
Purpose: to determine whether a character represents an alphabetic character
char-ci<=? : (char char char ... -> boolean)
Purpose: to determine whether a character precedes another (or is equal to it) in a case-insensitive manner
char-ci<? : (char char char ... -> boolean)
Purpose: to determine whether a character precedes another in a case-insensitive manner
char-ci=? : (char char char ... -> boolean)
Purpose: to determine whether two characters are equal in a case-insensitive manner
char-ci>=? : (char char char ... -> boolean)
Purpose: to determine whether a character succeeds another (or is equal to it) in a case-insensitive manner
char-ci>? : (char char char ... -> boolean)
Purpose: to determine whether a character succeeds another in a case-insensitive manner
char-downcase : (char -> char)
Purpose: to determine the equivalent lower-case character
char-lower-case? : (char -> boolean)
Purpose: to determine whether a character is a lower-case character
char-numeric? : (char -> boolean)
Purpose: to determine whether a character represents a digit
char-upcase : (char -> char)
Purpose: to determine the equivalent upper-case character
char-upper-case? : (char -> boolean)
Purpose: to determine whether a character is an upper-case character
char-whitespace? : (char -> boolean)
Purpose: to determine whether a character represents space
char<=? : (char char char ... -> boolean)
Purpose: to determine whether a character precedes another (or is equal to it)
char<? : (char char char ... -> boolean)
Purpose: to determine whether a character precedes another
char=? : (char char char ... -> boolean)
Purpose: to determine whether two characters are equal
char>=? : (char char char ... -> boolean)
Purpose: to determine whether a character succeeds another (or is equal to it)
char>? : (char char char ... -> boolean)
Purpose: to determine whether a character succeeds another
char? : (any -> boolean)
Purpose: to determine whether a value is a character

2.3.7 Strings

explode : (string -> (listof string))
Purpose: to translate a string into a list of 1-letter strings
format : (string any ... -> string)
Purpose: to format a string, possibly embedding values
implode : ((listof string) -> string)
Purpose: to concatenate the list of 1-letter strings into one string
int->string : (integer -> string)
Purpose: to convert an integer in [0,55295] or [57344 1114111] to a 1-letter string
list->string : ((listof char) -> string)
Purpose: to convert a s list of characters into a string
make-string : (nat char -> string)
Purpose: to produce a string of given length from a single given character
replicate : (nat string -> string)
Purpose: to replicate the given string
string : (char ... -> string)
Purpose: (string c1 c2 ...) builds a string
string->int : (string -> integer)
Purpose: to convert a 1-letter string to an integer in [0,55295] or [57344, 1114111]
string->list : (string -> (listof char))
Purpose: to convert a string into a list of characters
string->number : (string -> (union number false))
Purpose: to convert a string into a number, produce false if impossible
string->symbol : (string -> symbol)
Purpose: to convert a string into a symbol
string-alphabetic? : (string -> boolean)
Purpose: to determine whether all ’letters’ in the string are alphabetic
string-append : (string ... -> string)
Purpose: to juxtapose the characters of several strings
string-ci<=? : (string string string ... -> boolean)
Purpose: to determine whether one string alphabetically precedes another (or is equal to it) in a case-insensitive manner
string-ci<? : (string string string ... -> boolean)
Purpose: to determine whether one string alphabetically precedes another in a case-insensitive manner
string-ci=? : (string string string ... -> boolean)
Purpose: to compare two strings character-wise in a case-insensitive manner
string-ci>=? : (string string string ... -> boolean)
Purpose: to determine whether one string alphabetically succeeds another (or is equal to it) in a case-insensitive manner
string-ci>? : (string string string ... -> boolean)
Purpose: to determine whether one string alphabetically succeeds another in a case-insensitive manner
string-copy : (string -> string)
Purpose: to copy a string
string-ith : (string nat -> string)
Purpose: to extract the ith 1-letter substring from the given one
string-length : (string -> nat)
Purpose: to determine the length of a string
string-lower-case? : (string -> boolean)
Purpose: to determine whether all ’letters’ in the string are lower case
string-numeric? : (string -> boolean)
Purpose: to determine whether all ’letters’ in the string are numeric
string-ref : (string nat -> char)
Purpose: to extract the i-the character from a string
string-upper-case? : (string -> boolean)
Purpose: to determine whether all ’letters’ in the string are upper case
string-whitespace? : (string -> boolean)
Purpose: to determine whether all ’letters’ in the string are white space
string<=? : (string string string ... -> boolean)
Purpose: to determine whether one string alphabetically precedes another (or is equal to it)
string<? : (string string string ... -> boolean)
Purpose: to determine whether one string alphabetically precedes another
string=? : (string string string ... -> boolean)
Purpose: to compare two strings character-wise
string>=? : (string string string ... -> boolean)
Purpose: to determine whether one string alphabetically succeeds another (or is equal to it)
string>? : (string string string ... -> boolean)
Purpose: to determine whether one string alphabetically succeeds another
string? : (any -> boolean)
Purpose: to determine whether a value is a string
substring : (string nat nat -> string)
Purpose: to extract the substring starting at a 0-based index up to the second 0-based index (exclusive)

2.3.8 Images

image=? : (image image -> boolean)
Purpose: to determine whether two images are equal
image? : (any -> boolean)
Purpose: to determine whether a value is an image

2.3.9 Misc

=~ : (real real non-negative-real -> boolean)
Purpose: to check whether two real numbers are within some amount (the third argument) of either other
eof : eof
Purpose: the end-of-file value
eof-object? : (any -> boolean)
Purpose: to determine whether some value is the end-of-file value
eq? : (any any -> boolean)
Purpose: to determine whether two values are equivalent from the computer’s perspective (intensional)
equal? : (any any -> boolean)
Purpose: to determine whether two values are structurally equal where basic values are compared with the eqv? predicate
equal~? : (any any non-negative-real -> boolean)
Purpose: to compare like equal? on the first two arguments, except using =~ in the case of real numbers
eqv? : (any any -> boolean)
Purpose: to determine whether two values are equivalent from the perspective of all functions that can be applied to it (extensional)
error : (any ... -> void)
Purpose: to signal an error, combining the given values into an error message. If any of the values’ printed representations is too long, it is truncated and “...” is put into the string. If the first value is a symbol, it is treated specially; it is suffixed with a colon and a space (the intention is that the symbol is the name of the function signalling the error).
exit : (-> void)
Purpose: to exit the running program
identity : (any -> any)
Purpose: to return the argument unchanged
struct? : (any -> boolean)
Purpose: to determine whether some value is a structure

  top← prev  up  next →