5.16 Primitive Operations

top← prev up next →

5.16 Primitive Operations

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

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

(case->

(integer -> integer)

(-> (and/c real inexact? (>/c 0) (</c 1))))

Purpose: to generate a random natural number less than some given integer, or to generate a random inexact number between 0.0 and 1.0 exclusive

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

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

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

5.16.4 Lists

append : ((listof any) ... -> (listof any))

Purpose: to create a single list from several

assoc : (any (listof any) -> (listof any) or false)

Purpose: to produce the first element on the list whose first is equal? to v; otherwise it produces false

assq

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

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

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

list? : (any -> boolean)

Purpose: to determine whether some value is a 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

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

set-posn-x! : (posn number -> void)

Purpose: to update the x component of a posn

set-posn-y! : (posn number -> void)

Purpose: to update the x component of a posn

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

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

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

5.16.9 Misc

=~ : (number number non-negative-real -> boolean)

Purpose: to check whether two numbers are within some amount (the third argument) of either other

current-milliseconds : (-> exact-integer)

Purpose: to return the current “time” in fixnum milliseconds (possibly negative)

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

force : (delay -> any)

Purpose: to find the delayed value; see also delay

gensym : (-> symbol?)

Purpose: to generate a new symbol, different from all symbols in the program

identity : (any -> any)

Purpose: to return the argument unchanged

promise? : (any -> boolean)

Purpose: to determine if a value is delayed

sleep : (-> positive-number void)

Purpose: to cause the program to sleep for the given number of seconds

struct? : (any -> boolean)

Purpose: to determine whether some value is a structure

void : (-> void)

Purpose: produces a void value

void? : (any -> boolean)

Purpose: to determine if a value is void

5.16.10 Numbers (relaxed conditions)

* : (number ... -> number)

Purpose: to multiply all given numbers

+ : (number ... -> number)

Purpose: to add all given numbers

- : (number ... -> number)

Purpose: to subtract from the first all remaining numbers

/ : (number ... -> number)

Purpose: to divide the first by all remaining numbers

5.16.11 Higher-Order Functions

andmap : ((X -> boolean) (listof X) -> boolean)

Purpose: (andmap p (list x-1 ... x-n)) = (and (p x-1) ... (p x-n))

apply

((X-1 ... X-N -> Y)

X-1

...

X-i

(list X-i+1 ... X-N)

Purpose: to apply a function using items from a list as the arguments

argmax : ((X -> real) (listof X) -> X)

Purpose: to find the (first) element of the list that maximizes the output of the function

argmin : ((X -> real) (listof X) -> X)

Purpose: to find the (first) element of the list that minimizes the output of the function

build-list : (nat (nat -> X) -> (listof X))

Purpose: (build-list n f) = (list (f 0) ... (f (- n 1)))

build-string : (nat (nat -> char) -> string)

Purpose: (build-string n f) = (string (f 0) ... (f (- n 1)))

compose

((Y-1 -> Z)

...

(Y-N -> Y-N-1)

(X-1 ... X-N -> Y-N)

(X-1 ... X-N -> Z))

Purpose: to compose a sequence of procedures into a single procedure

filter : ((X -> boolean) (listof X) -> (listof X))

Purpose: to construct a list from all those items on a list for which the predicate holds

foldl : ((X Y -> Y) Y (listof X) -> Y)

Purpose: (foldl f base (list x-1 ... x-n)) = (f x-n ... (f x-1 base))

foldr : ((X Y -> Y) Y (listof X) -> Y)

Purpose: (foldr f base (list x-1 ... x-n)) = (f x-1 ... (f x-n base))

for-each : ((any ... -> any) (listof any) ... -> void)

Purpose: to apply a function to each item on one or more lists for effect only

map : ((X ... -> Z) (listof X) ... -> (listof Z))

Purpose: to construct a new list by applying a function to each item on one or more existing lists

memf

((X -> boolean)

(listof X)

(union false (listof X)))

Purpose: to determine whether the first argument produces true for some value in the second argument

ormap : ((X -> boolean) (listof X) -> boolean)

Purpose: (ormap p (list x-1 ... x-n)) = (or (p x-1) ... (p x-n))

procedure? : (any -> boolean)

Purpose: to determine if a value is a procedure

quicksort : ((listof X) (X X -> boolean) -> (listof X))

Purpose: to construct a list from all items on a list in an order according to a predicate

sort : ((listof X) (X X -> boolean) -> (listof X))

Purpose: to construct a list from all items on a list in an order according to a predicate

5.16.12 Reading and Printing

display : (any -> void)

Purpose: to print the argument to stdout (without quotes on symbols and strings, etc.)

newline : (-> void)

Purpose: to print a newline to stdout

pretty-print : (any -> void)

Purpose: like write, but with standard newlines and indentation

print : (any -> void)

Purpose: to print the argument as a value to stdout

printf : (string any ... -> void)

Purpose: to format the rest of the arguments according to the first argument and print it to stdout

read : (-> sexp)

Purpose: to read input from the user

with-input-from-file : (string (-> any) -> any)

Purpose: to open the named input file and to extract all input from there

with-input-from-string : (string (-> any) -> any)

Purpose: to turn the given string into input for read* operations

with-output-to-file : (string (-> any) -> any)

Purpose: to open the named output file and to put all output there

with-output-to-string : (string (-> any) -> any)

Purpose: to produce a string from all write/display/print operations

write : (any -> void)

Purpose: to print the argument to stdout (in a traditional style that is somewhere between print and display)

5.16.13 Vectors

build-vector : (nat (nat -> X) -> (vectorof X))

Purpose: to construct a vector

make-vector : (number X -> (vectorof X))

Purpose: to construct a vector

vector : (X ... -> (vector X ...))

Purpose: to construct a vector

vector-length : ((vector X) -> nat)

Purpose: to determine the length of a vector

vector-ref : ((vector X) nat -> X)

Purpose: to extract an element from a vector

vector-set! : ((vectorof X) nat X -> void)

Purpose: to update a vector

vector? : (any -> boolean)

Purpose: to determine if a value is a vector

5.16.14 Boxes

box : (any -> box)

Purpose: to construct a box

box? : (any -> boolean)

Purpose: to determine if a value is a box

set-box! : (box any -> void)

Purpose: to update a box

unbox : (box -> any)

Purpose: to extract the boxed value

5.16.15 Hash Tables

hash-copy : (hash -> hash)

Purpose: to copy a hash table

hash-count : (hash -> integer)

Purpose: to determine the number of keys mapped by a hash table

hash-eq? : (hash -> boolean)

Purpose: to determine if a hash table uses eq? for comparisions

hash-equal? : (hash -> boolean)

Purpose: to determine if a hash table uses equal? for comparisions

hash-eqv? : (hash -> boolean)

Purpose: to determine if a hash table uses eqv? for comparisions

hash-for-each : ((hash X Y) (X Y -> any) -> void)

Purpose: to apply a function to each mapping of a hash table for effect only

hash-has-key? : ((hash X Y) X -> boolean)

Purpose: to determine if a key is associated with a value in a hash table

hash-map : ((hash X Y) (X Y -> A) -> (listof A))

Purpose: to construct a new list by applying a function to each mapping of a hash table

hash-ref

(case->

((hash X Y) X -> Y)

((hash X Y) X Y -> Y)

((hash X Y) X (-> Y) -> Y))

Purpose: to extract the value associated with a key from a hash table; the three argument case allows a default value or default value computation

hash-ref!

(case->

((hash X Y) X Y -> Y)

((hash X Y) X (-> Y) -> Y))

Purpose: to extract the value associated with a key from a mutable hash table; if the key does not have an mapping, the third argument is used as the value (or used to compute the value) and is added to the hash table associated with the key

hash-remove : ((hash X Y) X -> (hash X Y))

Purpose: to construct an immutable hash table with one less mapping than an existing immutable hash table

hash-remove! : ((hash X Y) X -> void)

Purpose: to remove an mapping from a mutable hash table

hash-set : ((hash X Y) X Y -> (hash X Y))

Purpose: to construct an immutable hash table with one new mapping from an existing immutable hash table

hash-set! : ((hash X Y) X Y -> void)

Purpose: to update a mutable hash table with a new mapping

hash-update

(case->

((hash X Y) X (Y -> Y) -> (hash X Y))

((hash X Y) X (Y -> Y) Y -> (hash X Y))

((hash X Y) X (Y -> Y) (-> Y) -> (hash X Y)))

Purpose: to compose hash-ref and hash-set to update an existing mapping; the third argument is used to compute the new mapping value; the fourth argument is used as the third argument to hash-ref

hash-update!

(case->

((hash X Y) X (Y -> Y) -> void)

((hash X Y) X (Y -> Y) Y -> void)

((hash X Y) X (Y -> Y) (-> Y) -> void))

Purpose: to compose hash-ref and hash-set! to update an existing mapping; the third argument is used to compute the new mapping value; the fourth argument is used as the third argument to hash-ref

hash? : (any -> boolean)

Purpose: to determine if a value is a hash table

make-hash

(case->

(-> (hash X Y))