(
boolean-hash
obj
)
⟹
integer?

boolean-hash, char-hash, char-ci-hash string-hash, string-ci-hash, symbol-hash, number-hash These are hash functions for some standard Scheme types, suitable for passing to make-comparator. Users may write their own hash functions with the same signature. However, if programmers wish their hash functions to be backward compatible with the reference implementation of SRFI 69, they are advised to write their hash functions to accept a second argument and ignore it. These are suitable hash functions for the specified types. The hash functions char-ci-hash and string-ci-hash treat their argument case-insensitively. Note that while symbol-hash may return the hashed value of applying symbol->string and then string-hash to the symbol, this is not a requirement.

(
bytevector-length
[
bytevector?
bytevector
]
)
⟹
integer?

Returns the length of bytevector in bytes as an exact integer.

(
bytevector-u8-ref
[
bytevector?
bytevector
]
[
integer?
k
]
)
⟹
integer?

It is an error if k is not a valid index of bytevector. Returns the kth byte of bytevector.

floor, ceiling, truncate, round These procedures return integers. The floor procedure returns the largest integer not larger than x. The ceiling procedure returns the smallest integer not smaller than x, truncate returns the integer closest to x whose absolute value is not larger than the absolute value of x, and round returns the closest integer to x, rounding to even when x is halfway between two integers. Rationale: The round procedure rounds to even for consistency with the default rounding mode specified by the IEEE 754 IEEE floating-point standard. Note: If the argument to one of these procedures is inexact, then the result will also be inexact. If an exact value is needed, the result can be passed to the exact procedure. If the argument is infinite or a NaN, then it is returned.

Given a Unicode character, char->integer returns an exact integer between 0 and #xD7FF or between #xE000 and #x10FFFF which is equal to the Unicode scalar value of that character. Given a non-Unicode character, it returns an exact integer greater than #x10FFFF. This is true independent of whether the implementation uses the Unicode representation internally. Given an exact integer that is the value returned by a character when char->integer is applied to it, integer->char returns that character.

(
char-ci-hash
obj
)
⟹
integer?

(
char-hash
obj
)
⟹
integer?

(
comparator-hash
[
comparator?
comparator
]
obj
)
⟹
integer?

Invokes the hash function of comparator on obj and returns what it returns. More convenient than comparator-hash-function, but less efficient when the function is called repeatedly. Note: No invokers are required for the equality and ordering predicates, because =? and <? serve this function.

(
count
[
procedure?
pred
]
[
list?
clist1
]
[
list?
clist2
]
...
)
⟹
integer?

pred
⟹
(
λ
obj
...
)
⟹
*

pred is a procedure taking as many arguments as there are lists and returning a single value. It is applied element-wise to the elements of the lists, and a count is tallied of the number of elements that produce a true value. This count is returned. count is "iterative" in that it is guaranteed to apply pred to the list elements in a left-to-right order. The counting stops when the shortest list expires. At least one of the argument lists must be finite.

(
current-jiffy
)
⟹
integer?

Returns the number of jiffies as an exact integer that have elapsed since an arbitrary, implementation-defined epoch. A jiffy is an implementation-defined fraction of a second which is defined by the return value of the jiffies-per-second procedure. The starting epoch is guaranteed to be constant during a run of the program, but may vary between runs. Rationale: Jiffies are allowed to be implementation-dependent so that current-jiffy can execute with minimum overhead. It should be very likely that a compactly represented integer will suffice as the returned value. Any particular jiffy size will be inappropriate for some implementations: a microsecond is too long for a very fast machine, while a much smaller unit would force many implementations to return integers which have to be allocated for most calls, rendering current-jiffy less useful for accurate timing measurements.

(
current-second
)
⟹
real?

Returns an inexact number representing the current time on the International Atomic Time (TAI) scale. The value 0.0 represents midnight on January 1, 1970 TAI (equivalent to ten seconds before midnight Universal Time) and the value 1.0 represents one TAI second later. Neither high accuracy nor high precision are required; in particular, returning Coordinated Universal Time plus a suitable constant might be the best an implementation can do.

(
default-hash
obj
)
⟹
integer?

This is the hash function used by default comparators, which accepts a Scheme value and hashes it in some implementation-defined way, subject to the following conditions:
1 When applied to a pair, it must return the result of hashing together the values returned by default-hash when applied to the car and the cdr.
2 When applied to a boolean, character, string, symbol, or number, it must return the same result as boolean-hash, char-hash, string-hash, symbol-hash, or number-hash respectively.
3 When applied to a list or vector, it must return the result of hashing together the values returned by default-hash when applied to each of the elements.

numerator, denominator These procedures return the numerator or denominator of their argument; the result is computed as if the argument was represented as a fraction in lowest terms. The denominator is always positive. The denominator of 0 is defined to be 1.

This procedure returns the numeric value (0 to 9) of its argument if it is a numeric digit (that is, if char-numeric? returns #t), or #f on any other character.

Returns two non-negative exact integers s and r where k = s^2 + r and k < (s + 1)^2.

floor/, floor-quotient, floor-remainder, truncate/, truncate-quotient, truncate-remainder These procedures implement number-theoretic (integer) division. It is an error if n2 is zero. The procedures ending in / return two integers; the other procedures return an integer. All the procedures compute a quotient nq and remainder nr such that n1 = n2 * nq + nr.

gcd, lcm These procedures return the greatest common divisor or least common multiple of their arguments. The result is always non-negative.

(
generator->vector!
[
vector?
vector
]
[
integer?
at
]
[
procedure?
generator
]
)
⟹
integer?

generator
⟹
(
λ
)
⟹
*

(
generator-count
[
procedure?
pred
]
[
procedure?
generator
]
)
⟹
integer?

pred
⟹
(
λ
element
)
⟹
boolean?

generator
⟹
(
λ
)
⟹
*

(
hash-bound
)
⟹
integer?

Hash functions should be written so as to return a number between 0 and the largest reasonable number of elements (such as hash buckets) a data structure in the implementation might have. What that value is depends on the implementation. This value provides the current bound as a positive exact integer, typically for use by user-written hash functions. However, they are not required to bound their results in this way.

(
hash-salt
)
⟹
integer?

A salt is random data in the form of a non-negative exact integer used as an additional input to a hash function in order to defend against dictionary attacks, or (when used in hash tables) against denial-of-service attacks that overcrowd certain hash buckets, increasing the amortized O(1) lookup time to O(n). Salt can also be used to specify which of a family of hash functions should be used for purposes such as cuckoo hashing. This macro provides the current value of the salt, typically for use by user-written hash functions. However, they are not required to make use of the current salt.
The initial value is implementation-dependent, but must be less than the value of (hash-bound), and should be distinct for distinct runs of a program unless otherwise specified by the implementation. Implementations may provide a means to specify the salt value to be used by a particular invocation of a hash function.

(
hash-table-count
[
procedure?
pred
]
[
hash-table?
hash-table
]
)
⟹
integer?

pred
⟹
(
λ
key
value
)
⟹
boolean?

(
hash-table-size
[
hash-table?
hash-table
]
)
⟹
integer?

(
jiffies-per-second
)
⟹
integer?

Returns an exact integer representing the number of jiffies per SI second. This value is an implementation-specified constant.