2.3 Primitive Operations

► |  | How to Design Programs Languages

1 | Beginning Student
2 | Beginning Student with List Abbreviations
3 | Intermediate Student
4 | Intermediate Student with Lambda
5 | Advanced Student
| Index

▼ | 2 | Beginning Student with List Abbreviations

2.1 | Quote
2.2 | Quasiquote
2.3 | Primitive Operations
2.4 | Unchanged Forms

► | 2.3 | Primitive Operations

2.3.1 | Numbers: Integers, Rationals, Reals, Complex, Exacts, Inexacts
2.3.2 | Booleans
2.3.3 | Symbols
2.3.4 | Lists
2.3.5 | Posns
2.3.6 | Characters
2.3.7 | Strings
2.3.8 | Images
2.3.9 | Misc

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 →