Cycles are an immutable ordered, but unindexed, container type similar to circular lists.
The idea is to make a cycle type disjoint from the other types, only interface is standardized. Scheme implementations are free to use any underlying structure to achieve it.
(make-cycle list)
Constructs and returns a new cycle whose elements are the elements of list.
(cycle element ...)
Constructs and returns a new cycle containing elements.
(cycle->list cycle)
Constructs and returns a list whose elements are those of cycle.
(cycle? obj)
Returns #t if obj is a cycle, and otherwise returns #f.
(cycle-length cycle)
Returns the number of elements in cycle.
(cycle-front cycle)
Returns the element in front of cycle.
(cycle-remove-front cycle)
cycle-remove-front returns a cycle obtained from cycle where the front element has been removed.
(cycle-rotate cycle k)
cycle-rotate returns a cycle obtained from cycle by a rotation of k, which is an exact integer. If k is positive, the rotation is forward; if k is negative, the rotation is backward; if k is zero, there is no rotation.
(cycle-insert cycle obj)
Return a cycle where obj is put in front in cycle.
(cycle=? equivalence cycle1 cycle2)
Return #t if cycle1 and cycle2 contain the same values (in the sense of the equivalence predicate) in the same order, independent of their rotations; otherwise return #f.
Example: (cycle=? (make-cycle 1 2 3) (make-cycle 3 1 2)) => t
(cycle-map proc cycle ...)
All cycles must have the same length, and proc must be a procedure taking as many arguments as there are cycles and returning a single value. cycle-map applies proc to the elements of the cycle(s) and returns a newly allocated cycle of the corresponding results.
(cycle-for-each proc cycle ...)
All cycles must have the same length, and proc must be a procedure taking as many arguments as there are cycles. cycle-for-each applies proc to the elements of the cycle(s) and discards any results.
(cycle-fold proc nil cycle ...)
All cycles must have the same length, and proc must be a procedure taking as many arguments as there are cycles, plus one additional argument, and returning a single value. cycle-fold applies proc to the elements of the cycle(s) and the value previously returned by proc. On the first call to proc, the additional argument is nil. Returns the result of the final call to proc.
(cycle-unfold continue? successor mapper seed)
Start with an empty list. If the result of applying the predicate continue? to seed is #f, apply make-cycle to the reversed list and return the result. Otherwise, apply the procedure mapper to seed. The value of mapper is prepended onto the list. Then get a new seed by applying the procedure successor to seed, and repeat this algorithm.
The cycle composed of elements 1, 2 and 3 with 1 in front can be written as following:
#cycle(1 2 3)