suzanne.soy/racket
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

set docs: change the name of the parameter of set-union to avoid shadowing 'set'

Browse Source 
used the name 'st' following the style guide's suggestion of 'lst' for lists
  since it should use the same parameter name everywhere, change this everywhere
  also: rackety
This commit is contained in:
Robby Findler 2011-01-07 20:56:34 -06:00
parent eaa82cc84d
commit 422bb10b53
1 changed files with 62 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

121
collects/scribblings/reference/sets.scrbl
View File

@ -7,14 +7,14 @@
@(interaction-eval #:eval set-eval (require racket/set)) @(interaction-eval #:eval set-eval (require racket/set))
A @deftech{set} represents a set of distinct elements. For a given A @deftech{set} represents a set of distinct elements. For a given
set, elements are equivalent via @scheme[equal?], @scheme[eqv?], or set, elements are equivalent via @racket[equal?], @racket[eqv?], or
@scheme[eq?]. Two sets are @scheme[equal?] when they use the same @racket[eq?]. Two sets are @racket[equal?] when they use the same
element-comparison procedure (@scheme[equal?], @scheme[eqv?], or element-comparison procedure (@racket[equal?], @racket[eqv?], or
@scheme[eq?]) and have equivalent elements. @racket[eq?]) and have equivalent elements.
A set can be used as a single-valued sequence (see A set can be used as a single-valued sequence (see
@secref["sequences"]). The elements of the set serve as elements @secref["sequences"]). The elements of the set serve as elements
of the sequence. See also @scheme[in-set]. of the sequence. See also @racket[in-set].
Operations on sets that contain elements that are mutated are Operations on sets that contain elements that are mutated are
unpredictable in much the same way that @tech{hash table} operations are unpredictable in much the same way that @tech{hash table} operations are
@ -24,18 +24,18 @@ unpredictable when keys are mutated.
@defproc[(set? [v any/c]) boolean?]{ @defproc[(set? [v any/c]) boolean?]{
Returns @scheme[#t] if @scheme[v] is a @tech{set}, @scheme[#f] Returns @racket[#t] if @racket[v] is a @tech{set}, @racket[#f]
otherwise.} otherwise.}
@defproc[(set-eqv? [set set?]) boolean?]{ @defproc[(set-eqv? [st set?]) boolean?]{
Returns @scheme[#t] if @scheme[set] compares elements with @scheme[eqv?], Returns @racket[#t] if @racket[st] compares elements with @racket[eqv?],
@scheme[#f] if it compares with @scheme[equal?] or @scheme[eq?].} @racket[#f] if it compares with @racket[equal?] or @racket[eq?].}
@defproc[(set-eq? [set set?]) boolean?]{ @defproc[(set-eq? [st set?]) boolean?]{
Returns @scheme[#t] if @scheme[set] compares elements with @scheme[eq?], Returns @racket[#t] if @racket[st] compares elements with @racket[eq?],
@scheme[#f] if it compares with @scheme[equal?] or @scheme[eqv?].} @racket[#f] if it compares with @racket[equal?] or @racket[eqv?].}
@deftogether[( @deftogether[(
@defproc[(set [v any/c] ...) set?] @defproc[(set [v any/c] ...) set?]
@ -43,51 +43,51 @@ Returns @scheme[#t] if @scheme[set] compares elements with @scheme[eq?],
@defproc[(seteq [v any/c] ...) set?] @defproc[(seteq [v any/c] ...) set?]
)]{ )]{
Creates a set that uses @scheme[equal?], @scheme[eq?], or Creates a set that uses @racket[equal?], @racket[eq?], or
@scheme[eqv?], respectively, to compare elements. The given @racket[eqv?], respectively, to compare elements. The given
@scheme[v]s are added to the set. The elements are added in the order @racket[v]s are added to the set. The elements are added in the order
that they appear as @scheme[v]s, so in the first two cases, an earlier that they appear as @racket[v]s, so in the first two cases, an earlier
element that is @scheme[equal?] or @scheme[eqv?] but not @scheme[eq?] element that is @racket[equal?] or @racket[eqv?] but not @racket[eq?]
to a later element takes precedence over the later element.} to a later element takes precedence over the later element.}
@defproc[(set-empty? [set set?]) boolean?]{ @defproc[(set-empty? [st set?]) boolean?]{
Returns @scheme[#t] if @scheme[set] has no members, @scheme[#f] Returns @racket[#t] if @racket[st] has no members, @racket[#f]
otherwise.} otherwise.}
@defproc[(set-count [set set?]) exact-nonnegative-integer?]{ @defproc[(set-count [st set?]) exact-nonnegative-integer?]{
Returns the number of elements in @scheme[set].} Returns the number of elements in @racket[st].}
@defproc[(set-member? [set set?] [v any/c]) boolean?]{ @defproc[(set-member? [st set?] [v any/c]) boolean?]{
Returns @scheme[#t] if @scheme[v] is in @scheme[set], @scheme[#f] Returns @racket[#t] if @racket[v] is in @racket[st], @racket[#f]
otherwise.} otherwise.}
@defproc[(set-add [set set?] [v any/c]) set?]{ @defproc[(set-add [st set?] [v any/c]) set?]{
@margin-note{Like operations on immutable hash tables, ``constant @margin-note{Like operations on immutable hash tables, ``constant
time'' set operations actually require @math{O(log N)} time for a set time'' set operations actually require @math{O(log N)} time for a set
of size @math{N}.} of size @math{N}.}
Produces a set that includes @scheme[v] plus all elements of Produces a set that includes @racket[v] plus all elements of
@scheme[set]. This operation runs in constant time.} @racket[st]. This operation runs in constant time.}
@defproc[(set-remove [set set?] [v any/c]) set?]{ @defproc[(set-remove [st set?] [v any/c]) set?]{
Produces a set that includes all elements of @scheme[set] except Produces a set that includes all elements of @racket[st] except
@scheme[v]. This operation runs in constant time.} @racket[v]. This operation runs in constant time.}
@defproc[(set-union [set set?] ...+) set?]{ @defproc[(set-union [st set?] ...+) set?]{
Produces a set that includes all elements of all given @scheme[set]s, Produces a set that includes all elements of all given @racket[st]s,
which must all use the same equivalence predicate (@scheme[equal?], which must all use the same equivalence predicate (@racket[equal?],
@scheme[eq?], or @scheme[eqv?]). This operation runs in time @racket[eq?], or @racket[eqv?]). This operation runs in time
proportional to the total size of all given @scheme[set]s except for proportional to the total size of all given @racket[st]s except for
the largest. the largest.
At least one set must be provided to @racket[set-union] even though At least one set must be provided to @racket[set-union] even though
@ -106,54 +106,54 @@ you desire.
]} ]}
@defproc[(set-intersect [set set?] ...+) set?]{ @defproc[(set-intersect [st set?] ...+) set?]{
Produces a set that includes only the elements in all of the given Produces a set that includes only the elements in all of the given
@scheme[set]s, which must all use the same equivalence predicate @racket[st]s, which must all use the same equivalence predicate
(@scheme[equal?], @scheme[eq?], or @scheme[eqv?]). This operation (@racket[equal?], @racket[eq?], or @racket[eqv?]). This operation
runs in time proportional to the total size of all given runs in time proportional to the total size of all given
@scheme[set]s except for the largest.} @racket[st]s except for the largest.}
@defproc[(set-subtract [set set?] ...+) set?]{ @defproc[(set-subtract [st set?] ...+) set?]{
Produces a set that includes all elements the first @scheme[set]s that Produces a set that includes all elements the first @racket[st]s that
are not present in any of the other given @scheme[sets]s. All of the are not present in any of the other given @racket[sts]s. All of the
given @scheme[set]s must use the same equivalence predicate given @racket[st]s must use the same equivalence predicate
(@scheme[equal?], @scheme[eq?], or @scheme[eqv?]). This operation (@racket[equal?], @racket[eq?], or @racket[eqv?]). This operation
runs in time proportional to the total size of all given runs in time proportional to the total size of all given
@scheme[set]s except the first one.} @racket[st]s except the first one.}
@defproc[(subset? [set set?] [set2 set?]) boolean?]{ @defproc[(subset? [st set?] [st2 set?]) boolean?]{
Returns @scheme[#t] if every member of @scheme[set] is in Returns @racket[#t] if every member of @racket[st] is in
@scheme[set2], @scheme[#f] otherwise. The @scheme[set] and @racket[st2], @racket[#f] otherwise. The @racket[st] and
@scheme[set2] must use the same equivalence predicate @racket[st2] must use the same equivalence predicate
(@scheme[equal?], @scheme[eq?], or @scheme[eqv?]). This operation (@racket[equal?], @racket[eq?], or @racket[eqv?]). This operation
runs in time proportional to the size of @scheme[set].} runs in time proportional to the size of @racket[st].}
@defproc[(set-map [set set?] @defproc[(set-map [st set?]
[proc (any/c . -> . any/c)]) [proc (any/c . -> . any/c)])
(listof any/c)]{ (listof any/c)]{
Applies the procedure @scheme[proc] to each element in Applies the procedure @racket[proc] to each element in
@scheme[set] in an unspecified order, accumulating the results @racket[st] in an unspecified order, accumulating the results
into a list.} into a list.}
@defproc[(set-for-each [set set?] @defproc[(set-for-each [st set?]
[proc (any/c . -> . any)]) [proc (any/c . -> . any)])
void?]{ void?]{
Applies @scheme[proc] to each element in @scheme[set] (for the Applies @racket[proc] to each element in @racket[st] (for the
side-effects of @scheme[proc]) in an unspecified order.} side-effects of @racket[proc]) in an unspecified order.}
@defproc[(in-set [set set?]) sequence?]{ @defproc[(in-set [st set?]) sequence?]{
Explicitly converts a set to a sequence for use with @scheme[for] and Explicitly converts a set to a sequence for use with @racket[for] and
other forms.} other forms.}
@deftogether[( @deftogether[(
@ -165,7 +165,10 @@ other forms.}
@defform[(for*/seteqv (for-clause ...) body ...+)] @defform[(for*/seteqv (for-clause ...) body ...+)]
)]{ )]{
Analogous to @scheme[for/list] and @scheme[for*/list], but to Analogous to @racket[for/list] and @racket[for*/list], but to
construct a set instead of a list.} construct a set instead of a list.}
@close-eval[set-eval] @close-eval[set-eval]
@(define i #'set)
@(define i2 #'set-union)